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

/Users/blackie/Documents/myRepository/phobosengine-vc2005/phobosengine/phobosengine/MeshModel.cpp

Go to the documentation of this file.
00001 
00002 
00003 #include "MeshModel.h"
00004 
00005 #include "AABB.h"
00006 #include "Mesh.h"
00007 
00008 
00009 namespace pge {
00010 
00011         //****************************************************************************
00012         //
00013         //
00014         //
00015         //****************************************************************************
00016         MeshModel::MeshModel(void) {
00017                 m_boundingBox = NULL;
00018                 m_meshs = new std::vector<Mesh*>();
00019         }
00020 
00021 
00022         //****************************************************************************
00023         //
00024         //
00025         //
00026         //****************************************************************************
00027         MeshModel::~MeshModel(void) {
00028                 std::vector<Mesh*>::iterator it;
00029 
00030                 if(m_meshs != NULL) {
00031                         for(it = m_meshs->begin(); it != m_meshs->end(); it++) {
00032                                 if(*it != NULL) {
00033                                         delete *it;
00034                                 }
00035                         }
00036                         delete m_meshs;
00037                         m_meshs = NULL;
00038                 }
00039 
00040                 if(m_boundingBox != NULL) {
00041                         delete m_boundingBox;
00042                         m_boundingBox = NULL;
00043                 }
00044         }
00045 
00046 
00047         //****************************************************************************
00048         //
00049         //
00050         //
00051         //****************************************************************************
00052         bool MeshModel::init(void) {
00053                 std::vector<Mesh*>::iterator it;
00054 
00055                 buildBoundingBox();
00056 
00057                 for(it = m_meshs->begin(); it != m_meshs->end(); it++) {
00058                         Mesh *mesh = *it;
00059                         mesh->init();
00060                 }
00061 
00062                 return true;
00063         }
00064 
00065 
00066         //****************************************************************************
00067         //
00068         //
00069         //
00070         //****************************************************************************
00071         void MeshModel::render(void) {
00072                 std::vector<Mesh*>::iterator it;
00073 
00074 
00075                 for(it = m_meshs->begin(); it != m_meshs->end(); it++) {
00076                         Mesh *mesh = *it;
00077                         mesh->render();
00078                 }
00079         }
00080 
00081 
00082         //****************************************************************************
00083         //
00084         //
00085         //
00086         //****************************************************************************
00087         void MeshModel::timer(unsigned int delay) {
00088                 std::vector<Mesh*>::iterator it;
00089 
00090 
00091                 for(it = m_meshs->begin(); it != m_meshs->end(); it++) {
00092                         Mesh *mesh = *it;
00093                         mesh->timer(delay);
00094                 }
00095         }
00096 
00097 
00098         //****************************************************************************
00099         //
00100         //
00101         //
00102         //****************************************************************************
00103         std::vector<Mesh*>* MeshModel::getMeshs(void) {
00104                 return m_meshs;
00105         }
00106 
00107 
00108         //****************************************************************************
00109         //
00110         //
00111         //
00112         //****************************************************************************
00113         int MeshModel::getTriangleNum(void) {
00114                 std::vector<Mesh*>::iterator it;
00115                 int num = 0;
00116 
00117 
00118                 for(it = m_meshs->begin(); it != m_meshs->end(); it++) {
00119                         Mesh *mesh = *it;
00120                         num += mesh->getTriangleNum();
00121                 }
00122                 return num;
00123         }
00124 
00125 
00126         //****************************************************************************
00127         //
00128         //
00129         //
00130         //****************************************************************************
00131         int MeshModel::getMeshNum(void) {
00132                 return (int)m_meshs->size();
00133         }
00134 
00135 
00136         //****************************************************************************
00137         //
00138         //
00139         //
00140         //****************************************************************************
00141         AABB* MeshModel::getBoundingBox(void) {
00142                 return m_boundingBox;
00143         }
00144 
00145 
00146         //****************************************************************************
00147         //
00148         //
00149         //
00150         //****************************************************************************
00151         void MeshModel::addMesh(Mesh *mesh) {
00152                 m_meshs->push_back(mesh);
00153         }
00154 
00155         
00156         //****************************************************************************
00157         //
00158         //
00159         //
00160         //****************************************************************************
00161         void MeshModel::addMeshModel(MeshModel *model) {
00162                 std::vector<Mesh*>::iterator it;
00163 
00164 
00165                 for(it = model->getMeshs()->begin(); it != model->getMeshs()->end(); it++) {
00166                         m_meshs->push_back(*it);
00167                 }
00168         }
00169 
00170 
00171         //****************************************************************************
00172         //
00173         //
00174         //
00175         //****************************************************************************
00176         void MeshModel::clearMeshs(void) {
00177                 m_meshs->clear();
00178         }
00179 
00180 
00181         //****************************************************************************
00182         //
00183         //
00184         //
00185         //****************************************************************************
00186         float MeshModel::getHeightAt(float posX, float posZ) {
00187                 float height = 0.0f;
00188                 std::vector<Mesh*>::iterator it;
00189 
00190 
00191                 for(it = m_meshs->begin(); it != m_meshs->end(); it++) {
00192                         Mesh *mesh = *it;
00193 
00194                         if(mesh->isHeightQueryInside(posX, posZ)) {
00195 
00196                                 if(mesh->getHeightAt(posX, posZ, &height)) {
00197                                         return height;
00198                                 }
00199                         }
00200                 }
00201                 return 0.0f;
00202         }
00203 
00204 
00205         //****************************************************************************
00206         //
00207         //
00208         //
00209         //****************************************************************************
00210         void MeshModel::buildBoundingBox(void) {
00211                 //
00212                 // Variables
00213                 //
00214                 float minX;
00215                 float minY;
00216                 float minZ;
00217                 float maxX;
00218                 float maxY;
00219                 float maxZ;
00220                 int i;
00221                 Vector3f temp;
00222                 std::vector<Mesh*>::iterator meshIt;
00223                 std::vector<Triangle*>::iterator triangleIt;
00224 
00225 
00226                 // Set the start values to the first vertex in the first mesh, if it exists.
00227                 if(m_meshs->size() < 1) {
00228                         // TODO: Error?
00229                         return;
00230                 } else {
00231                         if(m_meshs->at(0)->getTriangles()->size() < 1) {
00232                                 return;
00233                         }
00234                 }
00235 
00236                 temp = m_meshs->at(0)->getTriangles()->at(0)->m_vertices[0];
00237                 minX = temp.m_v[0];
00238                 minY = temp.m_v[1];
00239                 minZ = temp.m_v[2];
00240                 maxX = temp.m_v[0];
00241                 maxY = temp.m_v[1];
00242                 maxZ = temp.m_v[2];
00243 
00244                 for(meshIt = m_meshs->begin(); meshIt != m_meshs->end(); meshIt++) {
00245                         Mesh *mesh = *meshIt;
00246 
00247                         for(triangleIt = mesh->getTriangles()->begin(); triangleIt != mesh->getTriangles()->end(); triangleIt++) {
00248                                 Triangle *t = *triangleIt;
00249 
00250                                 for(i = 0; i < 3; i++) {
00251                                         Vector3f v = t->m_vertices[i];
00252 
00253                                         // Min values.
00254                                         if (v.m_v[0] < minX) {
00255                                                 minX = v.m_v[0];
00256                                         }
00257                                         if (v.m_v[1] < minY) {
00258                                                 minY = v.m_v[1];
00259                                         }
00260                                         if (v.m_v[2] < minZ) {
00261                                                 minZ = v.m_v[2];
00262                                         }
00263 
00264                                         // Max values.
00265                                         if (v.m_v[0] > maxX) {
00266                                                 maxX = v.m_v[0];
00267                                         }
00268                                         if (v.m_v[1] > maxY) {
00269                                                 maxY = v.m_v[1];
00270                                         }
00271                                         if (v.m_v[2] > maxZ) {
00272                                                 maxZ = v.m_v[2];
00273                                         }
00274                                 }
00275                         }
00276                 }
00277 
00278                 if(m_boundingBox != NULL) {
00279                         m_boundingBox->m_minX = minX;
00280                         m_boundingBox->m_minY = minY;
00281                         m_boundingBox->m_minZ = minZ;
00282                         m_boundingBox->m_maxX = maxX;
00283                         m_boundingBox->m_maxY = maxY;
00284                         m_boundingBox->m_maxZ = maxZ;
00285                 } else {
00286                         m_boundingBox = new AABB(minX, minY, minZ, maxX, maxY, maxZ);
00287                 }
00288         }
00289 
00290 
00291         //****************************************************************************
00292         //
00293         //
00294         //
00295         //****************************************************************************
00296         void MeshModel::scale(float s) {
00297                 std::vector<Mesh*>::iterator meshIt;
00298                 std::vector<Triangle*>::iterator triangleIt;
00299 
00300 
00301                 for(meshIt = m_meshs->begin(); meshIt != m_meshs->end(); meshIt++) {
00302                         Mesh *mesh = *meshIt;
00303 
00304                         for(triangleIt = mesh->getTriangles()->begin(); triangleIt != mesh->getTriangles()->end(); triangleIt++) {
00305                                 Triangle *t = *triangleIt;
00306 
00307                                 t->m_vertices[0] = t->m_vertices[0].multiply(s);
00308                                 t->m_vertices[1] = t->m_vertices[1].multiply(s);
00309                                 t->m_vertices[2] = t->m_vertices[2].multiply(s);
00310                         }
00311                 }
00312         }
00313 
00314 
00315         //****************************************************************************
00316         //
00317         //
00318         //
00319         //****************************************************************************
00320         void MeshModel::setBottomCenter(Vector3f bottomCenter) {
00321                 Vector3f difference;
00322                 Vector3f center;
00323                 std::vector<Mesh*>::iterator meshIt;
00324                 std::vector<Triangle*>::iterator triangleIt;
00325 
00326 
00327                 center = m_boundingBox->getBottomCenter();
00328                 difference = bottomCenter.subtract(center);
00329                 m_bottomCenterDifference = difference;
00330 
00331                 for(meshIt = m_meshs->begin(); meshIt != m_meshs->end(); meshIt++) {
00332                         Mesh *mesh = *meshIt;
00333 
00334                         for(triangleIt = mesh->getTriangles()->begin(); triangleIt != mesh->getTriangles()->end(); triangleIt++) {
00335                                 Triangle *t = *triangleIt;
00336 
00337                                 t->m_vertices[0] = t->m_vertices[0].add(difference);
00338                                 t->m_vertices[1] = t->m_vertices[1].add(difference);
00339                                 t->m_vertices[2] = t->m_vertices[2].add(difference);
00340                         }
00341                 }
00342 
00343                 m_boundingBox->m_minX += difference.m_v[0];
00344                 m_boundingBox->m_minY += difference.m_v[1];
00345                 m_boundingBox->m_minZ += difference.m_v[2];
00346                 m_boundingBox->m_maxX += difference.m_v[0];
00347                 m_boundingBox->m_maxY += difference.m_v[1];
00348                 m_boundingBox->m_maxZ += difference.m_v[2];
00349         }
00350 
00351 
00352         //****************************************************************************
00353         //
00354         //
00355         //
00356         //****************************************************************************
00357         Vector3f MeshModel::getBottomCenterDifference(void) {
00358                 return m_bottomCenterDifference;
00359         }
00360 };

Generated on Mon Oct 16 12:08:10 2006 for Phobosengine by doxygen 1.3.4