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

pge::SingleTexturedMesh Class Reference

#include <SingleTexturedMesh.h>

Inheritance diagram for pge::SingleTexturedMesh:

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

Collaboration graph
[legend]

Public Member Functions

 SingleTexturedMesh (bool disableLightShader=false)
 Constructor.

virtual ~SingleTexturedMesh (void)
 Destructor.

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

void setTexture (Texture *texture)

Private Member Functions

void buildVBO (void)
void renderVBO (void)
void renderImmediate (void)
void getSurroundingLights (void)

Private Attributes

Texturem_texture
VBOm_vbo
int m_vertexNum
bool m_disableLightShader
LightShaderm_lightShader

Constructor & Destructor Documentation

pge::SingleTexturedMesh::SingleTexturedMesh bool  disableLightShader = false  ) 
 

Constructor.

Definition at line 24 of file SingleTexturedMesh.cpp.

References m_disableLightShader, m_lightShader, pge::Mesh::m_renderMode, m_texture, m_vbo, and m_vertexNum.

00024                                                                       : Mesh() {
00025                 m_texture = TextureDatabase::getInstance()->getDefaultTexture();
00026                 m_renderMode = Mesh::VertexBufferObject;
00027                 m_vbo = NULL;
00028                 m_vertexNum = 0;
00029                 m_disableLightShader = disableLightShader;
00030 
00031                 if(!m_disableLightShader) {
00032                         m_lightShader = new LightShader(CoreEngine::getInstance()->getCurrentWorld()->getLightProgram());
00033                 } else {
00034                         m_lightShader = NULL;
00035                 }
00036 
00037         }

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

Destructor.

Definition at line 45 of file SingleTexturedMesh.cpp.

References m_lightShader, and m_vbo.

00045                                                     {
00046                 if(m_vbo != NULL) {
00047                         delete m_vbo;
00048                         m_vbo = NULL;
00049                 }
00050                 if(m_lightShader != NULL) {
00051                         delete m_lightShader;
00052                         m_lightShader = NULL;
00053                 }
00054         }


Member Function Documentation

void pge::SingleTexturedMesh::buildVBO void   )  [private]
 

Definition at line 128 of file SingleTexturedMesh.cpp.

References pge::VBO::addTriangle(), pge::VBO::buildVBO(), pge::Mesh::getVertexNum(), pge::Mesh::m_triangles, m_vbo, and m_vertexNum.

Referenced by init().

00128                                               {
00129                 std::vector<Triangle*>::iterator it;
00130 
00131 
00132                 m_vertexNum = getVertexNum();
00133                 m_vbo = new VBO(m_vertexNum);
00134 
00135                 // Go through all triangles.
00136                 for(it = m_triangles->begin(); it != m_triangles->end(); it++) {
00137                         Triangle *triangle = *it;
00138 
00139                         m_vbo->addTriangle(triangle);
00140                 }
00141 
00142                 m_vbo->buildVBO();
00143         }

Here is the call graph for this function:

void pge::SingleTexturedMesh::getSurroundingLights void   )  [private]
 

Definition at line 209 of file SingleTexturedMesh.cpp.

References pge::LightShader::addActiveLight(), pge::World::getLightAt(), and m_lightShader.

Referenced by init().

