Search  

---

C:/temp/src/j2k/Beta/Math/Vector/NotDone/jMatrix.hpp

Go to the documentation of this file.

/*
The class jMatrix is a 4x4 matrix, and can deal with some of the operations that can be performed on a matrix. The class was designed with the intention of it's being used for transforming points in 3d space. Any object can be represented by enough points, therefore, It can be used to transform any 3d object. Lower dimentions should work also, but if it called often, will probably have a heavy cost.

All functions that are specific to 3d transformation of points are held in a Seperate class, jMatrixStack.

FIXME:
  check over jMatrixStack, something may be fishy... not intuitive

  make matrix class designed for 2d space
  make stack for 2d matrix
  come up with better names
  seperate the stacks for the matrices... -easy, just make a new file
  possibly make variable sized matrix, probably only usefull to math
*/

#ifndef __jmatrix_h_
#define __jmatrix_h_

#include <vector>
#include <stdio.h>
#include <math.h>
#include <joe/vect3f.h>

using namespace std;

const double pi =  acos(-1);

//////////////////////////////////////////////////////////////
//*********************************************************///
//////////////////////////////////////////////////////////////

class jMatrix
{
 public:
  // constructors
  jMatrix() {}
  jMatrix(const jMatrix& obj);
  ~jMatrix() {}
  
  // variables
  float m[4][4];
  
  // functions
  void enter(  float m00, float m01, float m02, float m03,
      float m10, float m11, float m12, float m13,
      float m20, float m21, float m22, float m23,
      float m30, float m31, float m32, float m33);
  
  void identity();
  void clear();
  void printSelf();
  
  void add(jMatrix& add);
  void subtract(jMatrix& sub);
  void mult(jMatrix mult);
  void negative();
  
  void tform(vect3f& point);
  void tform(vect3f* point);
  
  // operators
  jMatrix operator+(jMatrix&);
  jMatrix operator-(jMatrix&);
  jMatrix operator-();
  jMatrix operator*(jMatrix&);
  
  void operator+=(jMatrix&);
  void operator-=(jMatrix&);
  void operator*=(jMatrix&);
};


jMatrix::jMatrix(const jMatrix& obj)
{
  for (int i = 0; i < 4; i++){
    for (int j = 0; j < 4; j++){
      m[i][j] = obj.m[i][j];
    }
  }
}

//---------------------------------------------------------//

void jMatrix::enter(float m00, float m01, float m02, float m03,
          float m10, float m11, float m12, float m13,
          float m20, float m21, float m22, float m23,
          float m30, float m31, float m32, float m33)
{
  m[0][0] = m00;
  m[0][1] = m01;
  m[0][2] = m02;
  m[0][3] = m03;
  
  m[1][0] = m10;
  m[1][1] = m11;
  m[1][2] = m12;
  m[1][3] = m13;
  
  m[2][0] = m20;
  m[2][1] = m21;
  m[2][2] = m22;
  m[2][3] = m23;
  
  m[3][0] = m30;
  m[3][1] = m31;
  m[3][2] = m32;
  m[3][3] = m33;
}

//---------------------------------------------------------//

void jMatrix::identity()
{
  int i, j;
  for (i = 0; i < 4; i++){
    for (j = 0; j < 4; j++){
      if (i == j)
   m[i][j] = 1;
      else
   m[i][j] = 0;
    }
  }
}

//---------------------------------------------------------//

void jMatrix::clear()
{
  int i, j;
  for (i = 0; i < 4; i++){
    for (j = 0; j < 4; j++)
      m[i][j] = 0;
  }
}

//---------------------------------------------------------//

void jMatrix::printSelf()
{
  printf("|  %-+7.2f %-+7.2f %-+7.2f %-+7.2f|\n", m[0][0], m[0][1], m[0][2], m[0][3]);
  printf("|  %-+7.2f %-+7.2f %-+7.2f %-+7.2f|\n", m[1][0], m[1][1], m[1][2], m[1][3]);
  printf("|  %-+7.2f %-+7.2f %-+7.2f %-+7.2f|\n", m[2][0], m[2][1], m[2][2], m[2][3]);
  printf("|  %-+7.2f %-+7.2f %-+7.2f %-+7.2f|\n\n", m[3][0], m[3][1], m[3][2], m[3][3]);
}

