Vector.h

Go to the documentation of this file.

// BC  2/19/2004  \Bob110\Include\Vector.h

#define __VECTOR_H

#ifndef __EXPORTS_H
#include "Exports.h"
#endif
#include <math.h>

#ifdef _SIMD
#include "smlmath.h"
#endif

#define V_PI 3.1415926535898

class Matrix34;
class Matrix33;
class Vector2;
class Quaternion;

class MATRIXEXPORT Vector {
public:
   union {
#ifdef _SIMD
      struct { SMLVec3f m_smlvec3f; };
#endif      
      struct { float x, y, z; };
   };
   
   Vector( void ) {}
   Vector( float xi, float yi, float zi );
   Vector( const Vector &other );
   Vector( float f );
   Vector( const Vector2 &v2 );
   float operator[]( int i ) const;
   float &operator[]( int i );

   Vector & operator += ( const Vector &other );
   Vector & operator -= ( const Vector &other );
   Vector & operator /= ( const Vector &other )
   {
      x /= other.x;
      y /= other.y;
      z /= other.z;
      return *this;
   }
   Vector & operator *= ( const Vector &other )  // GOOD CANDIDATES FOR sse, NOT IN sml
   {
      x *= other.x;
      y *= other.y;
      z *= other.z;
      return *this; 
   }

   Vector & operator *= ( float scale );
   Vector & operator /= ( float scale );
   Vector & operator ^= ( const Vector &a ) { return (*this = Cross(a)); }

   Vector & operator *= ( const Matrix34 &m );
   Vector & operator *= ( const Matrix33 &m );
   Vector & operator *= ( const Quaternion &q );

   Vector & Negate( void );
   void Set( float xi, float yi, float zi );
   void Set( float f );
   void Swap( Vector &a )           { Vector temp(*this); *this = a; a = temp; }

   int operator == ( const Vector &a ) const;
   int operator != ( const Vector &a ) const { return !(*this == a); }   
   
   Vector operator + ( const Vector &a )   const { return Vector(*this) += a; }
   Vector operator - ( const Vector &a )   const { return Vector(*this) -= a; }
   Vector operator - ( void )              const { return Vector(*this).Negate(); } // unary minus
   Vector operator * ( const Vector &a )   const { return Vector(*this) *= a; }
   Vector operator * ( float s )           const { return Vector(*this) *= s; }
   Vector operator / ( float s )           const { return Vector(*this) /= s; }
   Vector operator / ( const Vector &a )   const { return Vector(*this) /= a; }

   float Norm( void ) const;
   Vector Normalized( void )    const { return Vector(*this).Normalize(); }
   float NormalizeLength( void )
   {
      float length = Norm();
      if (length)
         operator /= (length);
      return length;
   }
   Vector & Normalize( void );
   float Dot( const Vector &a ) const;
   float Square( void )       const { return Dot(*this); }
   Vector Absolute( void )    const { return Vector( (float)fabs( x ), (float)fabs( y ), (float)fabs( z )); }
   Vector Reciprocal( void )  const { return Vector( 1.0f/x, 1.0f/y, 1.0f/z ); }
   void CrossSelf( const Vector &a )     { *this = Cross( a ); }
   Vector Cross( const Vector &v ) const
   {
      return Vector(y*v.z - z*v.y, z*v.x - x*v.z, x*v.y - y*v.x);  // SML is just inline anyway, save = operator
   }
   Vector Hundredized()        const { return Vector(*this).Hundredize(); } 
   Vector & Hundredize( void )
   {
      float length = Norm();
      if (length)
         *this *= (100/length);
      return *this;
   }

   float operator | ( const Vector &a ) const { return Dot(a); } // same as Dot
   Vector operator ^ ( const Vector &a ) const { return Cross(a); } // same as Cross

   friend Vector operator * ( const float s, const Vector &a )  { return a * s; }
   friend float Dot( const Vector &a, const Vector &b )         { return a.Dot(b); }
   friend Vector Cross( const Vector &a, const Vector &b )      { return a.Cross(b); }
   friend void Swap( Vector &a, Vector &b )                     { a.Swap(b); }
   friend BOOL IsBackward( const Vector &a, const Vector &b, const Vector &c )
   {
      return (b.x-a.x) * (c.y-a.y) - (b.y-a.y) * (c.x-a.x) < 0;
   }

   void Min(float min) { if (x<min) x=min; if (y<min) y=min; if (z<min) z=min; }
   void Max(float max) { if (x>max) x=max; if (y>max) y=max; if (z>max) z=max; }
};