00209                                                           {
00210                 int i;
00211                 World *world;
00212                 Light *light;
00213                 float distance;
00214                 float minDistance;
00215                 float tmpDistance;
00216                 Light *minLight1;
00217                 Light *minLight2;
00218                 Light *minLight3;
00219 
00220 
00221                 world = CoreEngine::getInstance()->getCurrentWorld();
00222 
00223                 // TODO: infinity for this map!
00224                 minDistance = 10000000.0f;
00225 
00226                 /*// Find the minimal distance light.
00227                 for(i = 0; i < world->getLightNum(); i++) {
00228                         light = world->getLightAt(i);
00229                         distance = Vector3f(light->m_position).distance(m_boundingBox->getCenter());
00230                         if(distance < minDistance) {
00231                                 minLight1 = light;
00232                                 minDistance = distance;
00233                         }
00234                 }
00235 
00236                 // TODO: infinity for this map!
00237                 tmpDistance = 10000000.0f;
00238 
00239                 // Find the second smallest distance light.
00240                 for(i = 0; i < world->getLightNum(); i++) {
00241                         light = world->getLightAt(i);
00242                         distance = Vector3f(light->m_position).distance(m_boundingBox->getCenter());
00243 
00244                         if(distance >= minDistance && distance < tmpDistance && light != minLight1) {
00245                                 minLight2 = light;
00246                                 tmpDistance = distance;
00247                         }
00248                 }
00249 
00250                 minDistance = tmpDistance;
00251 
00252                 // Find the third smallest distance light.
00253                 for(i = 0; i < world->getLightNum(); i++) {
00254                         light = world->getLightAt(i);
00255                         distance = Vector3f(light->m_position).distance(m_boundingBox->getCenter());
00256 
00257                         if(distance >= minDistance && distance < tmpDistance && light != minLight1 && light != minLight2) {
00258                                 minLight3 = light;
00259                                 tmpDistance = distance;
00260                         }
00261                 }*/
00262 
00263 
00264                 minLight1 = world->getLightAt(0);
00265                 minLight2 = world->getLightAt(1);
00266                 minLight3 = world->getLightAt(2);
00267 
00268                 m_lightShader->addActiveLight(minLight1);
00269                 m_lightShader->addActiveLight(minLight2);
00270                 m_lightShader->addActiveLight(minLight3);
00271         }

Here is the call graph for this function:

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

Reimplemented from pge::Mesh.

Definition at line 62 of file SingleTexturedMesh.cpp.

References buildVBO(), getSurroundingLights(), m_disableLightShader, and m_lightShader.

00062                                           {
00063                 Mesh::init();
00064                 buildVBO();
00065 
00066                 if(!m_disableLightShader && m_lightShader != NULL) {
00067                         getSurroundingLights();
00068                 }
00069 
00070                 return true;
00071         }

Here is the call graph for this function:

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

Called when the object should render itself.

Reimplemented from pge::Mesh.

Definition at line 79 of file SingleTexturedMesh.cpp.

References pge::Vector3f::distance(), pge::Camera::getBoundingSphere(), pge::Camera::getPosition(), pge::Sphere::isIntersecting(), pge::Mesh::m_alphaColor, pge::Mesh::m_boundingSphere, pge::Sphere::m_center, renderVBO(), and pge::Vector3f::sqrDistance().

00079                                             {
00080                 // Calculate alpha value based on distance to the camera.
00081                 Camera *camera = CoreEngine::getInstance()->getCurrentWorld()->getCamera();
00082                 float sqrDist = 0.0f;
00083                 float dist = 0.0f;
00084                 float maxDistance = 200.0f;
00085                 float minDistance = 180.0f;
00086 
00087                 // If the camera is inside of the mesh's sphere, then render without alpha.
00088                 if(m_boundingSphere->isIntersecting(*camera->getBoundingSphere())) {
00089                         m_alphaColor = 1.0f;
00090                 } else {
00091                         // Calculate distance to camera.
00092                         sqrDist = camera->getPosition().sqrDistance(m_boundingSphere->m_center);
00093                         if(sqrDist >= minDistance * minDistance) {
00094                                 if(sqrDist <= maxDistance * maxDistance) {
00095                                         // Calculate blend factor.
00096                                         dist = camera->getPosition().distance(m_boundingSphere->m_center) - minDistance;
00097                                         m_alphaColor = 1.0f - (dist / (maxDistance - minDistance));
00098                                 } else {
00099                                         m_alphaColor = 0.0f;
00100                                 }
00101                         } else {
00102                                 m_alphaColor = 1.0f;
00103                         }
00104                 }
00105                 if(m_alphaColor > 0.0f) {
00106                         renderVBO();
00107                 }
00108         }

