---

MyMathUtils.h

#if !defined __MYMATHUTILS_H
#define __MYMATHUTILS_H


#include "assert.h"
#include "math.h"
#include "stdlib.h"


#define PI                3.1415926535
#define feps          0.001f            //float calculation failure
#define deps         0.000000001f       //double calcualtion failure

#define DIV_DEG_TO_RAD    57.29577951   //= 180 / PI
#define DIV_RAD_TO_DEG    0.017453293   //= PI / 180

#define MUL_DEG_TO_RAD    DIV_RAD_TO_DEG
#define MUL_RAD_TO_DEG    DIV_DEG_TO_RAD



class Vektor3f;
class Vektor4f;


class Matrix4f  //Spaltenweise angeordnet !!! (OpenGL Style)
{
public:
  float m[16];

  Matrix4f()
  {
    //Do nothing in default constructor, be CAREFUL !!
  }


  Matrix4f(Matrix4f &p)
  {
    *this = p;
  }

  Matrix4f(float m0, float m4, float m8, float m12,
         float m1, float m5, float m9, float m13,
         float m2, float m6, float m10, float m14,
         float m3, float m7, float m11, float m15)
  {
    m[0] = m0; m[4] = m4; m[8] = m8;   m[12] = m12;
    m[1] = m1; m[5] = m5; m[9] = m9;   m[13] = m13;
    m[2] = m2; m[6] = m6; m[10] = m10; m[14] = m14;
    m[3] = m3; m[7] = m7; m[11] = m11; m[15] = m15;
  }

  inline void set(float m0, float m4, float m8, float m12,
                  float m1, float m5, float m9, float m13,
                  float m2, float m6, float m10, float m14,
                  float m3, float m7, float m11, float m15)
  {
    m[0] = m0; m[4] = m4; m[8] = m8;   m[12] = m12;
    m[1] = m1; m[5] = m5; m[9] = m9;   m[13] = m13;
    m[2] = m2; m[6] = m6; m[10] = m10; m[14] = m14;
    m[3] = m3; m[7] = m7; m[11] = m11; m[15] = m15;
  }


  inline void setIdentity()
  {
    m[0] = 1; m[4] = 0; m[8] = 0;  m[12] = 0;
    m[1] = 0; m[5] = 1; m[9] = 0;  m[13] = 0;
    m[2] = 0; m[6] = 0; m[10] = 1; m[14] = 0;
    m[3] = 0; m[7] = 0; m[11] = 0; m[15] = 1;
  }


public:
  //Calculates the inverse of the actual matrix
  bool Inverse(); //returns true if could calculate inverse matrix, otherwise false

private:
  //helper method for inverse
  void SubMatrix(float *m3, int i, int j);

public:
  float getDeterminant(); //calculates determinant of the current matrix


  //Matrix transformations (affecting the current matrix)
public:
  void RotateX(float angle);

  void RotateY(float angle);

  void RotateZ(float angle);

  void Rotate(float angle, Vektor3f &v);

  void Rotate(float angle, float px, float py, float pz);

  void Translate(Vektor3f &v);

  void Translate(float px, float py, float pz);

  void Scale(float sx, float sy, float sz);


  void LookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez, GLdouble centerx, GLdouble centery, GLdouble centerz, GLdouble upx, GLdouble upy, GLdouble upz);

  void LookAt(Vektor3f &p_Position, Vektor3f &p_ViewingDirection, Vektor3f &p_UpViewingDirection);

  void LookAt(Vektor3f &p_Position, Vektor3f &p_ViewingDirection, Vektor3f &p_UpViewingDirection, Vektor3f &p_NormalViewingDirection);  //All Vektors must be normalized

  void LookTo(Vektor3f &p_Position, Vektor3f &p_ViewingDirection, Vektor3f &p_UpViewingDirection);

  void LookTo(Vektor3f &p_Position, Vektor3f &p_ViewingDirection, Vektor3f &p_UpViewingDirection, Vektor3f &p_NormalViewingDirection);  //All Vektors must be normalized

