Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals

pge::Mesh Class Reference

#include <Mesh.h>

Inheritance diagram for pge::Mesh:

Inheritance graph
[legend]
Collaboration diagram for pge::Mesh:

Collaboration graph
[legend]

Public Types

enum  RenderMode { Immediate, DisplayList, VertexBufferObject }

Public Member Functions

 Mesh (void)
 Constructor.

virtual ~Mesh (void)
 Destructor.

bool init (void)
void render (void)
 Called when the object should render itself.

void timer (unsigned int delay)
 Called when the timer event comes.

std::vector< Triangle * > * getTriangles (void)
int getTriangleNum (void)
int getVertexNum (void)
AABBgetBoundingBox (void)
SpheregetBoundingSphere (void)
void setAlphaColor (float alpha)
bool addTriangle (Triangle triangle)
bool getHeightAt (float posX, float posZ, float *result)
bool isHeightQueryInside (float posX, float posZ)

Protected Attributes

std::vector< Triangle * > * m_triangles
float m_alphaColor
unsigned int m_displayList
RenderMode m_renderMode
AABBm_boundingBox
Spherem_boundingSphere
bool m_debugRender

Private Member Functions

void buildBoundingBox (void)
void buildBoundingSphere (void)
void buildDisplayList (void)
void renderImmediate (void)
void renderDisplayList (void)

Member Enumeration Documentation

enum pge::Mesh::RenderMode
 

Enumeration values:
Immediate 
DisplayList 
VertexBufferObject 

Definition at line 26 of file Mesh.h.

00026                                 {
00027                         Immediate, DisplayList, VertexBufferObject
00028                 };


Constructor & Destructor Documentation

pge::Mesh::Mesh void   ) 
 

Constructor.

Definition at line 19 of file Mesh.cpp.

References DisplayList, m_alphaColor, m_boundingBox, m_boundingSphere, m_debugRender, m_displayList, m_renderMode, and m_triangles.

00019                        {
00020                 m_triangles = new std::vector<Triangle*>();
00021                 m_alphaColor = 1.0f;
00022                 m_displayList = 0;
00023                 m_renderMode = DisplayList;
00024                 m_boundingBox = NULL;
00025                 m_boundingSphere = NULL;
00026                 m_debugRender = false;
00027         }

pge::Mesh::~Mesh void   )  [virtual]
 

Destructor.

Definition at line 35 of file Mesh.cpp.

References DisplayList, Immediate, m_boundingBox, m_boundingSphere, m_displayList, m_renderMode, and m_triangles.

00035                         {
00036                 std::vector<Triangle*>::iterator it;
00037 
00038 
00039                 if(m_boundingBox != NULL) {
00040                         delete m_boundingBox;
00041                         m_boundingBox = NULL;
00042                 }
00043                 if(m_boundingSphere != NULL) {
00044                         delete m_boundingSphere;
00045                         m_boundingSphere = NULL;
00046                 }
00047 
00048                 if(m_triangles != NULL) {
00049                         for(it = m_triangles->begin(); it != m_triangles->end(); it++) {
00050                                 delete *it;
00051                                 *it = NULL;
00052                         }
00053                         delete m_triangles;
00054                         m_triangles = NULL;
00055                 }
00056 
00057                 switch(m_renderMode) {
00058                         case Immediate:
00059                                 break;
00060                         case DisplayList:
00061                                 renderer::deleteDisplayList(m_displayList);
00062                                 break;
00063                 }
00064 
00065         }


Member Function Documentation

bool pge::Mesh::addTriangle Triangle  triangle  ) 
 

Definition at line 182 of file Mesh.cpp.

References pge::Triangle::m_plane, pge::Triangle::m_texCoords, m_triangles, and pge::Triangle::m_vertices.

Referenced by pge::SGFMeshModel::convertMeshes(), pge::meshfactory::createCuboid(), createGrass(), pge::DynamicCity::createGround(), pge::DynamicCity::createHouse(), and pge::Terrain::createTerrain().