inline float DistancePointToPlane( const Vector &point, const Vector &pointonplane, const Vector &normal )
{
   Vector delta = point;
   delta -= pointonplane;
   return Dot( delta, normal );
}

inline void PushMinMax( const Vector &p, Vector &minv, Vector &maxv )
{
   if ( p.x > maxv.x )
      maxv.x = p.x;
   if ( p.x < minv.x )
      minv.x = p.x;
   if ( p.y > maxv.y )
      maxv.y = p.y;
   if ( p.y < minv.y )
      minv.y = p.y;
   if ( p.z > maxv.z )
      maxv.z = p.z;
   if ( p.z < minv.z )
      minv.z = p.z;
}

#ifdef _SIMD

inline Vector::Vector( float xi, float yi, float zi ) :  m_smlvec3f(xi, yi, zi)
{
}

inline Vector::Vector( const Vector &other ) : m_smlvec3f( other.m_smlvec3f )
{
}

inline Vector::Vector( float f ) : m_smlvec3f( f, f, f )
{
}

inline float Vector::operator[]( int i ) const
{
   return m_smlvec3f[i];
}

inline float &Vector::operator[]( int i )
{
   return m_smlvec3f[i];
}

inline Vector & Vector::operator += ( const Vector &other )
{
   m_smlvec3f += other.m_smlvec3f;
   return *this;
}

inline Vector & Vector::operator -= ( const Vector &other )
{
   m_smlvec3f -= other.m_smlvec3f;
   return *this;
}

inline Vector & Vector::operator *= ( float scale )
{
   m_smlvec3f *= scale;
   return *this;
}

inline Vector & Vector::operator /= ( float scale )
{
   m_smlvec3f /= scale;
   return *this;
}

inline Vector & Vector::Negate( void )
{
   m_smlvec3f.Negate();
   return *this;
}

inline void Vector::Set( float xi, float yi, float zi )
{
   m_smlvec3f.Set(xi, yi, zi);
}

inline void Vector::Set( float f )
{
   m_smlvec3f.Set(f,f,f);
}

inline int Vector::operator == ( const Vector &a ) const
{
   return m_smlvec3f == a.m_smlvec3f;
}

inline float Vector::Norm( void ) const
{
   return m_smlvec3f.Length();
} 

inline Vector & Vector::Normalize( void )
{
   m_smlvec3f.Normalize();
   return *this;
}

inline float Vector::Dot( const Vector &a ) const
{
   return m_smlvec3f.Dot(a.m_smlvec3f);
}

#else  // not SIMD

inline Vector::Vector( float xi, float yi, float zi )
{
   Set(xi,yi,zi);
}

inline Vector::Vector( const Vector &other )
{
   *this = other;
}

inline Vector::Vector( float fill )
{
   Set(fill);
}

inline float Vector::operator[]( int i ) const
{
   return (&x)[i];
}

inline float &Vector::operator[]( int i )
{
   return (&x)[i];
}

inline Vector & Vector::operator += ( const Vector &other )
{
   x += other.x;
   y += other.y;
   z += other.z;
   return *this; 
}

inline Vector & Vector::operator -= ( const Vector &other )
{
   x -= other.x;
   y -= other.y;
   z -= other.z;
   return *this; 
}

inline Vector & Vector::operator *= ( float scale )
{
   x *= scale;
   y *= scale;
   z *= scale;
   return *this;
}

inline Vector & Vector::operator /= ( float scale )
{
   x /= scale;
   y /= scale;
   z /= scale;
   return *this;
}

inline Vector & Vector::Negate( void )
{
   x = -x;
   y = -y;
   z = -z;
   return *this;
}

inline void Vector::Set( float xi, float yi, float zi )
{
   x = xi;
   y = yi;
   z = zi;
}

inline void Vector::Set( float fill )
{
   x = y = z = fill;
}

inline int Vector::operator == ( const Vector &a ) const
{
   return (x == a.x) && (y == a.y) && (z == a.z);
}

inline float Vector::Norm( void ) const
{
   return (float)sqrt(Square());
}

inline Vector & Vector::Normalize( void )
{
//   *this *= InverseSqrt( x*x + y*y + z*z );
   float length = Norm();
   if (length)
      *this /= length;
   return *this;
}

inline float Vector::Dot( const Vector &a ) const
{
   return x * a.x + y * a.y + z * a.z;
}

#endif // not SIMD

---