OSGVector.h

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
 *                                OpenSG                                     *
 *                                                                           *
 *                                                                           *
 *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
 *                                                                           *
 *                            www.opensg.org                                 *
 *                                                                           *
 *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
 *                                                                           *
\*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*\
 *                                License                                    *
 *                                                                           *
 * This library is free software; you can redistribute it and/or modify it   *
 * under the terms of the GNU Library General Public License as published    *
 * by the Free Software Foundation, version 2.                               *
 *                                                                           *
 * This library is distributed in the hope that it will be useful, but       *
 * WITHOUT ANY WARRANTY; without even the implied warranty of                *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
 * Library General Public License for more details.                          *
 *                                                                           *
 * You should have received a copy of the GNU Library General Public         *
 * License along with this library; if not, write to the Free Software       *
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
 *                                                                           *
\*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*\
 *                                Changes                                    *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
\*---------------------------------------------------------------------------*/

#ifndef _OSGVECTOR_H_
#define _OSGVECTOR_H_
#ifdef __sgi
#pragma once
#endif

#include <OSGConfig.h>
#include <OSGBase.h>
#include <OSGBaseTypes.h>
#include <OSGBaseFunctions.h>

#include <iostream>

OSG_BEGIN_NAMESPACE

template<class ValueTypeT, class StorageInterfaceT>
class VectorInterface;

template<class ValueTypeT, class StorageInterfaceT>
class PointInterface;


#ifdef __sgi
#pragma set woff 1209
#endif

//---------------------------------------------------------------------------
//  Class
//---------------------------------------------------------------------------

template <class ValueTypeT>
class VecStorage2
{
    /*==========================  PUBLIC  =================================*/

  public:

    static const UInt32 _iSize = 2;

    /*---------------------------------------------------------------------*/
    VecStorage2(void);

    /*---------------------------------------------------------------------*/
    ~VecStorage2(void);

    /*---------------------------------------------------------------------*/
    void       setValues        (const ValueTypeT  rVal1, 
                                 const ValueTypeT  rVal2);

    void       getSeparateValues(      ValueTypeT &rVal1, 
                                       ValueTypeT &rVal2) const;

    ValueTypeT x                (void                   ) const;
    ValueTypeT y                (void                   ) const;

    /*=========================  PROTECTED  ===============================*/

  protected:

    ValueTypeT _values[_iSize];

    /*==========================  PRIVATE  ================================*/

  private:

    VecStorage2(const VecStorage2 &source);
    void operator =(const VecStorage2 &source);
};




//---------------------------------------------------------------------------
//  Class
//---------------------------------------------------------------------------

template <class ValueTypeT>
class VecStorage3
{
    /*==========================  PUBLIC  =================================*/

  public:

    static const UInt32 _iSize = 3;

    /*---------------------------------------------------------------------*/
    VecStorage3(void);

    /*---------------------------------------------------------------------*/
    ~VecStorage3(void);

    /*---------------------------------------------------------------------*/
    void       setValues        (const ValueTypeT  rVal1,
                                 const ValueTypeT  rVal2,
                                 const ValueTypeT  rVal3);

    void       getSeparateValues(      ValueTypeT &rVal1,
                                       ValueTypeT &rVal2,
                                       ValueTypeT &rVal3) const;

    ValueTypeT x                (void                   ) const;
    ValueTypeT y                (void                   ) const;
    ValueTypeT z                (void                   ) const;

    /*=========================  PROTECTED  ===============================*/

  protected:

    ValueTypeT _values[_iSize];

    /*==========================  PRIVATE  ================================*/

  private:

    VecStorage3(const VecStorage3 &source);
    void operator =(const VecStorage3 &source);
};




//---------------------------------------------------------------------------
//  Class
//---------------------------------------------------------------------------

template <class ValueTypeT>
class VecStorage4
{
    /*==========================  PUBLIC  =================================*/

  public:

    static const UInt32 _iSize = 4;

    /*---------------------------------------------------------------------*/
    VecStorage4(void);

    /*---------------------------------------------------------------------*/
    ~VecStorage4(void);

    /*---------------------------------------------------------------------*/
    void       setValues        (const ValueTypeT  rVal1,
                                 const ValueTypeT  rVal2,
                                 const ValueTypeT  rVal3,
                                 const ValueTypeT  rVal4);

    void       getSeparateValues(      ValueTypeT &rVal1,
                                       ValueTypeT &rVal2,
                                       ValueTypeT &rVal3,
                                       ValueTypeT &rVal4) const;

