Frm_3DMath.h

Go to the documentation of this file.

// Frm_3DMath.h
// Declares vector, matrix, rectangles and defines special
// array elements
 
#ifndef FRM_MATH_H
#define FRM_MATH_H
 
#include <mem.h>
 
namespace Frm {
 
//Vector description/////////////////////////
template <typename T>
class vector {
        public:
                T x, y, z;
      vector(void): x(0), y(0), z(0) {};
      vector(T px, T py, T pz): x(px), y(py), z(pz) {};
        vector(const vector<T> &pv):x (pv.x), y(pv.y), z(pv.z){};
      vector(const T* &pv){x = pv[0]; y = pv[1]; z = pv[2];};
 
      vector<T>& operator=(const vector<T> pv)
        {x = pv.x; y = pv.y; z = pv.z; return *this;};
      inline void Set(T px, T py, T pz){x=px; y=py; z=pz;};
      bool operator>(const vector<T> &pv){return (x+y)>(pv.x+pv.y);};
 
      T operator[](int index)const{if (index== 1) return y; if (index== 2)return z; return x;};
      T& operator[](int index){if (index== 1) return y; if (index== 2)return z; return x;};
 
      vector<T> operator+(vector<T> pv)const {return vector<T>((T)(x + pv.x), (T)(y + pv.y), (T)(z + pv.z));};
      vector<T> operator-(vector<T>& pv)const{return vector<T>((T)(x - pv.x), (T)(y - pv.y),(T)(z - pv.z));};
      vector<T> operator*(T& pT)const{return vector<T>((T)(pT * x), (T)(pT * y), (T)(pT * z));};
 
      void Normalize(void){vector<T> pv((T)(x*x),(T)(y*y), (T)(z*z));T fLength = (T)(1.0f/(float)(pv.x + pv.y + pv.z)); if (fLength < 1e-08) return; x = (T)(pv.x * fLength); y = (T)(pv.y * fLength); z = (T)(pv.z * fLength);};
      T Dot(vector<T> pV)const{return (T)(x*pV.x + y*pV.y + z*pV.z);};
      vector<T> Cross(vector<T> pV)const{return vector<T>((T)(y * pV.z - z * pV.y), (T)(z * pV.x - x * pV.z), (T)(x * pV.y - y * pV.x));};
      vector<T> UnitCross(vector<T> pV)const{vector<T> pR((T)(y * pV.z - z * pV.y), (T)(z * pV.x - x * pV.z), (T)(x * pV.y - y * pV.x)); pR.Normalize(); return pR;};
};
 
template<typename T, int size>
struct Array {
        T data[size];
   Array(void){memset(data, 0, size * sizeof(T));};
   Array(const Array<T, size> &pA){memcpy(data, pA.data, size * sizeof(T));};
   Array(const T* pT){memcpy(data, pT, size * sizeof(T));};
 
        Array<T, size>& operator=(Array<T, size> pA)
        {memcpy(data, pA.data, size * sizeof(T)); return *this;};
   Array<T, size>& operator+=(Array<T, size> &pA);
   Array<T, size> Mult(const T pScalar);
   Array<T, size> operator+(Array<T, size> &pA);
   T operator[](int index)const{return data[index];};
   T& operator[](int index){return data[index];};
};
 
typedef Array<unsigned short, 3> Face;
typedef Array<float, 3> Vertex;
typedef Array<float, 2> TCoord;
typedef Array<float, 4> Color4;
typedef Array<float, 3> Color3;
 
template<typename T>
Array<T, 4> Set4(T px, T py, T pz, T pw){T data[4]; data[0]=px; data[1]=py; data[2]=pz; data[3]=pw;return Array<T, 4>(data);};
 
template<typename T>
Array<T, 3> Set3(T px, T py, T pz){T data[3]; data[0]=px; data[1]=py; data[2]=pz;return Array<T, 3>(data);};
 
template<typename T>
Array<T, 2> Set2(T pu, T pv){T data[2]; data[0]=pu; data[1]=pv;return Array<T, 2>(data);};
 
template<typename T, int size>
Array<T, size>& Array<T, size>::operator+=(Array<T, size> &pA)
{
   for (int i= 0; i< size; i++)
        data[i] += pA.data[i];
   return *this;
}
 
template<typename T, int size>
Array<T, size> Array<T, size>::Mult(const T pScalar)
{
        T rdata[size];
   memcpy(rdata, data, size * sizeof(T));
   for (int i= 0; i< size; i++)
        rdata[i]*=pScalar;
   return Array<T,size>(rdata);
}
 
template<typename T, int size>
Array<T, size> Array<T, size>::operator+(Array<T, size> &pA)
{
        T rdata[size];
   for (int i= 0; i< size; i++)
        rdata[i]=data[i] + pA.data[i];
   return Array<T,size>(rdata);
};
 
 
};
#endif