public:
  //Matrix transformations (overwriting the current matrix)

  void setRotateX(float angle);

  void setRotateY(float angle);

  void setRotateZ(float angle);

  void setRotate(float angle, Vektor3f &v);

  void setRotate(float angle, float px, float py, float pz);

  void setTranslate(Vektor3f &v);

  void setTranslate(float px, float py, float pz);

  void setScale(float sx, float sy, float sz);


  void setLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez, GLdouble centerx, GLdouble centery, GLdouble centerz, GLdouble upx, GLdouble upy, GLdouble upz);

  void setLookAt(Vektor3f &p_Position, Vektor3f &p_ViewingDirection, Vektor3f &p_UpViewingDirection);

  void setLookAt(Vektor3f &p_Position, Vektor3f &p_ViewingDirection, Vektor3f &p_UpViewingDirection, Vektor3f &p_NormalViewingDirection);  //All Vektors must be normalized

  void setLookTo(Vektor3f &p_Position, Vektor3f &p_ViewingDirection, Vektor3f &p_UpViewingDirection);

  void setLookTo(Vektor3f &p_Position, Vektor3f &p_ViewingDirection, Vektor3f &p_UpViewingDirection, Vektor3f &p_NormalViewingDirection);  //All Vektors must be normalized


  //Create some operators for this class

  Matrix4f operator*(Matrix4f &p);    //Matrix multiplication, return result

  Matrix4f& operator*=(Matrix4f &p);  //Matrix multiplication, result stored in actual matrix


  Vektor3f operator*(Vektor3f &v);    //Matrix * Vektor3f Product, return result  

  Vektor4f operator*(Vektor4f &v);    //Matrix * Vektor4f Product, return result
};


typedef Matrix4f Matrix4d;  //TODO: temporary
typedef Matrix4f Matrix;




// 2 dimensional vector

//Definition of class Vektor2f
#define VECTOR Vektor2f
#define SCALAR float


class Vektor2f
{
public:
  Vektor2f()
  {
    setNull();
  }

  Vektor2f(SCALAR px, SCALAR py)
  {
    set(px, py);
  }

#include "MyVector2x.h"


#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR


//Definition of class Vektor2d
#define VECTOR Vektor2d
#define SCALAR float

class Vektor2d
{
public:
  Vektor2d()
  {
    setNull();
  }

  Vektor2d(SCALAR px, SCALAR py)
  {
    set(px, py);
  }

#include "MyVector2x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR



//Definition of class Vektor2l
#define VECTOR Vektor2l
#define SCALAR long

class Vektor2l
{
public:
  Vektor2l()
  {
    setNull();
  }

  Vektor2l(SCALAR px, SCALAR py)
  {
    set(px, py);
  }

#include "MyVector2x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR



//Definition of class Vektor2ul
#define VECTOR Vektor2ul
#define SCALAR unsigned long
#define SCALARUNSIGNED

class Vektor2ul
{
public:
  Vektor2ul()
  {
    setNull();
  }

  Vektor2ul(SCALAR px, SCALAR py)
  {
    set(px, py);
  }

#include "MyVector2x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR




//Definition of class Vektor2i
#define VECTOR Vektor2i
#define SCALAR int

class Vektor2i
{
public:
  Vektor2i()
  {
    setNull();
  }

  Vektor2i(SCALAR px, SCALAR py)
  {
    set(px, py);
  }

#include "MyVector2x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR



//Definition of class Vektor2ui
#define VECTOR Vektor2ui
#define SCALAR unsigned int
#define SCALARUNSIGNED

class Vektor2ui
{
public:
  Vektor2ui()
  {
    setNull();
  }

  Vektor2ui(SCALAR px, SCALAR py)
  {
    set(px, py);
  }

#include "MyVector2x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR




//Definition of class Vektor2b
#define VECTOR Vektor2b
#define SCALAR char

class Vektor2b
{
public:
  Vektor2b()
  {
    setNull();
  }