    ValueTypeT x                (void                   ) const;
    ValueTypeT y                (void                   ) const;
    ValueTypeT z                (void                   ) const;
    ValueTypeT w                (void                   ) const;

    /*=========================  PROTECTED  ===============================*/

  protected:

    ValueTypeT _values[_iSize];

    /*==========================  PRIVATE  ================================*/

  private:

    VecStorage4(const VecStorage4 &source);
    void operator =(const VecStorage4 &source);
};




//---------------------------------------------------------------------------
//  Class
//---------------------------------------------------------------------------

#ifdef __sgi
#pragma set woff 1375
#endif

template<class ValueTypeT, class StorageInterfaceT>
class PointInterface : public StorageInterfaceT
{
    /*==========================  PUBLIC  =================================*/

  public:

    typedef          StorageInterfaceT                      Inherited;

    typedef typename TypeTraits<ValueTypeT>::RealReturnType RealReturnType;

    typedef          ValueTypeT                             ValueType;

    typedef          VectorInterface<ValueTypeT, 
                                     StorageInterfaceT>     VecInterface;


    typedef          PointInterface <ValueTypeT, 
                                     StorageInterfaceT>     Self;

    static  const    PointInterface                         Null;

    /*---------------------------------------------------------------------*/
             PointInterface(      void                  );

    explicit PointInterface(const ValueTypeT     *pVals );
    explicit PointInterface(      ValueTypeT     *pVals );

    /* This inline code was brought to you by Microsoft */

    template<class VectorT> 
#ifndef OSG_MICROSOFT_COMPILER_HACKS
    explicit 
#endif
             PointInterface(const VectorT        &vec   )
    {
        if(Self::_iSize <= VectorT::_iSize)
        {
            for(UInt32 i = 0; i < Self::_iSize; i++)
            {
                Self::_values[i] = vec.getValues()[i];
            }
        }
        else
        {
            UInt32 i;
            for(i = 0; i < VectorT::_iSize; i++)
            {
                Self::_values[i] = vec.getValues()[i];
            }
            for(i = VectorT::_iSize; i < Self::_iSize; i++)
            {
                Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
            }
        }
    }

             PointInterface(const PointInterface &source);

#if 0
    /* Constructor which takes one value, remaining entries will be zero;
       Actually this one collides with the template constuctor above,
       so I do not implement this one, any problems with that (GV)
    */

    PointInterface(const ValueTypeT rVal1);
#endif

    /* Found so far no way to move these constructors to the memory
       interface :-(. I still find them a little bit wrong placed (GV)
    */

    PointInterface(const ValueTypeT rVal1, const ValueTypeT rVal2);

    PointInterface(const ValueTypeT rVal1, const ValueTypeT rVal2,
                   const ValueTypeT rVal3);

    PointInterface(const ValueTypeT rVal1, const ValueTypeT rVal2,
                   const ValueTypeT rVal3, const ValueTypeT rVal4);

    /*---------------------------------------------------------------------*/
    ~PointInterface(void);

    /*---------------------------------------------------------------------*/
    void setNull (void);

#if 0
    /* set first values, remaining entries will not change;
       Actually this one collides with the template set function below,
       so I do not implement this one, any problems with that (GV)
    */

    void setValue(const ValueTypeT     &rVal1);
#endif

    void setValue(const PointInterface &vec     );

    /* This inline code was brought to you by Microsoft */

    template<class VectorT>
    void setValue(const VectorT        &vec     )
    {
        for(UInt32   i = 0;
                     i < (Self::_iSize < VectorT::_iSize ? 
                          Self::_iSize : VectorT::_iSize);
                   ++i)
        {
            Self::_values[i] = vec.getValues()[i];
        }
    }

    void setValue           (const ValueTypeT     *pVals   );
    void setValue           (      ValueTypeT     *pVals   );

    void setValueFromCString(const Char8          *szString);
    void setValueFromCString(      Char8          *szString);

#ifndef OSG_DISABLE_DEPRECATED
    void setValue           (const Char8          *szString);
    void setValue           (      Char8          *szString);
#endif


    /*---------------------------------------------------------------------*/
          ValueTypeT *getValues(void);
    const ValueTypeT *getValues(void) const;

    /*---------------------------------------------------------------------*/
          bool            isZero  (      void                     ) const;

          void            negate  (      void                     );

          bool            equals  (const PointInterface &vec,
                                   const ValueTypeT      tolerance) const;

          VecInterface   &subZero (      void                     );
    const VecInterface   &subZero (      void                     ) const;