Here is the call graph for this function:

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

Reimplemented from pge::Mesh.

Definition at line 200 of file SingleTexturedMesh.cpp.

00200                                                      {
00201         }

void pge::SingleTexturedMesh::renderVBO void   )  [private]
 

Definition at line 151 of file SingleTexturedMesh.cpp.

References pge::Texture::hasAlphaBlending(), pge::Mesh::m_alphaColor, m_disableLightShader, m_lightShader, m_texture, m_vbo, m_vertexNum, pge::LightShader::postRender(), pge::LightShader::preRender(), and pge::VBO::renderVBO().

Referenced by render().

00151                                                {
00152                 if(m_texture != NULL) {
00153                         // Enable alpha blending if the texture is set to it.
00154                         if(m_texture->hasAlphaBlending()) {
00155                                 renderer::setTextureAlphaBlendEnabled(true);
00156 
00157                         } else if(m_alphaColor < 1.0f) {
00158                                 renderer::setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
00159                                 renderer::setBlendingEnabled(true);
00160                         }
00161                         renderer::setTexture(m_texture, GL_MODULATE);
00162                         renderer::color4f(1.0f, 1.0f, 1.0f, m_alphaColor);
00163 
00164                 } else {
00165                         glDisable(GL_TEXTURE_2D);
00166                 }
00167 
00168                 // Light shader.
00169                 if(!m_disableLightShader && m_lightShader != NULL) {
00170                         m_lightShader->preRender();
00171                 }
00172 
00173                 // Render.
00174                 m_vbo->renderVBO(0, m_vertexNum);
00175 
00176                 // Light shader.
00177                 if(!m_disableLightShader && m_lightShader != NULL) {
00178                         m_lightShader->postRender();
00179                 }
00180 
00181                 if(m_texture != NULL) {
00182                         // Disable alpha blending.
00183                         if(m_texture->hasAlphaBlending()) {
00184                                 renderer::setTextureAlphaBlendEnabled(false);
00185                         }
00186                 }
00187                 if(m_alphaColor < 1.0f) {
00188                         renderer::setBlendingEnabled(false);
00189                         // Reset alpha color.
00190                         renderer::color4f(1.0f, 1.0f, 1.0f, 1.0f);
00191                 }
00192         }

Here is the call graph for this function:

void pge::SingleTexturedMesh::setTexture Texture texture  ) 
 

Definition at line 116 of file SingleTexturedMesh.cpp.

References m_texture.

Referenced by createGrass(), pge::DynamicCity::createGround(), pge::DynamicCity::createHouse(), and pge::Terrain::createTerrain().

00116                                                             {
00117                 if(texture != NULL) {
00118                         m_texture = texture;
00119                 }
00120         }


Field Documentation

bool pge::SingleTexturedMesh::m_disableLightShader [private]
 

Definition at line 72 of file SingleTexturedMesh.h.

Referenced by init(), renderVBO(), and SingleTexturedMesh().

LightShader* pge::SingleTexturedMesh::m_lightShader [private]
 

Definition at line 73 of file SingleTexturedMesh.h.

Referenced by getSurroundingLights(), init(), renderVBO(), SingleTexturedMesh(), and ~SingleTexturedMesh().

Texture* pge::SingleTexturedMesh::m_texture [private]
 

Definition at line 68 of file SingleTexturedMesh.h.

Referenced by renderVBO(), setTexture(), and SingleTexturedMesh().

VBO* pge::SingleTexturedMesh::m_vbo [private]
 

Definition at line 69 of file SingleTexturedMesh.h.

Referenced by buildVBO(), renderVBO(), SingleTexturedMesh(), and ~SingleTexturedMesh().

int pge::SingleTexturedMesh::m_vertexNum [private]
 

Definition at line 70 of file SingleTexturedMesh.h.

Referenced by buildVBO(), renderVBO(), and SingleTexturedMesh().


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