Search  

---

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

Go to the documentation of this file.

/*
This class is intended to be a triangle which is used in opengl. Although 
it may be possible to use it for some other purpose, there may be some 
functions that don't work correctly, or at all.

I am not sure how to go about the problem that different programs use 
different vertexes. The best solution I see at the moment is to allow
the creation of vertex classes that fit the following parameters.

required:
   below members are accessable to the triangle class

   copy constructor

   pos of type vect3f

   function draw() which makes necessary commands to draw
   itself in opengl.

   function tform() which makes necessary commands to
   transform itself with <jmatrix.h>.

optional:
   normal of type vect3f, to draw normals

To use a specific type of vertex, you must use a typedef command
like this. I am not sure if it is possible to have multiple vertex
types in one program. If you can, make sure you dont mix triangle types:

   typedef nameOfVertexClass myVertexType;
*/

#ifndef __triangle_h_
#define __triangle_h_

#include <list>
#include <joe/vect3f.h>
#include <joe/old/jmatrix.h>

using namespace std;

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

class simpleVertex
{
public:
   vect3f pos;
   
   simpleVertex(const simpleVertex& obj)
   {
      pos = obj.pos;
   }

   void draw() 
   {
      glVertex3fv(pos.v);
   }

   void tform()
   {
      mstack.tform(pos);
   }
};

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

class normalVertex
{
public:
   vect3f pos;
   vect3f normal;
   vect3f color;
   
   normalVertex() 
   {
      color(1,1,1);
   }

   normalVertex(const normalVertex& obj)
   {
      color = obj.color;
      normal = obj.normal;
      pos = obj.pos;
   }



   void draw() 
   {
      glColor3fv(color.v);
      glNormal3fv(normal.v);
      glVertex3fv(pos.v);
   }

   void tform()
   {
      normal += pos;
      mstack.tform(normal);
      mstack.tform(pos);
      normal -= pos;
   }
};

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

typedef normalVertex myVertexType;

class triangle
{
public:
   // constructors
   triangle() {}
   triangle(const triangle& obj)
   {
      for (int i = 0; i < 3; i++){
         vert[i] = obj.vert[i];
         center = obj.center;
         normal = obj.normal;
      }
   }
   ~triangle() {}

   // variables
   vect3f normal;
   vect3f center;

   myVertexType vert[3];

   // functions
   void draw();
   void drawmesh();
   void drawnormals();

   void tform();
   void normalize();
   void syncnormals();

   float angle(vect3f&);
   float distance(vect3f&);
};

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

void triangle::draw()
{
   myVertexType tempvert[3];

   glBegin(GL_TRIANGLES);
      for (int i = 0; i < 3; i++){
            tempvert[i] = vert[i];
            tempvert[i].tform();
            tempvert[i].draw();
      }
   glEnd();
}

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

void triangle::drawmesh()
{
   myVertexType tempvert[3];

   glBegin(GL_LINE_LOOP);
      for (int i = 0; i < 3; i++){
            tempvert[i] = vert[i];
            tempvert[i].tform();
            tempvert[i].draw();
      }
   glEnd();
}

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

void triangle::drawnormals()
{
   myVertexType tempvert[3];

   glBegin(GL_LINES);

      for (int i = 0; i < 3; i++){
            tempvert[i] = vert[i];
            tempvert[i].tform();
            tempvert[i].draw();
            tempvert[i].pos += tempvert[i].normal;
            tempvert[i].draw();
      }

      tempvert[0].pos = center;
      tempvert[0].normal = normal;
      tempvert[0].normal += tempvert[0].pos;
      mstack.tform(tempvert[0].pos);
      tempvert[0].draw();
      mstack.tform(tempvert[0].normal);
      tempvert[0].pos = tempvert[0].normal;
      tempvert[0].draw();
   glEnd();
}

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

void triangle::tform()
{
   for (int i = 0; i < 3; i++)
      vert[i].tform();

   normal += center;
   mstack.tform(center);
   mstack.tform(normal);
   normal -= center;
}

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

void triangle::normalize()
{
   vect3f edge1, edge2;
   edge1 = vert[1].pos - vert[0].pos;
   edge2 = vert[2].pos - vert[1].pos;
   normal = edge1 % edge2;
   normal.unit();
   center = (vert[0].pos + vert[1].pos + vert[2].pos) / 3;
}

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

void triangle::syncnormals()
{
   for (int i = 0; i < 3; i++)
      vert[i].normal = normal;
}

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

float triangle::angle(vect3f& point)
{
   vect3f vtop = point - center;
   return acos((normal * vtop) / (!normal * !vtop));
}

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

float triangle::distance(vect3f& point)
{
   vect3f vtop = point - center;
   return normal.comp(vtop);

}

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

class model
{
public:
   // variables
   vector<triangle> triList;
   vector<triangle>::iterator iter;

   unsigned int texture;

   // functions
   void put(triangle);
   triangle get();

   void begin();
   void next();
   void prev();
   int size();

   void draw();
   void drawmesh();
   void drawnormals();
   void tform();
};

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

void model::put(triangle obj)
{
   if (triList.empty()){
      triList.push_back(obj);
      iter = triList.begin();
   }
   else
      triList.push_back(obj);
}

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

triangle model::get()
{
   return *iter;
}

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

void model::begin()
{
   iter = triList.begin();
}

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

void model::next()
{
   if (iter < triList.end() - 1)
      iter++;
}

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

void model::prev()
{
   if (iter > triList.begin())
      iter--;
}

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

int model::size()
{
   return triList.size();
}

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

void model::draw()
{
   for (vector<triangle>::iterator i = triList.begin(); i < triList.end(); i++)
      (*i).draw();
}

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

void model::drawmesh()
{
   for (vector<triangle>::iterator i = triList.begin(); i < triList.end(); i++)
      (*i).drawmesh();
}

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

void model::drawnormals()
{
   for (vector<triangle>::iterator i = triList.begin(); i < triList.end(); i++)
      (*i).drawnormals();
}

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

void model::tform()
{
   for (vector<triangle>::iterator i = triList.begin(); i < triList.end(); i++)
      (*i).tform();
}

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

#endif // __triangle_h_

---