          RealReturnType  dist    (const PointInterface &vec      ) const;
          RealReturnType  dist2   (const PointInterface &vec      ) const;

          RealReturnType  maxValue(      void                     ) const;

    /*---------------------------------------------------------------------*/
    void            operator *=(const ValueTypeT      val );
    void            operator /=(const ValueTypeT      val );

    VecInterface    operator - (const PointInterface &vec ) const;

    PointInterface  operator + (const VecInterface   &vec ) const;

    PointInterface  operator - (const VecInterface   &vec ) const;

    PointInterface  operator * (const ValueTypeT      rVal) const;

    PointInterface  operator - (      void                );

    void            operator +=(const VecInterface   &vec );
    void            operator -=(const VecInterface   &vec );

    /*---------------------------------------------------------------------*/
           ValueTypeT &operator[](const UInt32 uiVal);
    const  ValueTypeT &operator[](const UInt32 uiVal) const;

    /* Cast operator, cast VecBase to ValueTypeT *
       Bad Bad idea, in my opion to buggy to be used, use getValues
       Const cast operator, cast VecBase to ValueTypeT *

       operator       ValueTypeT *(void);
       operator const ValueTypeT *(void);
    */

    /*---------------------------------------------------------------------*/
    PointInterface &operator =(const PointInterface &source);
    PointInterface &operator =(const VecInterface   &source);

    /*---------------------------------------------------------------------*/
    bool operator <  (const PointInterface &other)  const;

    bool operator == (const PointInterface &other) const;
    bool operator != (const PointInterface &other) const;

    /*=========================  PROTECTED  ===============================*/

  protected:

    /*==========================  PRIVATE  ================================*/

  private:
};


template <class ValueTypeT,
          class StorageInterfaceT> inline
PointInterface<ValueTypeT, StorageInterfaceT>
    operator *(const ValueTypeT                         val,
               const PointInterface<ValueTypeT,
                                    StorageInterfaceT> &vec);

template <class ValueTypeT,
          class StorageInterfaceT> inline
std::ostream &operator <<(        std::ostream                 &os,
                          const   PointInterface<ValueTypeT,
                                            StorageInterfaceT> &obj);




//---------------------------------------------------------------------------
//  Class
//---------------------------------------------------------------------------

template<class ValueTypeT, class StorageInterfaceT>
class VectorInterface :
    public PointInterface<ValueTypeT, StorageInterfaceT>
{
    /*==========================  PUBLIC  =================================*/

  public:

    typedef          PointInterface<ValueTypeT,
                                    StorageInterfaceT>      Inherited;

    typedef typename TypeTraits<ValueTypeT>::RealReturnType RealReturnType;

    typedef                        ValueTypeT               ValueType;

    typedef          Inherited                              PntInterface;

    typedef          VectorInterface<ValueTypeT, 
                                     StorageInterfaceT>     Self;

    static  const    VectorInterface                        Null;

    /*---------------------------------------------------------------------*/
             VectorInterface(      void                   );

    explicit VectorInterface(const ValueTypeT      *pVals );
    explicit VectorInterface(      ValueTypeT      *pVals );

    /* This inline code was brought to you by Microsoft */

    template<class VectorT> 
#ifndef OSG_MICROSOFT_COMPILER_HACKS
    explicit 
#endif
             VectorInterface(const VectorT         &vec   )
    {
        if(Self::_iSize <= VectorT::_iSize)
        {
            for(UInt32 i = 0; i < Self::_iSize; i++)
            {
                Self::_values[i] = vec.getValues()[i];
            }
        }
        else
        {
            UInt32 i;
            for(i = 0; i < VectorT::_iSize; i++)
            {
                Self::_values[i] = vec.getValues()[i];
            }
            for(i = VectorT::_iSize; i < Self::_iSize; i++)
            {
                Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
            }
        }
    }

             VectorInterface(const VectorInterface &source);

#if 0
    /* Constructor which takes one value, remaining entries will be zero;
       Actually this one collides with the template constuctor above,
       so I do not implement this one, any problems with that (GV)
    */

             VectorInterface(const ValueTypeT       rVal1 );
#endif

    /* Found so far no way to move these constructors to the memory
       interface :-(. I still find them a little bit wrong placed (GV)
    */

    VectorInterface(const ValueTypeT rVal1, const ValueTypeT rVal2);

    VectorInterface(const ValueTypeT rVal1, const ValueTypeT rVal2,
                    const ValueTypeT rVal3);

    VectorInterface(const ValueTypeT rVal1, const ValueTypeT rVal2,
                    const ValueTypeT rVal3, const ValueTypeT rVal4);

    /*---------------------------------------------------------------------*/
    ~VectorInterface(void);

    /*---------------------------------------------------------------------*/
    RealReturnType  length       (      void                  ) const;
    RealReturnType  squareLength (      void                  ) const;

    void            normalize    (      void                  );

    VectorInterface cross        (const VectorInterface &vec  ) const;
    VectorInterface operator %   (const VectorInterface &vec  ) const;

    void            crossThis    (const VectorInterface &vec  );

    ValueTypeT      dot          (const VectorInterface &vec  ) const;
    ValueTypeT      operator *   (const VectorInterface &vec  ) const;
    ValueTypeT      dot          (const PntInterface    &pnt  ) const;
    ValueTypeT      operator *   (const PntInterface    &pnt  ) const;

    RealReturnType  enclosedAngle(const VectorInterface &vec  ) const;

    RealReturnType  projectTo    (const VectorInterface &toVec);

    /*---------------------------------------------------------------------*/
          PntInterface    &addToZero (void);
    const PntInterface    &addToZero (void) const;

          VectorInterface &subZero   (void);
    const VectorInterface &subZero   (void) const;

    /*---------------------------------------------------------------------*/
    VectorInterface operator - (const VectorInterface &vec ) const;
    VectorInterface operator + (const VectorInterface &vec ) const;

    VectorInterface operator * (const ValueTypeT       rVal) const;

    VectorInterface operator - (      void                 ) const;

    /*---------------------------------------------------------------------*/
    VectorInterface &operator =(const VectorInterface &source);

    /*---------------------------------------------------------------------*/
    bool operator <  (const VectorInterface &other) const;

    bool operator == (const VectorInterface &other) const;
    bool operator != (const VectorInterface &other) const;

    /*=========================  PROTECTED  ===============================*/

  protected:

    /*==========================  PRIVATE  ================================*/

  private:
};

