Vector4.h

Go to the documentation of this file.

// RC  4/24/2002  \HRandy95\Include\Vector4.h

#define __VECTOR4_H

#ifndef __VECTOR_H
#include "Vector.h"
#endif
#ifndef __EXPORTS_H
#include "Exports.h"
#endif

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

class Matrix44;

class Vector4 
{
protected:
   union {
#ifdef _SIMD
      struct { SMLVec4f m_smlvec4f; };
#endif
      struct { float n[4]; };
   };

public:
   Vector4( void ) {}
   Vector4( float x, float y, float z, float w );
   Vector4( float fill );
   Vector4( const Vector4 &v );
   Vector4( const Vector &other3 );
   
   friend class Matrix44;

   float operator[]( int i ) const;
   float &operator[]( int i );
   void Set( float x, float y, float z, float w );
   void Set( float fill )
   {
      n[0] = n[1] = n[2] = n[3] = fill;
   }
   Vector4 & operator = ( const Vector4 &v );
   Vector4 & operator /= ( float scalar );
   Vector4 & operator -= ( const Vector4 &other );
   Vector4 & operator += ( const Vector4 &other );
   Vector4 & operator *= ( float scale );
   int operator == ( const Vector4 &a ) const;
   int operator != ( const Vector4 &a ) const { return !(*this == a); }   

   Vector4 operator + ( const Vector4 &a ) const { return Vector4(*this) += a; }
   Vector4 operator - ( const Vector4 &a ) const { return Vector4(*this) -= a; }

   float operator | ( const Vector4 &b ) const;   // Dot Product
   float operator | ( const Vector &b ) const;   // Dot Product
   Vector4 operator * ( const Vector4 &b ) const // Member by member multiply
   {
      Vector4 result;               // GOOD CANDIDATE FOR SIMD, NOT IN SML
      result[0] = n[0] * b[0];
      result[1] = n[1] * b[1];
      result[2] = n[2] * b[2];
      result[3] = n[3] * b[3];
      return result;
   }
   Vector4 operator * ( float scalar ) const 
   {
      return Vector4(*this) *= scalar;
   }
   friend MATRIXEXPORT Vector4 operator * ( float scalar, const Vector4 &v )
   {
      return v * scalar;
   }
   friend void Swap( Vector4 &a, Vector4 &b )
   {
      Vector4 temp( a );
      a = b;
      b = temp;
   }
};

#ifdef _SIMD

inline Vector4::Vector4( float x, float y, float z, float w ) : m_smlvec4f( x, y, z, w )
{
}

inline Vector4::Vector4( float f ) : m_smlvec4f( f, f, f, f )
{
}

inline Vector4::Vector4( const Vector4 &v ) : m_smlvec4f( v.m_smlvec4f )
{
}

inline Vector4::Vector4( const Vector &other3 ) : m_smlvec4f( other3[0],other3[1],other3[2],1.0f )
{
}

inline float Vector4::operator[]( int i ) const
{
   return m_smlvec4f.data()[i];
}

inline float &Vector4::operator[]( int i )
{
   return m_smlvec4f.data()[i];
}

inline void Vector4::Set( float x, float y, float z, float w )
{
   m_smlvec4f.Set( x, y, z, w );
}

inline Vector4 & Vector4::operator = ( const Vector4 &v )
{
   m_smlvec4f = v.m_smlvec4f; return *this;
}

inline Vector4 & Vector4::operator /= ( float scalar )
{
   m_smlvec4f /= scalar; return *this;
}

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

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

inline Vector4 & Vector4::operator *= ( float scale )
{
   m_smlvec4f *= scale;
   return *this;
}

inline int Vector4::operator == ( const Vector4 &a ) const
{
   return m_smlvec4f == a.m_smlvec4f;
}

inline float Vector4::operator | ( const Vector4 &b ) const   // Dot Product
{
   return m_smlvec4f.Dot( b.m_smlvec4f );
}

#else // NOT SIMD

inline Vector4::Vector4( float x, float y, float z, float w )
{
   Set(x,y,z,w);
}

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

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

inline Vector4::Vector4( const Vector &other3 )
{
   n[0] = other3[0];
   n[1] = other3[1];
   n[2] = other3[2];
   n[3] = 1.0f;
}

inline float Vector4::operator[]( int i ) const
{
   return n[i];
}

inline float &Vector4::operator[]( int i )
{
   return n[i];
}

inline void Vector4::Set( float x, float y, float z, float w )
{
    n[0] = x;
    n[1] = y;
    n[2] = z;
    n[3] = w;
}

inline Vector4 & Vector4::operator = ( const Vector4 &other )
{
   n[0] = other[0];
   n[1] = other[1];
   n[2] = other[2];
   n[3] = other[3];
   return *this;
}

inline Vector4 & Vector4::operator /= ( float scalar )
{
   n[0] /= scalar;
   n[1] /= scalar;
   n[2] /= scalar;
   n[3] /= scalar;
   return *this;
}

inline Vector4 & Vector4::operator -= ( const Vector4 &other )
{
   n[0] -= other[0];
   n[1] -= other[1];
   n[2] -= other[2];
   n[3] -= other[3];
   return *this;
}

inline Vector4 & Vector4::operator += ( const Vector4 &other )
{
   n[0] += other[0];
   n[1] += other[1];
   n[2] += other[2];
   n[3] += other[3];
   return *this;
}

inline Vector4 & Vector4::operator *= ( float scale )
{
   n[0]*=scale;
   n[1]*=scale;
   n[2]*=scale;
   n[3]*=scale;
   return *this;
}

inline int Vector4::operator == ( const Vector4 &a ) const
{
   return n[0]==a[0] && n[1]==a[1] && n[2]==a[2] && n[3]==a[3];
}

inline float Vector4::operator | ( const Vector4 &b ) const   // Dot Product
{
   return n[0]*b[0] + n[1]*b[1] + n[2]*b[2] + n[3]*b[3];
}

inline float Vector4::operator | ( const Vector &b ) const   // Dot Product
{
   return n[0]*b[0] + n[1]*b[1] + n[2]*b[2] + n[3];
}

#endif // NOT SIMD

---