utilityfuncs.h

#ifndef __UTILITYFUNCS_H__
#define __UTILITYFUNCS_H__

#include <math.h>


class sPoint3f
{
public:

    sPoint3f() { x = 0; y = 0; z = 0; }
    sPoint3f( float i, float j, float k) { x = i; y = j; z = k; }
    void Init(float i, float j, float k) { x = i; y = j; z = k; }
    sPoint3f operator= (sPoint3f v); 
    float x, y, z;
};

class sVector3f
{
public:

    sVector3f() { x = 0; y = 0; z = 0; }
    sVector3f( float i, float j, float k) { x = i; y = j; z = k; }
    Init( float i, float j, float k) { x = i; y = j; z = k; }
    sVector3f operator= (sVector3f v); 
    float x, y, z;
};

class sGrad
{
public:
    sGrad() {}
    sGrad(float i, float j, float k) { x = i; y = j; z = k; }

    sGrad operator= (sVector3f v);
    float x,y,z;
};

class sRGBA
{
public:

    sRGBA operator+= (sRGBA v);
    float r;
    float g;
    float b;
    float a;
};


class  CVector3f
{
public:
    CVector3f()
    {
        _mag = 0;
        _vec.x = 0;         _vec.y = 0;         _vec.z = 0, 
        _normalized.x = 0;  _normalized.y = 0;  _normalized.z = 0;
    };

    CVector3f(float x, float y, float z)
    {
        Set(x,y,z);
    }

    void Set(sPoint3f sPoint)
    {
        Set(sPoint.x, sPoint.y, sPoint.z);
    }

    void Set(float x, float y, float z)
    {
        _vec.x = x; _vec.y = y; _vec.z = z;

        _mag = sqrt( _vec.x * _vec.x + _vec.y * _vec.y + _vec.z * _vec.z );

        if ( 0 != _mag )
        {
            _normalized.x = x / _mag;
            _normalized.y = y / _mag;
            _normalized.z = z / _mag;
        }
        else
        {
            _normalized.x = 0;
            _normalized.y = 0;
            _normalized.z = 0;
        }
    }

    float     GetMagnitude()    { return _mag; }
    sVector3f GetNormalized()   { return _normalized; }
    sPoint3f  GetPoint()        
    { 
        sPoint3f point; 
        
        point.x = _vec.x; 
        point.y = _vec.y;
        point.z = _vec.z;

        return point;
    }
    
private:
    sVector3f  _vec, _normalized;
    float      _mag;
};

/*
 * 
 *
 */

sPoint3f operator + (sPoint3f c1, sVector3f c2);
sPoint3f operator - (sPoint3f c2, sPoint3f c1);

float dot(sVector3f v1, sVector3f v2);

sGrad operator + (sGrad g1, sGrad g2);
sGrad operator / (sGrad g1, float k);
sGrad operator * (sGrad g1, float k);

#endif

---