//==========================================================================
// vec4f.hpp : 4d vector class declaration
//==========================================================================

#ifndef VEC4F
#define VEC4F

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

class Vec4f
{
  public:
    float x, y, z, w;

    Vec4f (void) 
      {};
    Vec4f (const float X, const float Y, const float Z, const float W) 
      { x=X; y=Y; z=Z; w=W; };
    Vec4f (const Vec4f& v) 
      { x=v.x; y=v.y; z=v.z; w=v.w; };
    Vec4f (float v[4])
      { x=v[0]; y=v[1]; z=v[2]; w=v[3]; };
    void Set (const float X, const float Y, const float Z, const float W)
      { x=X; y=Y; z=Z; w=W; }
    void Set (float v[4])
      { x=v[0]; y=v[1]; z=v[2]; w=v[3]; };

    operator float*()                             // FLOAT * CONVERSION
      { return (float *)&x; }
    operator const float*() const                 // CONST FLOAT * CONVERSION
      { return &x; }

    int operator == (const Vec4f& A)              // COMPARISON (==)
      { return x==A.x && y==A.y &&
        z==A.z && w==A.w; } 
    Vec4f& operator = (const Vec4f& A)            // ASSIGNMENT (=)
      { x=A.x; y=A.y; z=A.z; w=A.w; 
        return(*this);  };
    Vec4f operator + (const Vec4f& A) const       // ADDITION (+)
      { Vec4f Sum(x+A.x, y+A.y, z+A.z, w+A.w); 
        return(Sum); };
    Vec4f operator - (const Vec4f& A) const       // SUBTRACTION (-)
      { Vec4f Diff(x-A.x, y-A.y, z-A.z, w-A.w);
        return(Diff); };
    float operator * (const Vec4f& A) const       // DOT-PRODUCT (*)
      { float DotProd = x*A.x+y*A.y+z*A.z+w*A.w; 
        return(DotProd); };
    Vec4f operator * (const float s) const        // MULTIPLY BY SCALAR (*)
      { Vec4f Scaled(x*s, y*s, z*s, w*s); 
        return(Scaled); };
    Vec4f operator / (const float s) const        // DIVIDE BY SCALAR (/)
      { Vec4f Scaled(x/s, y/s, z/s, w/s);
        return(Scaled); };

    friend inline Vec4f operator *(float s, const Vec4f& v)  // SCALAR MULT s*V
      { return Vec4f(v.x*s, v.y*s, v.z*s, v.w*s); }

    void operator += (const Vec4f A)              // ACCUMULATED VECTOR ADDITION (+=)
      { x+=A.x; y+=A.y; z+=A.z; w+=A.w; };
    void operator -= (const Vec4f A)              // ACCUMULATED VECTOR SUBTRACTION (+=)
      { x-=A.x; y-=A.y; z-=A.z; w-=A.w; };
    void operator *= (const float s)              // ACCUMULATED SCALAR MULT (*=)
      { x*=s; y*=s; z*=s; w*=s; };
    void operator /= (const float s)              // ACCUMULATED SCALAR DIV (/=)
      { x/=s; y/=s; z/=s; w/=s; };
    Vec4f operator - (void) const                 // NEGATION (-)
      { Vec4f Negated(-x, -y, -z, -w);
        return(Negated); };

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

    float Length (void) const                     // LENGTH OF VECTOR
      { return ((float)sqrt(x*x+y*y+z*z+w*w)); };
    float LengthSqr (void) const                  // LENGTH OF VECTOR (SQUARED)
      { return (x*x+y*y+z*z+w*w); };
    void Normalize (void)                         // NORMALIZE VECTOR
      { float L = Length();                       // CALCULATE LENGTH
        if (L>0) { x/=L; y/=L; z/=L; w/=L; } };   // DIV COMPONENTS BY LENGTH

    void Wdiv(void)
      { x/=w; y/=w; z/=w; w=1; }

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

#endif