  Vektor2b(SCALAR px, SCALAR py)
  {
    set(px, py);
  }

#include "MyVector2x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR




//Definition of class Vektor2ub
#define VECTOR Vektor2ub
#define SCALAR unsigned char
#define SCALARUNSIGNED

class Vektor2ub
{
public:
  Vektor2ub()
  {
    setNull();
  }

  Vektor2ub(SCALAR px, SCALAR py)
  {
    set(px, py);
  }

#include "MyVector2x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR




// 3 dimensional vector

//Definition of class Vektor3f
#define VECTOR Vektor3f
#define SCALAR float
#define USEMATRIX
#define VECTORMATRIX Matrix4f


class Vektor3f
{
public:
  Vektor3f()
  {
    setNull();
  }

  Vektor3f(SCALAR px, SCALAR py, SCALAR pz)
  {
    set(px, py, pz);
  }

#include "MyVector3x.h"


#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR


//Definition of class Vektor3d
#define VECTOR Vektor3d
#define SCALAR float

class Vektor3d
{
public:
  Vektor3d()
  {
    setNull();
  }

  Vektor3d(SCALAR px, SCALAR py, SCALAR pz)
  {
    set(px, py, pz);
  }

#include "MyVector3x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR



//Definition of class Vektor3l
#define VECTOR Vektor3l
#define SCALAR long

class Vektor3l
{
public:
  Vektor3l()
  {
    setNull();
  }

  Vektor3l(SCALAR px, SCALAR py, SCALAR pz)
  {
    set(px, py, pz);
  }

#include "MyVector3x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR



//Definition of class Vektor3ul
#define VECTOR Vektor3ul
#define SCALAR unsigned long
#define SCALARUNSIGNED

class Vektor3ul
{
public:
  Vektor3ul()
  {
    setNull();
  }

  Vektor3ul(SCALAR px, SCALAR py, SCALAR pz)
  {
    set(px, py, pz);
  }

#include "MyVector3x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR




//Definition of class Vektor3i
#define VECTOR Vektor3i
#define SCALAR int

class Vektor3i
{
public:
  Vektor3i()
  {
    setNull();
  }

  Vektor3i(SCALAR px, SCALAR py, SCALAR pz)
  {
    set(px, py, pz);
  }

#include "MyVector3x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR



//Definition of class Vektor3ui
#define VECTOR Vektor3ui
#define SCALAR unsigned int
#define SCALARUNSIGNED

class Vektor3ui
{
public:
  Vektor3ui()
  {
    setNull();
  }

  Vektor3ui(SCALAR px, SCALAR py, SCALAR pz)
  {
    set(px, py, pz);
  }

#include "MyVector3x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR




//Definition of class Vektor3b
#define VECTOR Vektor3b
#define SCALAR char

class Vektor3b
{
public:
  Vektor3b()
  {
    setNull();
  }

  Vektor3b(SCALAR px, SCALAR py, SCALAR pz)
  {
    set(px, py, pz);
  }

#include "MyVector3x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR




//Definition of class Vektor3ub
#define VECTOR Vektor3ub
#define SCALAR unsigned char
#define SCALARUNSIGNED

class Vektor3ub
{
public:
  Vektor3ub()
  {
    setNull();
  }

  Vektor3ub(SCALAR px, SCALAR py, SCALAR pz)
  {
    set(px, py, pz);
  }

#include "MyVector3x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR




// 4 dimensional vector

//Definition of class Vektor4f
#define VECTOR Vektor4f
#define SCALAR float


class Vektor4f
{
public:
  Vektor4f()
  {
    setNull();
  }

  Vektor4f(SCALAR px, SCALAR py, SCALAR pz, SCALAR ph)
  {
    set(px, py, pz, ph);
  }

#include "MyVector4x.h"


#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR


//Definition of class Vektor4d
#define VECTOR Vektor4d
#define SCALAR float

class Vektor4d
{
public:
  Vektor4d()
  {
    setNull();
  }