#ifdef __sgi
#pragma reset woff 1375
#endif

template <class ValueTypeT,
          class StorageInterfaceT> inline
VectorInterface<ValueTypeT, StorageInterfaceT>
    operator *(const ValueTypeT                          val,
               const VectorInterface<ValueTypeT,
                                     StorageInterfaceT> &vec);

template <class ValueTypeT,
          class StorageInterfaceT> inline
std::ostream &operator <<(        std::ostream                  &os,
                          const   VectorInterface<ValueTypeT,
                                             StorageInterfaceT> &obj);


// Actual Types


typedef VectorInterface< UInt8, VecStorage2<UInt8> > Vec2ub;

typedef Vec2ub *Vec2ubP;

#ifndef OSG_NO_INT8_PNT
typedef VectorInterface< Int8, VecStorage2<Int8> > Vec2b;
#endif

#ifndef OSG_NO_INT8_PNT
typedef Vec2b *Vec2bP;
#endif

typedef VectorInterface< UInt16, VecStorage2<UInt16> > Vec2us;

typedef Vec2us *Vec2usP;

typedef VectorInterface< Int16, VecStorage2<Int16> > Vec2s;

typedef Vec2s *Vec2sP;

typedef VectorInterface< Real32, VecStorage2<Real32> > Vec2f;

typedef Vec2f *Vec2fP;

typedef VectorInterface< Real64, VecStorage2<Real64> > Vec2d;

typedef Vec2d *Vec2dP;

typedef VectorInterface< Real128, VecStorage2<Real128> > Vec2ld;

typedef Vec2ld *Vec2ldP;


typedef VectorInterface< UInt8, VecStorage3<UInt8> > Vec3ub;

typedef Vec3ub *Vec3ubP;

#ifndef OSG_NO_INT8_PNT
typedef VectorInterface< Int8, VecStorage3<Int8> > Vec3b;
#endif

#ifndef OSG_NO_INT8_PNT
typedef Vec3b *Vec3bP;
#endif

typedef VectorInterface< UInt16, VecStorage3<UInt16> > Vec3us;

typedef Vec3us *Vec3usP;

typedef VectorInterface< Int16, VecStorage3<Int16> > Vec3s;

typedef Vec3s *Vec3sP;

typedef VectorInterface< Real32, VecStorage3<Real32> > Vec3f;

typedef Vec3f *Vec3fP;

typedef VectorInterface< Real64, VecStorage3<Real64> > Vec3d;

typedef Vec3d *Vec3dP;

typedef VectorInterface< Real128, VecStorage3<Real128> > Vec3ld;