00182                                                 {
00183                 // Check for vertices.
00184                 if(triangle.m_vertices == NULL) {
00185                         return false;
00186                 }
00187 
00188                 // Check for correct texture information.
00189                 if(triangle.m_texCoords == NULL) {
00190                         return false;
00191                 }
00192 
00193                 // Plane.
00194                 if (triangle.m_plane == NULL) {
00195                         triangle.m_plane = new Plane(&triangle);
00196                 }
00197 
00198                 // Add triangle.
00199                 m_triangles->push_back(new Triangle(triangle));
00200 
00201                 return true;
00202         }

void pge::Mesh::buildBoundingBox void   )  [private]
 

Definition at line 247 of file Mesh.cpp.

References m_boundingBox, pge::AABB::m_maxX, pge::AABB::m_maxY, pge::AABB::m_maxZ, pge::AABB::m_minX, pge::AABB::m_minY, pge::AABB::m_minZ, m_triangles, pge::Vector3f::m_v, and pge::Triangle::m_vertices.

Referenced by init().

00247                                         {
00248                 //
00249                 // Variables
00250                 //
00251                 float minX;
00252                 float minY;
00253                 float minZ;
00254                 float maxX;
00255                 float maxY;
00256                 float maxZ;
00257                 int i;
00258                 Vector3f temp;
00259                 std::vector<Triangle*>::iterator it;
00260 
00261 
00262                 // If there are no triangles listed, prevent nullpointer exception here.
00263                 if(m_triangles->size() < 1) {
00264                         m_boundingBox = new AABB(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
00265                         return;
00266                 }
00267 
00268                 // Set the start values to the first vertex of the first triangle in the list.
00269                 temp = m_triangles->at(0)->m_vertices[0];
00270                 minX = temp.m_v[0];
00271                 minY = temp.m_v[1];
00272                 minZ = temp.m_v[2];
00273                 maxX = temp.m_v[0];
00274                 maxY = temp.m_v[1];
00275                 maxZ = temp.m_v[2];
00276 
00277                 // Go through all triangles.
00278                 for(it = m_triangles->begin(); it != m_triangles->end(); it++) {
00279                         Triangle *triangle = *it;
00280 
00281                         for (i = 0; i < 3; i++) {
00282                                 Vector3f v = triangle->m_vertices[i];
00283                                 if (v.m_v[0] < minX) {
00284                                         minX = v.m_v[0];
00285                                 }
00286                                 if (v.m_v[1] < minY) {
00287                                         minY = v.m_v[1];
00288                                 }
00289                                 if (v.m_v[2] < minZ) {
00290                                         minZ = v.m_v[2];
00291                                 }
00292 
00293                                 if (v.m_v[0] > maxX) {
00294                                         maxX = v.m_v[0];
00295                                 }
00296                                 if (v.m_v[1] > maxY) {
00297                                         maxY = v.m_v[1];
00298                                 }
00299                                 if (v.m_v[2] > maxZ) {
00300                                         maxZ = v.m_v[2];
00301                                 }
00302                         }
00303                 }
00304                 if(m_boundingBox != NULL) {
00305                         m_boundingBox->m_minX = minX;
00306                         m_boundingBox->m_minY = minY;
00307                         m_boundingBox->m_minZ = minZ;
00308                         m_boundingBox->m_maxX = maxX;
00309                         m_boundingBox->m_maxY = maxY;
00310                         m_boundingBox->m_maxZ = maxZ;
00311                 } else {
00312                         m_boundingBox = new AABB(minX, minY, minZ, maxX, maxY, maxZ);
00313                 }
00314         }

void pge::Mesh::buildBoundingSphere void   )  [private]
 

Definition at line 322 of file Mesh.cpp.

References getVertexNum(), m_boundingSphere, m_triangles, pge::Vector3f::m_v, pge::Triangle::m_vertices, pge::Vector3f::magnitude(), and pge::Vector3f::subtract().

Referenced by init().

