---

vec3f.hpp

//==========================================================================
// Vec3.hpp : 3d vector class template. Works for any integer or real type.
//==========================================================================

#ifndef VEC3_H
#define VEC3_H

#include <stdio.h>
#include <math.h>

template<class Type>
class Vec3
{
  public:
    Type x, y, z;  

    Vec3 (void) 
      {};
    Vec3 (const Type X, const Type Y, const Type Z) 
      { x=X; y=Y; z=Z; };
    Vec3 (const Vec3& v) 
      { x=v.x; y=v.y; z=v.z; };
    Vec3 (const Type v[3])
      { x=v[0]; y=v[1]; z=v[2]; };
    void Set (const Type X, const Type Y, const Type Z)
      { x=X; y=Y; z=Z; }
    void Set (const Type v[3])
      { x=v[0]; y=v[1]; z=v[2]; };

    operator Type*()                            
      { return (Type *)&x; }
    operator const Type*() const                
      { return &x; }

    int operator == (const Vec3& A) const       
      { return (x==A.x && y==A.y && z==A.z); }

    Vec3& operator = (const Vec3& A)            
      { x=A.x; y=A.y; z=A.z; 
        return(*this);  };
    Vec3 operator + (const Vec3& A) const       
      { Vec3 Sum(x+A.x, y+A.y, z+A.z); 
        return(Sum); };
    Vec3 operator - (const Vec3& A) const       
      { Vec3 Diff(x-A.x, y-A.y, z-A.z);
        return(Diff); };
    Type operator * (const Vec3& A) const       
      { Type DotProd = x*A.x+y*A.y+z*A.z; 
        return(DotProd); };
    Vec3 operator / (const Vec3& A) const       
      { Vec3 CrossProd(y*A.z-z*A.y, z*A.x-x*A.z, x*A.y-y*A.x);
        return(CrossProd); };
    Vec3 operator ^ (const Vec3& A) const       
      { Vec3 CrossProd(y*A.z-z*A.y, z*A.x-x*A.z, x*A.y-y*A.x);
        return(CrossProd); };
    Vec3 operator * (const Type s) const        
      { Vec3 Scaled(x*s, y*s, z*s); 
        return(Scaled); };
    Vec3 operator / (const Type s) const        
      { Vec3 Scaled(x/s, y/s, z/s);
        return(Scaled); };
    Vec3 operator & (const Vec3& A) const       
      { Vec3 CompMult(x*A.x, y*A.y, z*A.z);
        return(CompMult); }

    friend inline Vec3 operator *(Type s, const Vec3& v)  
      { return Vec3(v.x*s, v.y*s, v.z*s); }

    Vec3& operator += (const Vec3& A)    
      { x+=A.x; y+=A.y; z+=A.z;
        return *this;}
    Vec3& operator -= (const Vec3& A)    
      { x-=A.x; y-=A.y; z-=A.z; 
        return *this; }
    Vec3& operator *= (const Type s)     
      { x*=s; y*=s; z*=s; 
        return *this; }
    Vec3& operator /= (const Type s)     
      { x/=s; y/=s; z/=s; 
        return *this; }
    Vec3& operator &= (const Vec3& A)  
      { x*=A.x; y*=A.y; z*=A.z; return *this; }
    Vec3 operator - (void) const        
      { Vec3 Negated(-x, -y, -z);
        return(Negated); };

/*
    const Type& operator [] (const int i) const // ALLOWS VECTOR ACCESS AS AN ARRAY.
      { return( (i==0)?x:((i==1)?y:z) ); };
    Type & operator [] (const int i)
      { return( (i==0)?x:((i==1)?y:z) ); };
*/

    Type Length (void) const                     
      { return ((Type)sqrt(x*x+y*y+z*z)); };
    Type LengthSqr (void) const                  
      { return (x*x+y*y+z*z); };
    Vec3& Normalize (void)                       
      { Type L = Length();                       //  CALCULATE LENGTH
        if (L>0) { x/=L; y/=L; z/=L; }           //  DIV COMPONENTS BY LENGTH
        return *this;
      };                                         


    Type* Star() const {
      Type s[] = ( 0, -z,  y,
                   z,  0, -x,
                  -y,  x,  0);
      return s;
    }


    void UpdateMinMax(Vec3 &Min, Vec3 &Max) const
    {
      if (x<Min.x) Min.x=x; else if (x>Max.x) Max.x=x;
      if (y<Min.y) Min.y=y; else if (y>Max.y) Max.y=y;
      if (z<Min.z) Min.z=z; else if (z>Max.z) Max.z=z;
    }


  void CompleteOrthonormalBasis(Vec3 &U, Vec3 &V) const
    {
      U = *this;
      unsigned char s[3] = {0, 1, 2}; 
      unsigned char tmpa;
      U.x = U.x < 0 ? -U.x : -U.x;
      U.y = U.y < 0 ? -U.y : -U.y;
      U.z = U.z < 0 ? -U.z : -U.z;
      if ( U[0] > U[1] )
      {
        tmpa = s[0];
        s[0] = s[1];
        s[1] = tmpa;
      }
      // xy min in s[0] now.
      if ( U[s[0]] > U[2] ) {
        tmpa = s[2];
        s[2] = s[0];
        s[0] = tmpa;
      }
      // xyz min in s[0] now
      U = *this;
      U[s[0]] = 0;

      // Voila U is now perpendicular to *this
      U.Normalize();

      // And so it's easy to find a v that is too, with cross product.
      V = *this ^ U;
      // Or by removing components projected onto other two...
      // I think the cross product may be cheaper
      // V = something - V * (*this.Normalize() + U);

      V.Normalize(); // wouldn't be necessary if we knew *this were normalized
    }

    void Print() const
      { printf("(%.3f, %.3f, %.3f)\n",x, y, z); }

    static Vec3 ZERO;
};

typedef Vec3<float> Vec3f;
typedef Vec3<double> Vec3d;

template<class Type> Vec3<Type> Vec3<Type>::ZERO = Vec3<Type>(0,0,0);

#endif

---