//---------------------------------------------------------//

void jMatrix::add(jMatrix& add)
{
  int i, j;
  for (i = 0; i < 4; i++){
    for (j = 0; j < 4; j++){
      m[i][j] += add.m[i][j];
    }
  }
}

//---------------------------------------------------------//

void jMatrix::subtract(jMatrix& sub)
{
  int i, j;
  for (i = 0; i < 4; i++){
    for (j = 0; j < 4; j++){
      m[i][j] -= sub.m[i][j];
    }
  }
}

//---------------------------------------------------------//

void jMatrix::mult(jMatrix mult)
{
  jMatrix tmp(*this);
  clear();
  
  int i, j, k;
  for (i = 0; i < 4; i++){
    for (j = 0; j < 4; j++){
      
      for (k = 0; k < 4; k++)
   m[i][j] += tmp.m[i][k] * mult.m[k][j];
      
    }
  }
}

//---------------------------------------------------------//

void jMatrix::negative()
{
  int i, j;
  for (i = 0; i < 4; i++){
    for (j = 0; j < 4; j++){
      m[i][j] = -m[i][j];
    }
  }
}

//---------------------------------------------------------//

void jMatrix::tform(vect3f& point)
{
  float w;
  vect3f tmp(point);
  
  w = m[3][0] * tmp[0] + m[3][1] * tmp[1] + m[3][2] * tmp[2] + m[3][3];
  
  for (int i = 0; i < 3; i++)
    point[i] = (m[i][0] * tmp[0] + m[i][1] * tmp[1] + m[i][2] * tmp[2] + m[i][3]) / w;
  
}

//---------------------------------------------------------//

void jMatrix::tform(vect3f* point)
{
  float w;
  vect3f tmp(*point);
  
  w = m[3][0] * tmp[0] + m[3][1] * tmp[1] + m[3][2] * tmp[2] + m[3][3];
  
  for (int i = 0; i < 3; i++)
    point->v[i] = (m[i][0] * tmp[0] + m[i][1] * tmp[1] + m[i][2] * tmp[2] + m[i][3]) / w;
  
}

//---------------------------------------------------------//

jMatrix jMatrix::operator+(jMatrix& obj)
{
  jMatrix tmp(*this);
  tmp.add(obj);
  return (tmp);
}

//---------------------------------------------------------//

jMatrix jMatrix::operator-(jMatrix& obj)
{
  jMatrix tmp(*this);
  tmp.subtract(obj);
  return (tmp);
}

//---------------------------------------------------------//

jMatrix jMatrix::operator-()
{
  jMatrix tmp(*this);
  tmp.negative();
  return (tmp);
}

//---------------------------------------------------------//

jMatrix jMatrix::operator*(jMatrix& obj)
{
  jMatrix tmp(*this);
  tmp.mult(obj);
  return (tmp);
}

//---------------------------------------------------------//

void jMatrix::operator+=(jMatrix& obj)
{
  add(obj);
}

//---------------------------------------------------------//

void jMatrix::operator-=(jMatrix& obj)
{
  subtract(obj);
}

//---------------------------------------------------------//

void jMatrix::operator*=(jMatrix& obj)
{
  mult(obj);
}


//////////////////////////////////////////////////////////////
//*********************************************************///
//////////////////////////////////////////////////////////////

class jMatrixStack
{
 protected:
  vector<jMatrix> stk;
  vector<jMatrix>::iterator iter;
  jMatrix mult;
  
 public:
  
  // constructors
  jMatrixStack();
  
  // push/pop
  void push();
  void pop();
  
  // fairly direct handling
  jMatrix getTop() { return *iter; }
  void setTop(jMatrix obj) { *iter = obj; }
  
  // less direct handling
  void tform(vect3f& point);
  void tform(vect3f* point);
  
  void trans(float x, float y, float z);
  
  void rotxrad(float angle);
  void rotxdeg(float angle);
  
  void rotyrad(float angle);
  void rotydeg(float angle);
  
  void rotzrad(float angle);
  void rotzdeg(float angle);
  
  void rotallrad(float x, float y, float z);
  void rotalldeg(float x, float y, float z);
  