00322                                            {
00323                 //
00324                 // Variables
00325                 //
00326                 int i;
00327                 float totalMass;
00328                 Vector3f center;
00329                 float mag;
00330                 float max = 0.0f;
00331                 Vector3f vertex;
00332                 Vector3f temp;
00333                 std::vector<Triangle*>::iterator it;
00334 
00335 
00336                 // Calculate the center of the mesh.
00337                 center = Vector3f();
00338                 totalMass = (float)getVertexNum();
00339 
00340                 for(it = m_triangles->begin(); it != m_triangles->end(); it++) {
00341                         Triangle *triangle = *it;
00342 
00343                         for (i = 0; i < 3; i++) {
00344                                 center.m_v[0] = center.m_v[0] + triangle->m_vertices[i].m_v[0];
00345                                 center.m_v[1] = center.m_v[1] + triangle->m_vertices[i].m_v[1];
00346                                 center.m_v[2] = center.m_v[2] + triangle->m_vertices[i].m_v[2];
00347                         }
00348                 }
00349                 center.m_v[0] = center.m_v[0] / totalMass;
00350                 center.m_v[1] = center.m_v[1] / totalMass;
00351                 center.m_v[2] = center.m_v[2] / totalMass;
00352 
00353                 // Calculate sphere radius.
00354                 for(it = m_triangles->begin(); it != m_triangles->end(); it++) {
00355                         Triangle *triangle = *it;
00356 
00357 
00358                         for (i = 0; i < 3; i++) {
00359                                 vertex = triangle->m_vertices[i];
00360                                 temp = vertex.subtract(center);
00361                                 mag = temp.magnitude();
00362                                 if (mag > max) {
00363                                         max = mag;
00364                                 }
00365                         }
00366                 }
00367 
00368                 m_boundingSphere = new Sphere(center, max);
00369         }

Here is the call graph for this function:

void pge::Mesh::buildDisplayList void   )  [private]
 

Definition at line 377 of file Mesh.cpp.

References m_displayList, and renderImmediate().

Referenced by init().

00377                                         {
00378                 m_displayList = renderer::createDisplayList();
00379                 renderImmediate();
00380                 renderer::endDisplayList();
00381 
00382         }

Here is the call graph for this function:

AABB * pge::Mesh::getBoundingBox void   ) 
 

Definition at line 153 of file Mesh.cpp.

References m_boundingBox.

Referenced by pge::QuadtreeNode::render(), pge::OctreeNode::render(), pge::QuadtreeNode::subdivide(), and pge::OctreeNode::subdivide().

00153                                        {
00154                 return m_boundingBox;
00155         }

Sphere * pge::Mesh::getBoundingSphere void   ) 
 

Definition at line 163 of file Mesh.cpp.

References m_boundingSphere.

00163                                             {
00164                 return m_boundingSphere;
00165         }

bool pge::Mesh::getHeightAt float  posX,
float  posZ,
float *  result
 

Definition at line 210 of file Mesh.cpp.

References pge::Plane::getIntersectionPoint(), m_boundingBox, pge::AABB::m_maxY, pge::Triangle::m_plane, m_triangles, and pge::Vector3f::m_v.

Referenced by pge::MeshModel::getHeightAt().

00210                                                                     {
00211                 std::vector<Triangle*>::iterator it;
00212 
00213                 for(it = m_triangles->begin(); it != m_triangles->end(); it++) {
00214                         Triangle *triangle = *it;
00215 
00216                         Vector3f point = triangle->m_plane->getIntersectionPoint(Vector3f(posX, m_boundingBox->m_maxY + 1.0f,
00217                                 posZ), Vector3f(posX, m_boundingBox->m_maxY - 1.0f, posZ));
00218                         if(triangle::isPointInside(point, *triangle)) {
00219                                 *result = point.m_v[1];
00220                                 return true;
00221                         }
00222                 }
00223                 return false;
00224         }

Here is the call graph for this function:

int pge::Mesh::getTriangleNum void   ) 
 

Definition at line 133 of file Mesh.cpp.

References m_triangles.

Referenced by pge::MeshModel::getTriangleNum().

00133                                      {
00134                 return (int)m_triangles->size();
00135         }

