OSGVector.h

Go to the documentation of this file.
00001 /*---------------------------------------------------------------------------*\
00002  *                                OpenSG                                     *
00003  *                                                                           *
00004  *                                                                           *
00005  *             Copyright (C) 2000-2003 by the OpenSG Forum                   *
00006  *                                                                           *
00007  *                            www.opensg.org                                 *
00008  *                                                                           *
00009  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
00010  *                                                                           *
00011 \*---------------------------------------------------------------------------*/
00012 /*---------------------------------------------------------------------------*\
00013  *                                License                                    *
00014  *                                                                           *
00015  * This library is free software; you can redistribute it and/or modify it   *
00016  * under the terms of the GNU Library General Public License as published    *
00017  * by the Free Software Foundation, version 2.                               *
00018  *                                                                           *
00019  * This library is distributed in the hope that it will be useful, but       *
00020  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
00021  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
00022  * Library General Public License for more details.                          *
00023  *                                                                           *
00024  * You should have received a copy of the GNU Library General Public         *
00025  * License along with this library; if not, write to the Free Software       *
00026  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
00027  *                                                                           *
00028 \*---------------------------------------------------------------------------*/
00029 /*---------------------------------------------------------------------------*\
00030  *                                Changes                                    *
00031  *                                                                           *
00032  *                                                                           *
00033  *                                                                           *
00034  *                                                                           *
00035  *                                                                           *
00036  *                                                                           *
00037 \*---------------------------------------------------------------------------*/
00038 
00039 #ifndef _OSGVECTOR_H_
00040 #define _OSGVECTOR_H_
00041 #ifdef __sgi
00042 #pragma once
00043 #endif
00044 
00045 #include "OSGBaseTypes.h"
00046 #include "OSGBaseFunctions.h"
00047 
00048 #include <iostream>
00049 
00050 OSG_BEGIN_NAMESPACE
00051 
00052 template<class ValueTypeT, class StorageInterfaceT>
00053 class PointInterface;
00054 
00055 template<class ValueTypeT, class StorageInterfaceT>
00056 class VectorInterface;
00057 
00058 
00059 #ifdef __sgi
00060 #pragma set woff 1209
00061 #endif
00062 
00063 //---------------------------------------------------------------------------
00064 //  Class
00065 //---------------------------------------------------------------------------
00066 
00072 template <class ValueTypeT>
00073 class VecStorage1
00074 {
00075     /*==========================  PUBLIC  =================================*/
00076 
00077   public:
00078 
00079     static const UInt32 _uiSize = 1;
00080 
00081     /*---------------------------------------------------------------------*/
00085     VecStorage1(void);
00086 
00088     /*---------------------------------------------------------------------*/
00092     ~VecStorage1(void);
00093 
00095     /*---------------------------------------------------------------------*/
00099     void       setValues        (const ValueTypeT  rVal1);
00100 
00101     void       getSeparateValues(      ValueTypeT &rVal1) const;
00102 
00103     ValueTypeT x                (void                   ) const;
00104 
00106     /*=========================  PROTECTED  ===============================*/
00107 
00108   protected:
00109 
00110     ValueTypeT _values[_uiSize];
00111 
00112     /*==========================  PRIVATE  ================================*/
00113 
00114   private:
00115 
00117     VecStorage1(const VecStorage1 &source);
00119     void operator =(const VecStorage1 &source);
00120 };
00121 
00122 
00123 //---------------------------------------------------------------------------
00124 //  Class
00125 //---------------------------------------------------------------------------
00126 
00132 template <class ValueTypeT>
00133 class VecStorage2
00134 {
00135     /*==========================  PUBLIC  =================================*/
00136 
00137   public:
00138 
00139     static const UInt32 _uiSize = 2;
00140 
00141     /*---------------------------------------------------------------------*/
00145     VecStorage2(void);
00146 
00148     /*---------------------------------------------------------------------*/
00152     ~VecStorage2(void);
00153 
00155     /*---------------------------------------------------------------------*/
00159     void       setValues        (const ValueTypeT  rVal1, 
00160                                  const ValueTypeT  rVal2);
00161 
00162     void       getSeparateValues(      ValueTypeT &rVal1, 
00163                                        ValueTypeT &rVal2) const;
00164 
00165     ValueTypeT x                (void                   ) const;
00166     ValueTypeT y                (void                   ) const;
00167 
00169     /*=========================  PROTECTED  ===============================*/
00170 
00171   protected:
00172 
00173     ValueTypeT _values[_uiSize];
00174 
00175     /*==========================  PRIVATE  ================================*/
00176 
00177   private:
00178 
00180     VecStorage2(const VecStorage2 &source);
00182     void operator =(const VecStorage2 &source);
00183 };
00184 
00185 
00186 
00187 
00188 //---------------------------------------------------------------------------
00189 //  Class
00190 //---------------------------------------------------------------------------
00191 
00197 template <class ValueTypeT>
00198 class VecStorage3
00199 {
00200     /*==========================  PUBLIC  =================================*/
00201 
00202   public:
00203 
00204     static const UInt32 _uiSize = 3;
00205 
00206     /*---------------------------------------------------------------------*/
00210     VecStorage3(void);
00211 
00213     /*---------------------------------------------------------------------*/
00217     ~VecStorage3(void);
00218 
00220     /*---------------------------------------------------------------------*/
00224     void       setValues        (const ValueTypeT  rVal1,
00225                                  const ValueTypeT  rVal2,
00226                                  const ValueTypeT  rVal3);
00227 
00228     void       getSeparateValues(      ValueTypeT &rVal1,
00229                                        ValueTypeT &rVal2,
00230                                        ValueTypeT &rVal3) const;
00231 
00232     ValueTypeT x                (void                   ) const;
00233     ValueTypeT y                (void                   ) const;
00234     ValueTypeT z                (void                   ) const;
00235 
00237     /*=========================  PROTECTED  ===============================*/
00238 
00239   protected:
00240 
00241     ValueTypeT _values[_uiSize];
00242 
00243     /*==========================  PRIVATE  ================================*/
00244 
00245   private:
00246 
00248     VecStorage3(const VecStorage3 &source);
00250     void operator =(const VecStorage3 &source);
00251 };
00252 
00253 
00254 
00255 
00256 //---------------------------------------------------------------------------
00257 //  Class
00258 //---------------------------------------------------------------------------
00259 
00265 template <class ValueTypeT>
00266 class VecStorage4
00267 {
00268     /*==========================  PUBLIC  =================================*/
00269 
00270   public:
00271 
00272     static const UInt32 _uiSize = 4;
00273 
00274     /*---------------------------------------------------------------------*/
00278     VecStorage4(void);
00279 
00281     /*---------------------------------------------------------------------*/
00285     ~VecStorage4(void);
00286 
00288     /*---------------------------------------------------------------------*/
00292     void       setValues        (const ValueTypeT  rVal1,
00293                                  const ValueTypeT  rVal2,
00294                                  const ValueTypeT  rVal3,
00295                                  const ValueTypeT  rVal4);
00296 
00297     void       getSeparateValues(      ValueTypeT &rVal1,
00298                                        ValueTypeT &rVal2,
00299                                        ValueTypeT &rVal3,
00300                                        ValueTypeT &rVal4) const;
00301 
00302     ValueTypeT x                (void                   ) const;
00303     ValueTypeT y                (void                   ) const;
00304     ValueTypeT z                (void                   ) const;
00305     ValueTypeT w                (void                   ) const;
00306 
00308     /*=========================  PROTECTED  ===============================*/
00309 
00310   protected:
00311 
00312     ValueTypeT _values[_uiSize];
00313 
00314     /*==========================  PRIVATE  ================================*/
00315 
00316   private:
00317 
00319     VecStorage4(const VecStorage4 &source);
00321     void operator =(const VecStorage4 &source);
00322 };
00323 
00324 
00325 
00326 
00327 //---------------------------------------------------------------------------
00328 //  Class
00329 //---------------------------------------------------------------------------
00330 
00336 #ifdef __sgi
00337 #pragma set woff 1375
00338 #endif
00339 
00340 template<class ValueTypeT, class StorageInterfaceT>
00341 class PointInterface : public StorageInterfaceT
00342 {
00343     /*==========================  PUBLIC  =================================*/
00344 
00345   public:
00346 
00347     typedef          StorageInterfaceT                      Inherited;
00348 
00349     typedef typename TypeTraits<ValueTypeT>::RealReturnType RealReturnType;
00350 
00351     typedef          ValueTypeT                             ValueType;
00352 
00353     typedef          VectorInterface<ValueTypeT, 
00354                                      StorageInterfaceT>     VecInterface;
00355 
00356 
00357     typedef          PointInterface <ValueTypeT, 
00358                                      StorageInterfaceT>     Self;
00359 
00360     static  const    PointInterface                         Null;
00361 
00362     /*---------------------------------------------------------------------*/
00366              PointInterface(      void                  );
00367 
00368     explicit PointInterface(const ValueTypeT     *pVals );
00369     explicit PointInterface(      ValueTypeT     *pVals );
00370 
00371     template <class ValueType2T, class StorageInterface2T> 
00372     explicit PointInterface(const PointInterface<ValueType2T, 
00373                                                  StorageInterface2T> &vec);
00374 
00375     template <class ValueType2T, class StorageInterface2T> 
00376     explicit PointInterface(const VectorInterface<ValueType2T, 
00377                                                   StorageInterface2T> &vec);
00378 
00379     
00380     
00381     PointInterface(const PointInterface &source);
00382 
00383     /* Found so far no way to move these constructors to the memory
00384        interface :-(. I still find them a little bit wrong placed (GV)
00385     */
00386 
00387     PointInterface(const ValueTypeT rVal1);
00388 
00389     PointInterface(const ValueTypeT rVal1, const ValueTypeT rVal2);
00390 
00391     PointInterface(const ValueTypeT rVal1, const ValueTypeT rVal2,
00392                    const ValueTypeT rVal3);
00393 
00394     PointInterface(const ValueTypeT rVal1, const ValueTypeT rVal2,
00395                    const ValueTypeT rVal3, const ValueTypeT rVal4);
00396 
00398     /*---------------------------------------------------------------------*/
00402     ~PointInterface(void);
00403 
00405     /*---------------------------------------------------------------------*/
00409     void setNull (void);
00410 
00411 
00412     //void setValue(const ValueTypeT     &rVal1);
00413 
00414     void setValue(const PointInterface &vec     );
00415 
00416     template <class ValueType2T, class StorageInterface2T> 
00417     void setValue(const PointInterface<ValueType2T, 
00418                                        StorageInterface2T> &vec);
00419 
00420     void setValue           (const ValueTypeT     *pVals   );
00421     void setValue           (      ValueTypeT     *pVals   );
00422 
00423     void setValueFromCString(const Char8          *szString);
00424     void setValueFromCString(      Char8          *szString);
00425 
00426 #ifndef OSG_DISABLE_DEPRECATED
00427     void setValue           (const Char8          *szString);
00428     void setValue           (      Char8          *szString);
00429 #endif
00430 
00432     /*---------------------------------------------------------------------*/
00436           ValueTypeT *getValues(void);
00437     const ValueTypeT *getValues(void) const;
00438 
00440     /*---------------------------------------------------------------------*/
00444           bool            isZero  (      void                     ) const;
00445 
00446           void            negate  (      void                     );
00447 
00448           bool            equals  (const PointInterface &vec,
00449                                    const ValueTypeT      tolerance) const;
00450 
00451           VecInterface   &subZero (      void                     );
00452     const VecInterface   &subZero (      void                     ) const;
00453 
00454           RealReturnType  dist    (const PointInterface &vec      ) const;
00455           RealReturnType  dist2   (const PointInterface &vec      ) const;
00456 
00457           RealReturnType  maxValue(      void                     ) const;
00458 
00460     /*---------------------------------------------------------------------*/
00464     void            operator *=(const ValueTypeT      val );
00465     void            operator /=(const ValueTypeT      val );
00466 
00467     VecInterface    operator - (const PointInterface &vec ) const;
00468 
00469     PointInterface  operator + (const VecInterface   &vec ) const;
00470 
00471     PointInterface  operator - (const VecInterface   &vec ) const;
00472 
00473     PointInterface  operator * (const ValueTypeT      rVal) const;
00474 
00475     PointInterface  operator - (      void                );
00476 
00477     void            operator +=(const VecInterface   &vec );
00478     void            operator -=(const VecInterface   &vec );
00479 
00481     /*---------------------------------------------------------------------*/
00485            ValueTypeT &operator[](const UInt32 uiVal);
00486     const  ValueTypeT &operator[](const UInt32 uiVal) const;
00487 
00488     /* Cast operator, cast VecBase to ValueTypeT *
00489        Bad Bad idea, in my opion to buggy to be used, use getValues
00490        Const cast operator, cast VecBase to ValueTypeT *
00491 
00492        operator       ValueTypeT *(void);
00493        operator const ValueTypeT *(void);
00494     */
00495 
00497     /*---------------------------------------------------------------------*/
00501     PointInterface &operator =(const PointInterface &source);
00502     PointInterface &operator =(const VecInterface   &source);
00503 
00505     /*---------------------------------------------------------------------*/
00509     bool operator <  (const PointInterface &other)  const;
00510 
00511     bool operator == (const PointInterface &other) const;
00512     bool operator != (const PointInterface &other) const;
00513 
00515     /*=========================  PROTECTED  ===============================*/
00516 
00517   protected:
00518 
00519     /*==========================  PRIVATE  ================================*/
00520 
00521   private:
00522 };
00523 
00524 
00525 template <class ValueTypeT,
00526           class StorageInterfaceT> inline
00527 PointInterface<ValueTypeT, StorageInterfaceT>
00528     operator *(const ValueTypeT                         val,
00529                const PointInterface<ValueTypeT,
00530                                     StorageInterfaceT> &vec);
00531 
00532 template <class ValueTypeT,
00533           class StorageInterfaceT> inline
00534 std::ostream &operator <<(        std::ostream                 &os,
00535                           const   PointInterface<ValueTypeT,
00536                                             StorageInterfaceT> &obj);
00537 
00538 
00539 
00540 
00541 //---------------------------------------------------------------------------
00542 //  Class
00543 //---------------------------------------------------------------------------
00544 
00550 template<class ValueTypeT, class StorageInterfaceT>
00551 class VectorInterface :
00552     public PointInterface<ValueTypeT, StorageInterfaceT>
00553 {
00554     /*==========================  PUBLIC  =================================*/
00555 
00556   public:
00557 
00558     typedef          PointInterface<ValueTypeT,
00559                                     StorageInterfaceT>      Inherited;
00560 
00561     typedef typename TypeTraits<ValueTypeT>::RealReturnType RealReturnType;
00562 
00563     typedef                        ValueTypeT               ValueType;
00564 
00565     typedef          Inherited                              PntInterface;
00566 
00567     typedef          VectorInterface<ValueTypeT, 
00568                                      StorageInterfaceT>     Self;
00569 
00570     static  const    VectorInterface                        Null;
00571 
00572     /*---------------------------------------------------------------------*/
00576              VectorInterface(      void                   );
00577 
00578     explicit VectorInterface(const ValueTypeT      *pVals );
00579     explicit VectorInterface(      ValueTypeT      *pVals );
00580 
00581     template <class ValueType2T, class StorageInterface2T> 
00582     explicit VectorInterface(const PointInterface<ValueType2T, 
00583                                                   StorageInterface2T> &vec);
00584 
00585     template <class ValueType2T, class StorageInterface2T> 
00586     explicit VectorInterface(const VectorInterface<ValueType2T, 
00587                                                    StorageInterface2T> &vec);
00588 
00589 
00590 
00591     VectorInterface(const VectorInterface &source);
00592 
00593 
00594     /* Found so far no way to move these constructors to the memory
00595        interface :-(. I still find them a little bit wrong placed (GV)
00596     */
00597 
00598     VectorInterface(const ValueTypeT rVal1);
00599 
00600     VectorInterface(const ValueTypeT rVal1, const ValueTypeT rVal2);
00601 
00602     VectorInterface(const ValueTypeT rVal1, const ValueTypeT rVal2,
00603                     const ValueTypeT rVal3);
00604 
00605     VectorInterface(const ValueTypeT rVal1, const ValueTypeT rVal2,
00606                     const ValueTypeT rVal3, const ValueTypeT rVal4);
00607 
00609     /*---------------------------------------------------------------------*/
00613     ~VectorInterface(void);
00614 
00616     /*---------------------------------------------------------------------*/
00620     RealReturnType  length       (      void                  ) const;
00621     RealReturnType  squareLength (      void                  ) const;
00622 
00623     void            normalize    (      void                  );
00624 
00625     VectorInterface cross        (const VectorInterface &vec  ) const;
00626     VectorInterface operator %   (const VectorInterface &vec  ) const;
00627 
00628     void            crossThis    (const VectorInterface &vec  );
00629 
00630     ValueTypeT      dot          (const VectorInterface &vec  ) const;
00631     ValueTypeT      operator *   (const VectorInterface &vec  ) const;
00632     ValueTypeT      dot          (const PntInterface    &pnt  ) const;
00633     ValueTypeT      operator *   (const PntInterface    &pnt  ) const;
00634 
00635     RealReturnType  enclosedAngle(const VectorInterface &vec  ) const;
00636 
00637     RealReturnType  projectTo    (const VectorInterface &toVec);
00638 
00640     /*---------------------------------------------------------------------*/
00644           PntInterface    &addToZero (void);
00645     const PntInterface    &addToZero (void) const;
00646 
00647           VectorInterface &subZero   (void);
00648     const VectorInterface &subZero   (void) const;
00649 
00651     /*---------------------------------------------------------------------*/
00655     VectorInterface operator - (const VectorInterface &vec ) const;
00656     VectorInterface operator + (const VectorInterface &vec ) const;
00657 
00658     VectorInterface operator * (const ValueTypeT       rVal) const;
00659 
00660     VectorInterface operator - (      void                 ) const;
00661 
00663     /*---------------------------------------------------------------------*/
00667     VectorInterface &operator =(const VectorInterface &source);
00668 
00670     /*---------------------------------------------------------------------*/
00674     bool operator <  (const VectorInterface &other) const;
00675 
00676     bool operator == (const VectorInterface &other) const;
00677     bool operator != (const VectorInterface &other) const;
00678 
00680     /*=========================  PROTECTED  ===============================*/
00681 
00682   protected:
00683 
00684     /*==========================  PRIVATE  ================================*/
00685 
00686   private:
00687 };
00688 
00689 #ifdef __sgi
00690 #pragma reset woff 1375
00691 #endif
00692 
00693 template <class ValueTypeT,
00694           class StorageInterfaceT> inline
00695 VectorInterface<ValueTypeT, StorageInterfaceT>
00696     operator *(const ValueTypeT                          val,
00697                const VectorInterface<ValueTypeT,
00698                                      StorageInterfaceT> &vec);
00699 
00700 template <class ValueTypeT,
00701           class StorageInterfaceT> inline
00702 std::ostream &operator <<(        std::ostream                  &os,
00703                           const   VectorInterface<ValueTypeT,
00704                                              StorageInterfaceT> &obj);
00705 
00706 
00707 // Actual Types
00708 
00709 
00714 typedef VectorInterface< UInt8, VecStorage1<UInt8> > Vec1ub;
00715 
00720 typedef Vec1ub *Vec1ubP;
00721 
00726 #ifndef OSG_NO_INT8_PNT
00727 typedef VectorInterface< Int8, VecStorage1<Int8> > Vec1b;
00728 #endif
00729 
00734 #ifndef OSG_NO_INT8_PNT
00735 typedef Vec1b *Vec1bP;
00736 #endif
00737 
00742 typedef VectorInterface< UInt16, VecStorage1<UInt16> > Vec1us;
00743 
00748 typedef Vec1us *Vec1usP;
00749 
00754 typedef VectorInterface< Int16, VecStorage1<Int16> > Vec1s;
00755 
00760 typedef Vec1s *Vec1sP;
00761 
00766 typedef VectorInterface< Real32, VecStorage1<Real32> > Vec1f;
00767 
00772 typedef Vec1f *Vec1fP;
00773 
00778 typedef VectorInterface< Fixed32, VecStorage1<Fixed32> > Vec1fx;
00779 
00784 typedef Vec1fx *Vec1fxP;
00785 
00790 typedef VectorInterface< Real64, VecStorage1<Real64> > Vec1d;
00791 
00796 typedef Vec1d *Vec1dP;
00797 
00802 typedef VectorInterface< Real128, VecStorage1<Real128> > Vec1ld;
00803 
00808 typedef Vec1ld *Vec1ldP;
00809 
00810 
00815 typedef VectorInterface< UInt8, VecStorage2<UInt8> > Vec2ub;
00816 
00821 typedef Vec2ub *Vec2ubP;
00822 
00827 #ifndef OSG_NO_INT8_PNT
00828 typedef VectorInterface< Int8, VecStorage2<Int8> > Vec2b;
00829 #endif
00830 
00835 #ifndef OSG_NO_INT8_PNT
00836 typedef Vec2b *Vec2bP;
00837 #endif
00838 
00843 typedef VectorInterface< UInt16, VecStorage2<UInt16> > Vec2us;
00844 
00849 typedef Vec2us *Vec2usP;
00850 
00855 typedef VectorInterface< Int16, VecStorage2<Int16> > Vec2s;
00856 
00861 typedef Vec2s *Vec2sP;
00862 
00867 typedef VectorInterface< Real32,  VecStorage2<Real32 > > Vec2f;
00868 
00873 typedef Vec2f *Vec2fP;
00874 
00880 typedef VectorInterface< Fixed32, VecStorage2<Fixed32> > Vec2fx;
00881 
00886 typedef Vec2fx *Vec2fxP;
00887 
00892 typedef VectorInterface< Real64, VecStorage2<Real64> > Vec2d;
00893 
00898 typedef Vec2d *Vec2dP;
00899 
00904 typedef VectorInterface< Real128, VecStorage2<Real128> > Vec2ld;
00905 
00910 typedef Vec2ld *Vec2ldP;
00911 
00912 
00917 typedef VectorInterface< UInt8, VecStorage3<UInt8> > Vec3ub;
00918 
00923 typedef Vec3ub *Vec3ubP;
00924 
00929 #ifndef OSG_NO_INT8_PNT
00930 typedef VectorInterface< Int8, VecStorage3<Int8> > Vec3b;
00931 #endif
00932 
00937 #ifndef OSG_NO_INT8_PNT
00938 typedef Vec3b *Vec3bP;
00939 #endif
00940 
00945 typedef VectorInterface< UInt16, VecStorage3<UInt16> > Vec3us;
00946 
00951 typedef Vec3us *Vec3usP;
00952 
00957 typedef VectorInterface< Int16, VecStorage3<Int16> > Vec3s;
00958 
00963 typedef Vec3s *Vec3sP;
00964 
00969 typedef VectorInterface < Real32, VecStorage3<Real32>  > Vec3f;
00970 
00975 typedef Vec3f *Vec3fP;
00976 
00981 typedef VectorInterface< Fixed32, VecStorage3<Fixed32> > Vec3fx;
00982 
00987 typedef Vec3fx *Vec3fxP;
00988 
00993 typedef VectorInterface< Real64, VecStorage3<Real64> > Vec3d;
00994 
00999 typedef Vec3d *Vec3dP;
01000 
01005 typedef VectorInterface< Real128, VecStorage3<Real128> > Vec3ld;
01006 
01011 typedef Vec3ld *Vec3ldP;
01012 
01013 
01018 typedef VectorInterface< UInt8, VecStorage4<UInt8> > Vec4ub;
01019 
01024 typedef Vec4ub *Vec4ubP;
01025 
01030 #ifndef OSG_NO_INT8_PNT
01031 typedef VectorInterface< Int8, VecStorage4<Int8> > Vec4b;
01032 #endif
01033 
01038 #ifndef OSG_NO_INT8_PNT
01039 typedef Vec4b *Vec4bP;
01040 #endif
01041 
01046 typedef VectorInterface< UInt16, VecStorage4<UInt16> > Vec4us;
01047 
01052 typedef Vec4us *Vec4usP;
01053 
01058 typedef VectorInterface< Int16, VecStorage4<Int16> > Vec4s;
01059 
01064 typedef Vec4s *Vec4sP;
01065 
01070 typedef VectorInterface< Real32,  VecStorage4<Real32 > > Vec4f;
01071 
01076 typedef Vec4f *Vec4fP;
01077 
01082 typedef VectorInterface< Fixed32, VecStorage4<Fixed32> > Vec4fx;
01083 
01088 typedef Vec4fx *Vec4fxP;
01089 
01094 typedef VectorInterface< Real64, VecStorage4<Real64> > Vec4d;
01095 
01100 typedef Vec4d *Vec4dP;
01101 
01106 typedef VectorInterface< Real128, VecStorage4<Real128> > Vec4ld;
01107 
01112 typedef Vec4ld *Vec4ldP;
01113 
01114 
01115 
01116 
01121 typedef PointInterface< UInt8, VecStorage1<UInt8> > Pnt1ub;
01122 
01127 typedef Pnt1ub *Pnt1ubP;
01128 
01133 #ifndef OSG_NO_INT8_PNT
01134 typedef PointInterface< Int8, VecStorage1<Int8> > Pnt1b;
01135 #endif
01136 
01141 #ifndef OSG_NO_INT8_PNT
01142 typedef Pnt1b *Pnt1bP;
01143 #endif
01144 
01149 typedef PointInterface< UInt16, VecStorage1<UInt16> > Pnt1us;
01150 
01155 typedef Pnt1us *Pnt1usP;
01156 
01161 typedef PointInterface< Int16, VecStorage1<Int16> > Pnt1s;
01162 
01167 typedef Pnt1s *Pnt1sP;
01168 
01173 typedef PointInterface< Real32, VecStorage1<Real32> > Pnt1f;
01174 
01179 typedef Pnt1f *Pnt1fP;
01180 
01185 typedef PointInterface< Fixed32, VecStorage1<Fixed32> > Pnt1fx;
01186 
01191 typedef Pnt1fx *Pnt1fxP;
01192 
01197 typedef PointInterface< Real64, VecStorage1<Real64> > Pnt1d;
01198 
01203 typedef Pnt1d *Pnt1dP;
01204 
01209 typedef PointInterface< Real128, VecStorage1<Real128> > Pnt1ld;
01210 
01215 typedef Pnt1ld *Pnt1ldP;
01216 
01217 
01218 
01223 typedef PointInterface< UInt8, VecStorage2<UInt8> > Pnt2ub;
01224 
01229 typedef Pnt2ub *Pnt2ubP;
01230 
01235 #ifndef OSG_NO_INT8_PNT
01236 typedef PointInterface< Int8, VecStorage2<Int8> > Pnt2b;
01237 #endif
01238 
01243 #ifndef OSG_NO_INT8_PNT
01244 typedef Pnt2b *Pnt2bP;
01245 #endif
01246 
01251 typedef PointInterface< UInt16, VecStorage2<UInt16> > Pnt2us;
01252 
01257 typedef Pnt2us *Pnt2usP;
01258 
01263 typedef PointInterface< Int16, VecStorage2<Int16> > Pnt2s;
01264 
01269 typedef Pnt2s *Pnt2sP;
01270 
01275 typedef PointInterface< Real32,  VecStorage2<Real32 > > Pnt2f;
01276 
01281 typedef Pnt2f *Pnt2fP;
01282 
01287 typedef PointInterface< Fixed32, VecStorage2<Fixed32> > Pnt2fx;
01288 
01293 typedef Pnt2fx *Pnt2fxP;
01294 
01299 typedef PointInterface< Real64, VecStorage2<Real64> > Pnt2d;
01300 
01305 typedef Pnt2d *Pnt2dP;
01306 
01311 typedef PointInterface< Real128, VecStorage2<Real128> > Pnt2ld;
01312 
01317 typedef Pnt2ld *Pnt2ldP;
01318 
01319 
01324 typedef PointInterface< UInt8, VecStorage3<UInt8> > Pnt3ub;
01325 
01330 typedef Pnt3ub *Pnt3ubP;
01331 
01336 #ifndef OSG_NO_INT8_PNT
01337 typedef PointInterface< Int8, VecStorage3<Int8> > Pnt3b;
01338 #endif
01339 
01344 #ifndef OSG_NO_INT8_PNT
01345 typedef Pnt3b *Pnt3bP;
01346 #endif
01347 
01352 typedef PointInterface< UInt16, VecStorage3<UInt16> > Pnt3us;
01353 
01358 typedef Pnt3us *Pnt3usP;
01359 
01364 typedef PointInterface< Int16, VecStorage3<Int16> > Pnt3s;
01365 
01370 typedef Pnt3s *Pnt3sP;
01371 
01376 typedef PointInterface< Real32, VecStorage3<Real32   > > Pnt3f;
01377 
01382 typedef Pnt3f *Pnt3fP;
01383 
01388 typedef PointInterface < Fixed32, VecStorage3<Fixed32> > Pnt3fx;
01389 
01394 typedef Pnt3fx *Pnt3fxP;
01395 
01400 typedef PointInterface< Real64, VecStorage3<Real64> > Pnt3d;
01401 
01406 typedef Pnt3d *Pnt3dP;
01407 
01412 typedef PointInterface< Real128, VecStorage3<Real128> > Pnt3ld;
01413 
01418 typedef Pnt3ld *Pnt3ldP;
01419 
01420 
01425 typedef PointInterface< UInt8, VecStorage4<UInt8> > Pnt4ub;
01426 
01431 typedef Pnt4ub *Pnt4ubP;
01432 
01437 #ifndef OSG_NO_INT8_PNT
01438 typedef PointInterface< Int8, VecStorage4<Int8> > Pnt4b;
01439 #endif
01440 
01445 #ifndef OSG_NO_INT8_PNT
01446 typedef Pnt4b *Pnt4bP;
01447 #endif
01448 
01453 typedef PointInterface< UInt16, VecStorage4<UInt16> > Pnt4us;
01454 
01459 typedef Pnt4us *Pnt4usP;
01460 
01465 typedef PointInterface< Int16, VecStorage4<Int16> > Pnt4s;
01466 
01471 typedef Pnt4s *Pnt4sP;
01472 
01477 typedef PointInterface< Real32, VecStorage4<Real32> > Pnt4f;
01478 
01483 typedef Pnt4f *Pnt4fP;
01484 
01489 typedef PointInterface< Fixed32, VecStorage4<Fixed32> > Pnt4fx;
01490 
01495 typedef Pnt4fx *Pnt4fxP;
01496 
01501 typedef PointInterface< Real64, VecStorage4<Real64> > Pnt4d;
01502 
01507 typedef Pnt4d *Pnt4dP;
01508 
01513 typedef PointInterface< Real128, VecStorage4<Real128> > Pnt4ld;
01514 
01519 typedef Pnt4ld *Pnt4ldP;
01520 
01521 #ifdef OSG_FLOAT_PROFILE
01522 
01523 typedef Vec2f Vec2r;
01524 typedef Vec3f Vec3r;
01525 typedef Vec4f Vec4r;
01526 
01527 typedef Pnt2f Pnt2r;
01528 typedef Pnt3f Pnt3r;
01529 typedef Pnt4f Pnt4r;
01530 
01531 #else
01532 
01533 typedef Vec2fx Vec2r;
01534 typedef Vec3fx Vec3r;
01535 typedef Vec4fx Vec4r;
01536 
01537 typedef Pnt2fx Pnt2r;
01538 typedef Pnt3fx Pnt3r;
01539 typedef Pnt4fx Pnt4r;
01540 
01541 #endif
01542 
01543 OSG_END_NAMESPACE
01544 
01545 #include "OSGVector.inl"
01546 
01547 
01548 #ifdef __sgi
01549 #pragma reset woff 1209
01550 #endif
01551 
01552 #endif /* OSGVECTOR_H */
01553 
01554