typedef Vec3ld *Vec3ldP;


typedef VectorInterface< UInt8, VecStorage4<UInt8> > Vec4ub;

typedef Vec4ub *Vec4ubP;

#ifndef OSG_NO_INT8_PNT
typedef VectorInterface< Int8, VecStorage4<Int8> > Vec4b;
#endif

#ifndef OSG_NO_INT8_PNT
typedef Vec4b *Vec4bP;
#endif

typedef VectorInterface< UInt16, VecStorage4<UInt16> > Vec4us;

typedef Vec4us *Vec4usP;

typedef VectorInterface< Int16, VecStorage4<Int16> > Vec4s;

typedef Vec4s *Vec4sP;

typedef VectorInterface< Real32, VecStorage4<Real32> > Vec4f;

typedef Vec4f *Vec4fP;

typedef VectorInterface< Real64, VecStorage4<Real64> > Vec4d;

typedef Vec4d *Vec4dP;

typedef VectorInterface< Real128, VecStorage4<Real128> > Vec4ld;

typedef Vec4ld *Vec4ldP;




typedef PointInterface< UInt8, VecStorage2<UInt8> > Pnt2ub;

typedef Pnt2ub *Pnt2ubP;

#ifndef OSG_NO_INT8_PNT
typedef PointInterface< Int8, VecStorage2<Int8> > Pnt2b;
#endif

#ifndef OSG_NO_INT8_PNT
typedef Pnt2b *Pnt2bP;
#endif

typedef PointInterface< UInt16, VecStorage2<UInt16> > Pnt2us;

typedef Pnt2us *Pnt2usP;

typedef PointInterface< Int16, VecStorage2<Int16> > Pnt2s;

typedef Pnt2s *Pnt2sP;

typedef PointInterface< Real32, VecStorage2<Real32> > Pnt2f;

typedef Pnt2f *Pnt2fP;

typedef PointInterface< Real64, VecStorage2<Real64> > Pnt2d;

typedef Pnt2d *Pnt2dP;

typedef PointInterface< Real128, VecStorage2<Real128> > Pnt2ld;

typedef Pnt2ld *Pnt2ldP;


typedef PointInterface< UInt8, VecStorage3<UInt8> > Pnt3ub;

typedef Pnt3ub *Pnt3ubP;

#ifndef OSG_NO_INT8_PNT
typedef PointInterface< Int8, VecStorage3<Int8> > Pnt3b;
#endif

#ifndef OSG_NO_INT8_PNT
typedef Pnt3b *Pnt3bP;
#endif

typedef PointInterface< UInt16, VecStorage3<UInt16> > Pnt3us;

typedef Pnt3us *Pnt3usP;

typedef PointInterface< Int16, VecStorage3<Int16> > Pnt3s;

typedef Pnt3s *Pnt3sP;

typedef PointInterface< Real32, VecStorage3<Real32> > Pnt3f;

typedef Pnt3f *Pnt3fP;

typedef PointInterface< Real64, VecStorage3<Real64> > Pnt3d;

typedef Pnt3d *Pnt3dP;

typedef PointInterface< Real128, VecStorage3<Real128> > Pnt3ld;

typedef Pnt3ld *Pnt3ldP;


typedef PointInterface< UInt8, VecStorage4<UInt8> > Pnt4ub;

typedef Pnt4ub *Pnt4ubP;

#ifndef OSG_NO_INT8_PNT
typedef PointInterface< Int8, VecStorage4<Int8> > Pnt4b;
#endif

#ifndef OSG_NO_INT8_PNT
typedef Pnt4b *Pnt4bP;
#endif

typedef PointInterface< UInt16, VecStorage4<UInt16> > Pnt4us;

typedef Pnt4us *Pnt4usP;

typedef PointInterface< Int16, VecStorage4<Int16> > Pnt4s;

typedef Pnt4s *Pnt4sP;

typedef PointInterface< Real32, VecStorage4<Real32> > Pnt4f;

typedef Pnt4f *Pnt4fP;

typedef PointInterface< Real64, VecStorage4<Real64> > Pnt4d;

typedef Pnt4d *Pnt4dP;

typedef PointInterface< Real128, VecStorage4<Real128> > Pnt4ld;

typedef Pnt4ld *Pnt4ldP;


OSG_END_NAMESPACE

#include <OSGVector.inl>


#ifdef __sgi
#pragma reset woff 1209
#endif

#define OSGVECTOR_HEADER_CVSID "@(#)$Id: $"

#endif /* OSGVECTOR_H */

---