std::vector< Triangle * > * pge::Mesh::getTriangles void   ) 
 

Definition at line 123 of file Mesh.cpp.

References m_triangles.

Referenced by pge::MeshModel::buildBoundingBox(), pge::MeshModel::scale(), and pge::MeshModel::setBottomCenter().

00123                                                      {
00124                 return m_triangles;
00125         }

int pge::Mesh::getVertexNum void   ) 
 

Definition at line 143 of file Mesh.cpp.

References m_triangles.

Referenced by buildBoundingSphere(), and pge::SingleTexturedMesh::buildVBO().

00143                                    {
00144                 return (int)m_triangles->size() * 3;
00145         }

bool pge::Mesh::init void   )  [virtual]
 

Implements pge::IRenderableObject.

Reimplemented in pge::SingleTexturedMesh.

Definition at line 73 of file Mesh.cpp.

References buildBoundingBox(), buildBoundingSphere(), buildDisplayList(), DisplayList, Immediate, and m_renderMode.

Referenced by pge::MeshModel::init().

00073                             {
00074                 // Create the bounding box.
00075                 buildBoundingBox();
00076 
00077                 // Create the bounding sphere.
00078                 buildBoundingSphere();
00079 
00080                 // Prepare rendering after creating all bounding geometry information.
00081                 switch(m_renderMode) {
00082                         case Immediate:
00083                                 break;
00084                         case DisplayList:
00085                                 buildDisplayList();
00086                                 break;
00087                 }
00088                 return true;
00089         }

Here is the call graph for this function:

bool pge::Mesh::isHeightQueryInside float  posX,
float  posZ
 

Definition at line 232 of file Mesh.cpp.

References m_boundingBox, pge::AABB::m_maxX, pge::AABB::m_maxZ, pge::AABB::m_minX, and pge::AABB::m_minZ.

Referenced by pge::MeshModel::getHeightAt().

00232                                                              {
00233                 // Check against bounding box.
00234                 if (posX >= m_boundingBox->m_minX && posX <= m_boundingBox->m_maxX && posZ >= m_boundingBox->m_minZ
00235                         && posZ <= m_boundingBox->m_maxZ) {
00236                                 return true;
00237                 }
00238                 return false;
00239         }

void pge::Mesh::render void   )  [virtual]
 

Called when the object should render itself.

Implements pge::IRenderableObject.

Reimplemented in pge::SingleTexturedMesh.

Definition at line 97 of file Mesh.cpp.

References DisplayList, Immediate, m_renderMode, renderDisplayList(), and renderImmediate().

Referenced by pge::QuadtreeNode::render(), pge::OctreeNode::render(), and pge::MeshModel::render().

00097                               {
00098                 switch(m_renderMode) {
00099                         case Immediate:
00100                                 renderImmediate();
00101                                 break;
00102                         case DisplayList:
00103                                 renderDisplayList();
00104                                 break;
00105                 }
00106         }

Here is the call graph for this function:

void pge::Mesh::renderDisplayList void   )  [private]
 

Definition at line 441 of file Mesh.cpp.

References m_displayList.

Referenced by render().

00441                                          {
00442                 renderer::executeDisplayList(m_displayList);
00443         }

void pge::Mesh::renderImmediate void   )  [private]
 

Reimplemented in pge::SingleTexturedMesh.

Definition at line 390 of file Mesh.cpp.

References pge::Texture::hasAlphaBlending(), m_alphaColor, pge::Plane::m_normal, pge::Triangle::m_plane, pge::Triangle::m_texCoords, pge::Triangle::m_texture, m_triangles, and pge::Triangle::m_vertices.

Referenced by buildDisplayList(), and render().