  Vektor4d(SCALAR px, SCALAR py, SCALAR pz, SCALAR ph)
  {
    set(px, py, pz, ph);
  }

#include "MyVector4x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR



//Definition of class Vektor4l
#define VECTOR Vektor4l
#define SCALAR long

class Vektor4l
{
public:
  Vektor4l()
  {
    setNull();
  }

  Vektor4l(SCALAR px, SCALAR py, SCALAR pz, SCALAR ph)
  {
    set(px, py, pz, ph);
  }

#include "MyVector4x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR



//Definition of class Vektor4ul
#define VECTOR Vektor4ul
#define SCALAR unsigned long
#define SCALARUNSIGNED

class Vektor4ul
{
public:
  Vektor4ul()
  {
    setNull();
  }

  Vektor4ul(SCALAR px, SCALAR py, SCALAR pz, SCALAR ph)
  {
    set(px, py, pz, ph);
  }

#include "MyVector4x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR




//Definition of class Vektor4i
#define VECTOR Vektor4i
#define SCALAR int

class Vektor4i
{
public:
  Vektor4i()
  {
    setNull();
  }

  Vektor4i(SCALAR px, SCALAR py, SCALAR pz, SCALAR ph)
  {
    set(px, py, pz, ph);
  }

#include "MyVector4x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR



//Definition of class Vektor4ui
#define VECTOR Vektor4ui
#define SCALAR unsigned int
#define SCALARUNSIGNED

class Vektor4ui
{
public:
  Vektor4ui()
  {
    setNull();
  }

  Vektor4ui(SCALAR px, SCALAR py, SCALAR pz, SCALAR ph)
  {
    set(px, py, pz, ph);
  }

#include "MyVector4x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR




//Definition of class Vektor4b
#define VECTOR Vektor4b
#define SCALAR char

class Vektor4b
{
public:
  Vektor4b()
  {
    setNull();
  }

  Vektor4b(SCALAR px, SCALAR py, SCALAR pz, SCALAR ph)
  {
    set(px, py, pz, ph);
  }

#include "MyVector4x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR




//Definition of class Vektor4ub
#define VECTOR Vektor4ub
#define SCALAR unsigned char
#define SCALARUNSIGNED

class Vektor4ub
{
public:
  Vektor4ub()
  {
    setNull();
  }

  Vektor4ub(SCALAR px, SCALAR py, SCALAR pz, SCALAR ph)
  {
    set(px, py, pz, ph);
  }

#include "MyVector4x.h"

#undef SCALARUNSIGNED
#undef USEMATRIX
#undef VECTORMATRIX
#undef VECTOR
#undef SCALAR






// Typedefinition
typedef Vektor3f Vektor;    //Vektor3f should be known as Standard Vektor
typedef Vektor4f Color;     //Vektor4f could be used as color



class BoundingBox
{
public:
  Vektor3f m_Min, m_Max;  //Min and Max extends of the bounding box
  Vektor3f v[8];          //Bounding box
  Vektor3f m_Center;      //Center of bounding box
  Vektor3f m_Extents;     //X, Y, Z Extents of the bounding box
  float m_Radius;         //Radius of the object from the bounding box center


  BoundingBox()
  {
    m_Radius = 0;
  }


  //Initialize bounding box
  void Init(Vektor3f p_Min, Vektor3f p_Max, float p_Radius);

  //Draw bounding sphere
  void DrawSphere(Color p_Color = Color(1.0f, 1.0f, 1.0f, 1.0f));

  //Draw bounding box
  void DrawBox(Color p_Color = Color(1.0f, 1.0f, 1.0f, 1.0f));


  // Transformation operations
  void RotateX(float angle);

  void RotateY(float angle);

  void RotateZ(float angle);

  void Rotate(float angle, Vektor3f &p_v);

  void Rotate(float angle, float px, float py, float pz);
  

  void Translate(Vektor3f &p_v);

  void Translate(float px, float py, float pz);

  void Scale(float s);
};



#endif //#if !defined __MYMATHUTILS_H

---