  void scale(float x, float y, float z);
  
} mstack;


jMatrixStack::jMatrixStack()
{
  jMatrix ident;
  ident.identity();
  
  stk.push_back(ident);
  iter = stk.begin();
}

//---------------------------------------------------------//

void jMatrixStack::push()
{
  mult = *iter;
  stk.push_back(mult);
  iter = stk.end() - 1;
}

//---------------------------------------------------------//

void jMatrixStack::pop()
{
  if (stk.size() > 1){
    stk.pop_back();
    iter = stk.end() - 1;
  }
  else
    (*iter).identity();
}

//---------------------------------------------------------//

void jMatrixStack::tform(vect3f& point)
{
  (*iter).tform(point);
}

//---------------------------------------------------------//

void jMatrixStack::tform(vect3f* point)
{
  (*iter).tform(point);
}

//---------------------------------------------------------//

void jMatrixStack::trans(float x, float y, float z)
{
  mult.identity();
  
  mult.m[0][3] = x;
  mult.m[1][3] = y;
  mult.m[2][3] = z;
  
  (*iter).mult(mult);
}

//---------------------------------------------------------//

void jMatrixStack::rotxrad(float angle)
{
  mult.identity();
  
  mult.m[1][1] = cos(angle);
  mult.m[2][2] = cos(angle);
  mult.m[1][2] = -sin(angle);
  mult.m[2][1] = sin(angle);
  
  (*iter).mult(mult);
}

//---------------------------------------------------------//

void jMatrixStack::rotxdeg(float angle)
{
  mult.identity();
  
  angle *= pi / 180;
  
  mult.m[1][1] = cos(angle);
  mult.m[2][2] = cos(angle);
  mult.m[1][2] = -sin(angle);
  mult.m[2][1] = sin(angle);
  
  (*iter).mult(mult);
}

//---------------------------------------------------------//

void jMatrixStack::rotyrad(float angle)
{
  mult.identity();
  
  mult.m[0][0] = cos(angle);
  mult.m[2][2] = cos(angle);
  mult.m[0][2] = sin(angle);
  mult.m[2][0] = -sin(angle);
  
  (*iter).mult(mult);
}

//---------------------------------------------------------//

void jMatrixStack::rotydeg(float angle)
{
  mult.identity();
  
  angle *= pi / 180;
  
  mult.m[0][0] = cos(angle);
  mult.m[2][2] = cos(angle);
  mult.m[0][2] = sin(angle);
  mult.m[2][0] = -sin(angle);
  
  (*iter).mult(mult);
}


//---------------------------------------------------------//

void jMatrixStack::rotzrad(float angle)
{
  mult.identity();
  
  mult.m[0][0] = cos(angle);
  mult.m[1][1] = cos(angle);
  mult.m[0][1] = -sin(angle);
  mult.m[1][0] = sin(angle);
  
  (*iter).mult(mult);
}

//---------------------------------------------------------//

void jMatrixStack::rotzdeg(float angle)
{
  mult.identity();
  
  angle *= pi / 180;
  
  mult.m[0][0] = cos(angle);
  mult.m[1][1] = cos(angle);
  mult.m[0][1] = -sin(angle);
  mult.m[1][0] = sin(angle);
  
  (*iter).mult(mult);
}

//---------------------------------------------------------//

void jMatrixStack::rotallrad(float x, float y, float z)
{
  if (x != 0)
    rotxrad(x);
  if (y != 0)
    rotyrad(y);
  if (z != 0)
    rotzrad(z);
}

//---------------------------------------------------------//

void jMatrixStack::rotalldeg(float x, float y, float z)
{
  if (x != 0)
    rotxdeg(x);
  if (y != 0)
    rotydeg(y);
  if (z != 0)
    rotzdeg(z);
}

//---------------------------------------------------------//

void jMatrixStack::scale(float x, float y, float z)
{
  mult.identity();
  
  mult.m[0][0] = x;
  mult.m[1][1] = y;
  mult.m[2][2] = z;
  
  (*iter).mult(mult);
}


//////////////////////////////////////////////////////////////
//*********************************************************///
//////////////////////////////////////////////////////////////

#endif // __jmatrix_h_

---