00390                                        {
00391                 std::vector<Triangle*>::iterator it;
00392 
00393 
00394                 for(it = m_triangles->begin(); it != m_triangles->end(); it++) {
00395                         Triangle *triangle = *it;
00396 
00397                         if(triangle->m_texture != NULL) {
00398                                 // Enable alpha blending if the texture is set to it.
00399                                 if(triangle->m_texture->hasAlphaBlending()) {
00400                                         renderer::setTextureAlphaBlendEnabled(true);
00401                                 } else if(m_alphaColor < 1.0f) {
00402                                         renderer::setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
00403                                         renderer::setBlendingEnabled(true);
00404                                 }
00405                                 renderer::setTexture(triangle->m_texture, GL_MODULATE);
00406                         } else {
00407                                 glDisable(GL_TEXTURE_2D);
00408                         }
00409 
00410                         renderer::color4f(1.0f, 1.0f, 1.0f, m_alphaColor);
00411 
00412                         glBegin(GL_TRIANGLES);
00413                         renderer::normal3f(triangle->m_plane->m_normal);
00414                         renderer::vertex3f(triangle->m_vertices[0], triangle->m_texCoords[0]);
00415                         renderer::normal3f(triangle->m_plane->m_normal);
00416                         renderer::vertex3f(triangle->m_vertices[1], triangle->m_texCoords[1]);
00417                         renderer::normal3f(triangle->m_plane->m_normal);
00418                         renderer::vertex3f(triangle->m_vertices[2], triangle->m_texCoords[2]);
00419                         glEnd();
00420 
00421                         if(triangle->m_texture != NULL) {
00422                                 // Disable alpha blending.
00423                                 if(triangle->m_texture->hasAlphaBlending()) {
00424                                         renderer::setTextureAlphaBlendEnabled(false);
00425                                 }
00426                         }
00427                         if(m_alphaColor < 1.0f) {
00428                                 renderer::setBlendingEnabled(false);
00429                                 // Reset alpha color.
00430                                 renderer::color4f(1.0f, 1.0f, 1.0f, 1.0f);
00431                         }
00432                 }
00433         }

Here is the call graph for this function:

void pge::Mesh::setAlphaColor float  alpha  ) 
 

Definition at line 173 of file Mesh.cpp.

00173                                             {
00174         }

void pge::Mesh::timer unsigned int  delay  )  [virtual]
 

Called when the timer event comes.

Implements pge::IRenderableObject.

Definition at line 114 of file Mesh.cpp.

Referenced by pge::MeshModel::timer().

00114                                            {
00115         }


Field Documentation

float pge::Mesh::m_alphaColor [protected]
 

Definition at line 98 of file Mesh.h.

Referenced by Mesh(), pge::SingleTexturedMesh::render(), renderImmediate(), and pge::SingleTexturedMesh::renderVBO().

AABB* pge::Mesh::m_boundingBox [protected]
 

Definition at line 107 of file Mesh.h.

Referenced by buildBoundingBox(), getBoundingBox(), getHeightAt(), isHeightQueryInside(), Mesh(), and ~Mesh().

Sphere* pge::Mesh::m_boundingSphere [protected]
 

Definition at line 110 of file Mesh.h.

Referenced by buildBoundingSphere(), getBoundingSphere(), Mesh(), pge::SingleTexturedMesh::render(), and ~Mesh().

bool pge::Mesh::m_debugRender [protected]
 

Definition at line 113 of file Mesh.h.

Referenced by Mesh().

unsigned int pge::Mesh::m_displayList [protected]
 

Definition at line 101 of file Mesh.h.

Referenced by buildDisplayList(), Mesh(), renderDisplayList(), and ~Mesh().

RenderMode pge::Mesh::m_renderMode [protected]
 

Definition at line 104 of file Mesh.h.

Referenced by init(), Mesh(), render(), pge::SingleTexturedMesh::SingleTexturedMesh(), and ~Mesh().

std::vector<Triangle*>* pge::Mesh::m_triangles [protected]
 

Definition at line 96 of file Mesh.h.

Referenced by addTriangle(), buildBoundingBox(), buildBoundingSphere(), pge::SingleTexturedMesh::buildVBO(), getHeightAt(), getTriangleNum(), getTriangles(), getVertexNum(), Mesh(), renderImmediate(), and ~Mesh().


The documentation for this class was generated from the following files:
Generated on Mon Oct 16 12:09:17 2006 for Phobosengine by doxygen 1.3.4