Rampoina
/
MegaGlest
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

- a little bit of plumbing for VBO's for static models (currently disabled via # define) 

- small small speed improvement when calculating interpolations
This commit is contained in:
Mark Vejvoda 2011-01-18 07:52:06 +00:00
parent 55d213435a
commit c54e6dbf5d
14 changed files with 214 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
source/glest_game/graphics/renderer.cpp
View File

@ -736,7 +736,7 @@ void Renderer::renderMouse3d() {
modelRenderer->begin(true, true, false);
glColor4fv(color.ptr());
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color.ptr());
const Model *buildingModel= building->getFirstStOfClass(scStop)->getAnimation();
Model *buildingModel= building->getFirstStOfClass(scStop)->getAnimation();
if(gui->getSelectedFacing() != CardinalDir::NORTH) {
float rotateAmount = gui->getSelectedFacing() * 90.f;
@ -1815,7 +1815,7 @@ void Renderer::renderObjects(const int renderFps) {
visibleIndex < qCache.visibleObjectList.size(); ++visibleIndex) {
Object *o = qCache.visibleObjectList[visibleIndex];
const Model *objModel= o->getModel();
Model *objModel= o->getModelPtr();
const Vec3f &v= o->getConstPos();
if(modelRenderStarted == false) {
@ -2078,7 +2078,7 @@ void Renderer::renderUnits(const int renderFps) {
}
//render
const Model *model= unit->getCurrentModel();
Model *model= unit->getCurrentModelPtr();
model->updateInterpolationData(unit->getAnimProgress(), unit->isAlive());
modelRenderer->render(model);
@ -2617,7 +2617,7 @@ void Renderer::renderMenuBackground(const MenuBackground *menuBackground){
glPushMatrix();
glLoadIdentity();
glTranslatef(i*2.f-4.f, -1.4f, -7.5f);
menuBackground->getCharacterModel(i)->updateInterpolationData(menuBackground->getAnim(), true);
menuBackground->getCharacterModelPtr(i)->updateInterpolationData(menuBackground->getAnim(), true);
modelRenderer->render(menuBackground->getCharacterModel(i));
glPopMatrix();
}
@ -3287,7 +3287,7 @@ void Renderer::renderUnitsFast(bool renderingShadows) {
glRotatef(unit->getRotation(), 0.f, 1.f, 0.f);
//render
const Model *model= unit->getCurrentModel();
Model *model= unit->getCurrentModelPtr();
model->updateInterpolationVertices(unit->getAnimProgress(), unit->isAlive());
modelRenderer->render(model);

1
source/glest_game/menu/menu_background.h
View File

@ -85,6 +85,7 @@ public:
Texture2D *getWaterTexture() const {return waterTexture;}
const Camera *getCamera() const {return &camera;}
const Model *getCharacterModel(int i) const {return characterModels[i];}
Model *getCharacterModelPtr(int i) const {return characterModels[i];}
const Model *getMainModel() const {return mainModel;}
float getFade() const {return fade;}
Vec2f getRaindropPos(int i) const {return raindropPos[i];}

4
source/glest_game/type_instances/object.cpp
View File

@ -53,6 +53,10 @@ Object::~Object(){
renderer.removeObjectFromQuadCache(this);
}
Model *Object::getModelPtr() const {
return objectType==NULL ? (resource != NULL && resource->getType() != NULL ? resource->getType()->getModel() : NULL ) : objectType->getModel(variation);
}
const Model *Object::getModel() const{
return objectType==NULL ? (resource != NULL && resource->getType() != NULL ? resource->getType()->getModel() : NULL ) : objectType->getModel(variation);
}

1
source/glest_game/type_instances/object.h
View File

@ -53,6 +53,7 @@ public:
const Vec3f & getConstPos() const {return pos;}
float getRotation() {return rotation;}
const Model *getModel() const;
Model *getModelPtr() const;
bool getWalkable() const;
void setResource(const ResourceType *resourceType, const Vec2i &pos);

10
source/glest_game/type_instances/unit.cpp
View File

@ -636,6 +636,16 @@ void Unit::setVisible(const bool visible) {
// =============================== Render related ==================================
Model *Unit::getCurrentModelPtr() const {
if(currSkill == NULL) {
char szBuf[4096]="";
sprintf(szBuf,"In [%s::%s Line: %d] ERROR: currSkill == NULL, Unit = [%s]\n",__FILE__,__FUNCTION__,__LINE__,this->toString().c_str());
throw runtime_error(szBuf);
}
return currSkill->getAnimation();
}
const Model *Unit::getCurrentModel() const{
if(currSkill == NULL) {
char szBuf[4096]="";

1
source/glest_game/type_instances/unit.h
View File

@ -392,6 +392,7 @@ public:
//render related
const Model *getCurrentModel() const;
Model *getCurrentModelPtr() const;
Vec3f getCurrVector() const;
Vec3f getCurrVectorFlat() const;

1
source/glest_game/types/object_type.cpp
View File

@ -29,6 +29,7 @@ void ObjectType::init(int modelCount, int objectClass, bool walkable, int height
void ObjectType::loadModel(const string &path){
Model *model= Renderer::getInstance().newModel(rsGame);
model->setIsStaticModel(true);
model->load(path);
color= Vec3f(0.f);
if(model->getMeshCount()>0 && model->getMesh(0)->getTexture(0) != NULL) {

2
source/glest_game/types/resource_type.h
View File

@ -56,7 +56,7 @@ public:
int getResourceNumber() const {return resourceNumber;}
int getInterval() const {return interval;}
int getDefResPerPatch() const {return defResPerPatch;}
const Model *getModel() const {return model;}
Model *getModel() const {return model;}
bool getRecoup_cost() const { return recoup_cost;}
static ResourceClass strToRc(const string &s);

2
source/glest_game/types/skill_type.h
View File

@ -98,7 +98,7 @@ public:
int getEpCost() const {return mpCost;}
int getSpeed() const {return speed;}
int getAnimSpeed() const {return animSpeed;}
const Model *getAnimation() const {return animation;}
Model *getAnimation() const {return animation;}
StaticSound *getSound() const {return sounds.getRandSound();}
float getSoundStartTime() const {return soundStartTime;}

4
source/shared_lib/include/graphics/gl/model_renderer_gl.h
View File

@ -42,8 +42,8 @@ public:
private:
void renderMesh(const Mesh *mesh);
void renderMeshNormals(const Mesh *mesh);
void renderMesh(const Mesh *mesh, bool isStaticModel);
void renderMeshNormals(const Mesh *mesh, bool isStaticModel);
};
}}}//end namespace

37
source/shared_lib/include/graphics/model.h
View File

@ -25,6 +25,8 @@ using std::string;
using std::map;
using std::pair;
//#define ENABLE_VBO_CODE
namespace Shared{ namespace Graphics{
class Model;
@ -39,7 +41,7 @@ class TextureManager;
// Part of a 3D model
// =====================================================
class Mesh{
class Mesh {
private:
//mesh data
Texture2D *textures[meshTextureCount];
@ -50,6 +52,7 @@ private:
uint32 frameCount;
uint32 vertexCount;
uint32 indexCount;
uint32 texCoordFrameCount;
//vertex data
Vec3f *vertices;
@ -71,6 +74,12 @@ private:
InterpolationData *interpolationData;
TextureManager *textureManager;
#if defined(ENABLE_VBO_CODE)
// Vertex Buffer Object Names
uint32 m_nVBOVertices; // Vertex VBO Name
uint32 m_nVBOTexCoords; // Texture Coordinate VBO Name
#endif
public:
//init & end
Mesh();
@ -87,6 +96,12 @@ public:
uint32 getIndexCount() const {return indexCount;}
uint32 getTriangleCount() const;
#if defined(ENABLE_VBO_CODE)
uint32 getVBOVertices() const { return m_nVBOVertices;}
uint32 getVBOTexCoords() const { return m_nVBOTexCoords;}
void BuildVBOs();
#endif
//data
const Vec3f *getVertices() const {return vertices;}
const Vec3f *getNormals() const {return normals;}
@ -109,8 +124,8 @@ public:
//interpolation
void buildInterpolationData();
void updateInterpolationData(float t, bool cycle) const;
void updateInterpolationVertices(float t, bool cycle) const;
void updateInterpolationData(float t, bool cycle);
void updateInterpolationVertices(float t, bool cycle);
//load
void loadV2(const string &dir, FILE *f, TextureManager *textureManager,bool deletePixMapAfterLoad);
@ -130,7 +145,7 @@ private:
// 3D Model, than can be loaded from a g3d file
// =====================================================
class Model{
class Model {
private:
TextureManager *textureManager;
@ -139,6 +154,13 @@ private:
uint32 meshCount;
Mesh *meshes;
float lastTData;
bool lastCycleData;
float lastTVertex;
bool lastCycleVertex;
bool isStaticModel;
public:
//constructor & destructor
Model();
@ -147,8 +169,8 @@ public:
virtual void end()= 0;
//data
void updateInterpolationData(float t, bool cycle) const;
void updateInterpolationVertices(float t, bool cycle) const;
void updateInterpolationData(float t, bool cycle);
void updateInterpolationVertices(float t, bool cycle);
void buildShadowVolumeData() const;
//get
@ -168,6 +190,9 @@ public:
void setTextureManager(TextureManager *textureManager) {this->textureManager= textureManager;}
void deletePixels();
bool getIsStaticModel() const { return isStaticModel; }
void setIsStaticModel(bool value) { isStaticModel = value; }
private:
void buildInterpolationData() const;
};

99
source/shared_lib/sources/graphics/gl/model_renderer_gl.cpp
View File

@ -104,7 +104,7 @@ void ModelRendererGl::render(const Model *model) {
//render every mesh
for(uint32 i=0; i<model->getMeshCount(); ++i) {
renderMesh(model->getMesh(i));
renderMesh(model->getMesh(i),model->getIsStaticModel());
}
//assertions
@ -118,7 +118,7 @@ void ModelRendererGl::renderNormalsOnly(const Model *model) {
//render every mesh
for(uint32 i=0; i<model->getMeshCount(); ++i) {
renderMeshNormals(model->getMesh(i));
renderMeshNormals(model->getMesh(i),model->getIsStaticModel());
}
//assertions
@ -127,7 +127,7 @@ void ModelRendererGl::renderNormalsOnly(const Model *model) {
// ===================== PRIVATE =======================
void ModelRendererGl::renderMesh(const Mesh *mesh) {
void ModelRendererGl::renderMesh(const Mesh *mesh, bool isStaticModel) {
//assertions
assertGl();
@ -178,37 +178,80 @@ void ModelRendererGl::renderMesh(const Mesh *mesh) {
//assertions
assertGl();
//vertices
glVertexPointer(3, GL_FLOAT, 0, mesh->getInterpolationData()->getVertices());
#if defined(ENABLE_VBO_CODE)
if(isStaticModel == true) {
//vertices
glBindBufferARB( GL_ARRAY_BUFFER_ARB, mesh->getVBOVertices() );
glVertexPointer( 3, GL_FLOAT, 0, (char *) NULL ); // Set The Vertex Pointer To The Vertex Buffer
//normals
if(renderNormals) {
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, mesh->getInterpolationData()->getNormals());
}
else{
glDisableClientState(GL_NORMAL_ARRAY);
}
//normals
if(renderNormals) {
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, mesh->getInterpolationData()->getNormals());
}
else{
glDisableClientState(GL_NORMAL_ARRAY);
}
//tex coords
if(renderTextures && mesh->getTexture(mtDiffuse)!=NULL ) {
if(duplicateTexCoords) {
glActiveTexture(GL_TEXTURE0 + secondaryTexCoordUnit);
//tex coords
if(renderTextures && mesh->getTexture(mtDiffuse) != NULL ) {
glBindBufferARB( GL_ARRAY_BUFFER_ARB, mesh->getVBOTexCoords() );
if(duplicateTexCoords) {
glActiveTexture(GL_TEXTURE0 + secondaryTexCoordUnit);
//glEnableClientState(GL_TEXTURE_COORD_ARRAY);
//glTexCoordPointer(2, GL_FLOAT, 0, mesh->getTexCoords());
glTexCoordPointer( 2, GL_FLOAT, 0, (char *) NULL ); // Set The TexCoord Pointer To The TexCoord Buffer
}
glActiveTexture(GL_TEXTURE0);
//glEnableClientState(GL_TEXTURE_COORD_ARRAY);
//glTexCoordPointer(2, GL_FLOAT, 0, mesh->getTexCoords());
glTexCoordPointer( 2, GL_FLOAT, 0, (char *) NULL ); // Set The TexCoord Pointer To The TexCoord Buffer
}
else {
if(duplicateTexCoords) {
glActiveTexture(GL_TEXTURE0 + secondaryTexCoordUnit);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
glActiveTexture(GL_TEXTURE0);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
}
else
#endif
{
//vertices
glVertexPointer(3, GL_FLOAT, 0, mesh->getInterpolationData()->getVertices());
//normals
if(renderNormals) {
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, mesh->getInterpolationData()->getNormals());
}
else{
glDisableClientState(GL_NORMAL_ARRAY);
}
//tex coords
if(renderTextures && mesh->getTexture(mtDiffuse)!=NULL ) {
if(duplicateTexCoords) {
glActiveTexture(GL_TEXTURE0 + secondaryTexCoordUnit);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, mesh->getTexCoords());
}
glActiveTexture(GL_TEXTURE0);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, mesh->getTexCoords());
}
glActiveTexture(GL_TEXTURE0);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, mesh->getTexCoords());
}
else {
if(duplicateTexCoords) {
glActiveTexture(GL_TEXTURE0 + secondaryTexCoordUnit);
else {
if(duplicateTexCoords) {
glActiveTexture(GL_TEXTURE0 + secondaryTexCoordUnit);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
glActiveTexture(GL_TEXTURE0);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
glActiveTexture(GL_TEXTURE0);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
//draw model
@ -218,7 +261,7 @@ void ModelRendererGl::renderMesh(const Mesh *mesh) {
assertGl();
}
void ModelRendererGl::renderMeshNormals(const Mesh *mesh) {
void ModelRendererGl::renderMeshNormals(const Mesh *mesh,bool isStaticModel) {
glBegin(GL_LINES);
for(unsigned int i= 0; i<mesh->getIndexCount(); ++i){

6
source/shared_lib/sources/graphics/interpolation.cpp
View File

@ -84,9 +84,6 @@ void InterpolationData::updateVertices(float t, bool cycle) {
if(iterFind != cacheVertices.end()) {
std::map<bool, Vec3f *>::iterator iterFind2 = iterFind->second.find(cycle);
if(iterFind2 != iterFind->second.end()) {
//for(uint32 j=0; j< vertexCount; ++j){
// vertices[j] = iterFind2->second[j];
//}
memcpy(vertices,iterFind2->second,sizeof(Vec3f) * vertexCount);
return;
}
@ -130,9 +127,6 @@ void InterpolationData::updateNormals(float t, bool cycle){
if(iterFind != cacheNormals.end()) {
std::map<bool, Vec3f *>::iterator iterFind2 = iterFind->second.find(cycle);
if(iterFind2 != iterFind->second.end()) {
//for(uint32 j=0; j< vertexCount; ++j){
// normals[j] = iterFind2->second[j];
//}
memcpy(normals,iterFind2->second,sizeof(Vec3f) * vertexCount);
return;
}

99
source/shared_lib/sources/graphics/model.cpp
View File

@ -18,6 +18,13 @@
#include "interpolation.h"
#include "conversion.h"
#include "util.h"
#if defined(ENABLE_VBO_CODE)
#include "opengl.h"
#endif
#include "leak_dumper.h"
using namespace Shared::Platform;
@ -39,6 +46,7 @@ Mesh::Mesh() {
frameCount= 0;
vertexCount= 0;
indexCount= 0;
texCoordFrameCount = 0;
vertices= NULL;
normals= NULL;
@ -94,14 +102,36 @@ void Mesh::buildInterpolationData(){
interpolationData= new InterpolationData(this);
}
void Mesh::updateInterpolationData(float t, bool cycle) const{
void Mesh::updateInterpolationData(float t, bool cycle) {
interpolationData->update(t, cycle);
}
void Mesh::updateInterpolationVertices(float t, bool cycle) const{
void Mesh::updateInterpolationVertices(float t, bool cycle) {
interpolationData->updateVertices(t, cycle);
}
#if defined(ENABLE_VBO_CODE)
void Mesh::BuildVBOs() {
// Generate And Bind The Vertex Buffer
glGenBuffersARB( 1, &m_nVBOVertices ); // Get A Valid Name
glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_nVBOVertices ); // Bind The Buffer
// Load The Data
glBufferDataARB( GL_ARRAY_BUFFER_ARB, getVertexCount() * 3 * sizeof(float), vertices, GL_STATIC_DRAW_ARB );
// Generate And Bind The Texture Coordinate Buffer
glGenBuffersARB( 1, &m_nVBOTexCoords ); // Get A Valid Name
glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_nVBOTexCoords ); // Bind The Buffer
// Load The Data
glBufferDataARB( GL_ARRAY_BUFFER_ARB, getVertexCount() * 2 * sizeof(float), texCoords, GL_STATIC_DRAW_ARB );
// Our Copy Of The Data Is No Longer Necessary, It Is Safe In The Graphics Card
delete [] vertices; vertices = NULL;
delete [] texCoords; texCoords = NULL;
}
#endif
// ==================== load ====================
void Mesh::loadV2(const string &dir, FILE *f, TextureManager *textureManager,bool deletePixMapAfterLoad) {
@ -123,6 +153,7 @@ void Mesh::loadV2(const string &dir, FILE *f, TextureManager *textureManager,boo
frameCount= meshHeader.vertexFrameCount;
vertexCount= meshHeader.pointCount;
indexCount= meshHeader.indexCount;
texCoordFrameCount = meshHeader.texCoordFrameCount;
init();
@ -176,6 +207,7 @@ void Mesh::loadV3(const string &dir, FILE *f, TextureManager *textureManager,boo
frameCount= meshHeader.vertexFrameCount;
vertexCount= meshHeader.pointCount;
indexCount= meshHeader.indexCount;
texCoordFrameCount = meshHeader.texCoordFrameCount;
init();
@ -366,10 +398,16 @@ Model::Model(){
meshCount= 0;
meshes= NULL;
textureManager= NULL;
lastTData = -1;
lastCycleData = -1;
lastTVertex = -1;
lastCycleVertex = -1;
isStaticModel = false;
}
Model::~Model(){
delete [] meshes;
meshes = NULL;
}
// ==================== data ====================
@ -380,15 +418,23 @@ void Model::buildInterpolationData() const{
}
}
void Model::updateInterpolationData(float t, bool cycle) const{
for(unsigned int i=0; i<meshCount; ++i){
meshes[i].updateInterpolationData(t, cycle);
void Model::updateInterpolationData(float t, bool cycle) {
if(lastTData != t || lastCycleData != cycle) {
for(unsigned int i=0; i<meshCount; ++i){
meshes[i].updateInterpolationData(t, cycle);
}
lastTData = t;
lastCycleData = cycle;
}
}
void Model::updateInterpolationVertices(float t, bool cycle) const{
for(unsigned int i=0; i<meshCount; ++i){
meshes[i].updateInterpolationVertices(t, cycle);
void Model::updateInterpolationVertices(float t, bool cycle) {
if(lastTVertex != t || lastCycleVertex != cycle) {
for(unsigned int i=0; i<meshCount; ++i){
meshes[i].updateInterpolationVertices(t, cycle);
}
lastTVertex = t;
lastCycleVertex = cycle;
}
}
@ -492,13 +538,12 @@ void Model::loadG3d(const string &path, bool deletePixMapAfterLoad) {
fileVersion= fileHeader.version;
//version 4
if(fileHeader.version==4){
if(fileHeader.version == 4) {
//model header
ModelHeader modelHeader;
readBytes = fread(&modelHeader, sizeof(ModelHeader), 1, f);
meshCount= modelHeader.meshCount;
if(modelHeader.type!=mtMorphMesh){
if(modelHeader.type != mtMorphMesh) {
throw runtime_error("Invalid model type");
}
@ -508,6 +553,15 @@ void Model::loadG3d(const string &path, bool deletePixMapAfterLoad) {
meshes[i].load(dir, f, textureManager,deletePixMapAfterLoad);
meshes[i].buildInterpolationData();
}
#if defined(ENABLE_VBO_CODE)
if(isStaticModel == true) {
this->updateInterpolationData(0.f, true);
for(uint32 i=0; i<meshCount; ++i){
meshes[i].BuildVBOs();
}
}
#endif
}
//version 3
else if(fileHeader.version==3){
@ -518,18 +572,35 @@ void Model::loadG3d(const string &path, bool deletePixMapAfterLoad) {
meshes[i].loadV3(dir, f, textureManager,deletePixMapAfterLoad);
meshes[i].buildInterpolationData();
}
#if defined(ENABLE_VBO_CODE)
if(isStaticModel == true) {
this->updateInterpolationData(0.f, true);
for(uint32 i=0; i<meshCount; ++i){
meshes[i].BuildVBOs();
}
}
#endif
}
//version 2
else if(fileHeader.version==2){
else if(fileHeader.version==2) {
readBytes = fread(&meshCount, sizeof(meshCount), 1, f);
meshes= new Mesh[meshCount];
for(uint32 i=0; i<meshCount; ++i){
meshes[i].loadV2(dir, f, textureManager,deletePixMapAfterLoad);
meshes[i].buildInterpolationData();
}
#if defined(ENABLE_VBO_CODE)
if(isStaticModel == true) {
this->updateInterpolationData(0.f, true);
for(uint32 i=0; i<meshCount; ++i){
meshes[i].BuildVBOs();
}
}
#endif
}
else{
else {
throw runtime_error("Invalid model version: "+ intToStr(fileHeader.version));
}