ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove Base Vertex/Offset if base instance is unavailable

Browse Source
This commit is contained in:
Vincent Lejeune 2014-08-27 21:21:17 +02:00 committed by vlj
parent 998b5a89ac
commit a3b8494ad5
8 changed files with 106 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/graphics/render.cpp
View File

@ -768,7 +768,8 @@ void IrrDriver::renderGlow(std::vector<GlowData>& glows)
glDepthMask(GL_FALSE); glDepthMask(GL_FALSE);
glDisable(GL_BLEND); glDisable(GL_BLEND);
glBindVertexArray(VAOManager::getInstance()->getVAO(EVT_STANDARD)); if (irr_driver->hasARB_base_instance())
glBindVertexArray(VAOManager::getInstance()->getVAO(EVT_STANDARD));
for (u32 i = 0; i < glowcount; i++) for (u32 i = 0; i < glowcount; i++)
{ {
const GlowData &dat = glows[i]; const GlowData &dat = glows[i];

37
src/graphics/render_geometry.cpp
View File

@ -120,12 +120,15 @@ template<typename Shader, enum E_VERTEX_TYPE VertexType, int ...List, typename..
void renderMeshes1stPass(const std::vector<TexUnit> &TexUnits, std::vector<STK::Tuple<TupleType...> > *meshes) void renderMeshes1stPass(const std::vector<TexUnit> &TexUnits, std::vector<STK::Tuple<TupleType...> > *meshes)
{ {
glUseProgram(Shader::getInstance()->Program); glUseProgram(Shader::getInstance()->Program);
glBindVertexArray(VAOManager::getInstance()->getVAO(VertexType)); if (irr_driver->hasARB_base_instance())
glBindVertexArray(VAOManager::getInstance()->getVAO(VertexType));
for (unsigned i = 0; i < meshes->size(); i++) for (unsigned i = 0; i < meshes->size(); i++)
{ {
std::vector<GLuint> Textures; std::vector<GLuint> Textures;
std::vector<uint64_t> Handles; std::vector<uint64_t> Handles;
GLMesh &mesh = *(STK::tuple_get<0>(meshes->at(i))); GLMesh &mesh = *(STK::tuple_get<0>(meshes->at(i)));
if (!irr_driver->hasARB_base_instance())
glBindVertexArray(mesh.vao);
for (unsigned j = 0; j < TexUnits.size(); j++) for (unsigned j = 0; j < TexUnits.size(); j++)
{ {
if (UserConfigParams::m_azdo) if (UserConfigParams::m_azdo)
@ -388,12 +391,15 @@ void renderMeshes2ndPass(const std::vector<TexUnit> &TexUnits, std::vector<STK::
const std::vector<GLuint> &Prefilled_Tex) const std::vector<GLuint> &Prefilled_Tex)
{ {
glUseProgram(Shader::getInstance()->Program); glUseProgram(Shader::getInstance()->Program);
glBindVertexArray(VAOManager::getInstance()->getVAO(VertexType)); if (irr_driver->hasARB_base_instance())
glBindVertexArray(VAOManager::getInstance()->getVAO(VertexType));
for (unsigned i = 0; i < meshes->size(); i++) for (unsigned i = 0; i < meshes->size(); i++)
{ {
std::vector<uint64_t> Handles(Prefilled_Handle); std::vector<uint64_t> Handles(Prefilled_Handle);
std::vector<GLuint> Textures(Prefilled_Tex); std::vector<GLuint> Textures(Prefilled_Tex);
GLMesh &mesh = *(STK::tuple_get<0>(meshes->at(i))); GLMesh &mesh = *(STK::tuple_get<0>(meshes->at(i)));
if (!irr_driver->hasARB_base_instance())
glBindVertexArray(mesh.vao);
for (unsigned j = 0; j < TexUnits.size(); j++) for (unsigned j = 0; j < TexUnits.size(); j++)
{ {
if (UserConfigParams::m_azdo) if (UserConfigParams::m_azdo)
@ -615,12 +621,15 @@ template<typename Shader, enum E_VERTEX_TYPE VertexType, int...List, typename...
void renderTransparenPass(const std::vector<TexUnit> &TexUnits, std::vector<STK::Tuple<TupleType...> > *meshes) void renderTransparenPass(const std::vector<TexUnit> &TexUnits, std::vector<STK::Tuple<TupleType...> > *meshes)
{ {
glUseProgram(Shader::getInstance()->Program); glUseProgram(Shader::getInstance()->Program);
glBindVertexArray(VAOManager::getInstance()->getVAO(VertexType)); if (irr_driver->hasARB_base_instance())
glBindVertexArray(VAOManager::getInstance()->getVAO(VertexType));
for (unsigned i = 0; i < meshes->size(); i++) for (unsigned i = 0; i < meshes->size(); i++)
{ {
std::vector<uint64_t> Handles; std::vector<uint64_t> Handles;
std::vector<GLuint> Textures; std::vector<GLuint> Textures;
GLMesh &mesh = *(STK::tuple_get<0>(meshes->at(i))); GLMesh &mesh = *(STK::tuple_get<0>(meshes->at(i)));
if (!irr_driver->hasARB_base_instance())
glBindVertexArray(mesh.vao);
for (unsigned j = 0; j < TexUnits.size(); j++) for (unsigned j = 0; j < TexUnits.size(); j++)
{ {
if (!mesh.textures[TexUnits[j].m_id]) if (!mesh.textures[TexUnits[j].m_id])
@ -674,7 +683,8 @@ void IrrDriver::renderTransparent()
ListDisplacement::getInstance()->clear(); ListDisplacement::getInstance()->clear();
m_scene_manager->drawAll(scene::ESNRP_TRANSPARENT); m_scene_manager->drawAll(scene::ESNRP_TRANSPARENT);
glBindVertexArray(VAOManager::getInstance()->getVAO(EVT_STANDARD)); if (irr_driver->hasARB_base_instance())
glBindVertexArray(VAOManager::getInstance()->getVAO(EVT_STANDARD));
if (World::getWorld() && World::getWorld()->isFogEnabled()) if (World::getWorld() && World::getWorld()->isFogEnabled())
{ {
@ -716,13 +726,16 @@ void IrrDriver::renderTransparent()
glStencilFunc(GL_ALWAYS, 1, 0xFF); glStencilFunc(GL_ALWAYS, 1, 0xFF);
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
glBindVertexArray(VAOManager::getInstance()->getVAO(EVT_2TCOORDS)); if (irr_driver->hasARB_base_instance())
glBindVertexArray(VAOManager::getInstance()->getVAO(EVT_2TCOORDS));
// Generate displace mask // Generate displace mask
// Use RTT_TMP4 as displace mask // Use RTT_TMP4 as displace mask
irr_driver->getFBO(FBO_TMP1_WITH_DS).Bind(); irr_driver->getFBO(FBO_TMP1_WITH_DS).Bind();
for (unsigned i = 0; i < ListDisplacement::getInstance()->size(); i++) for (unsigned i = 0; i < ListDisplacement::getInstance()->size(); i++)
{ {
const GLMesh &mesh = *(STK::tuple_get<0>(ListDisplacement::getInstance()->at(i))); const GLMesh &mesh = *(STK::tuple_get<0>(ListDisplacement::getInstance()->at(i)));
if (!irr_driver->hasARB_base_instance())
glBindVertexArray(mesh.vao);
const core::matrix4 &AbsoluteTransformation = STK::tuple_get<1>(ListDisplacement::getInstance()->at(i)); const core::matrix4 &AbsoluteTransformation = STK::tuple_get<1>(ListDisplacement::getInstance()->at(i));
if (mesh.VAOType != video::EVT_2TCOORDS) if (mesh.VAOType != video::EVT_2TCOORDS)
{ {
@ -747,6 +760,8 @@ void IrrDriver::renderTransparent()
for (unsigned i = 0; i < ListDisplacement::getInstance()->size(); i++) for (unsigned i = 0; i < ListDisplacement::getInstance()->size(); i++)
{ {
const GLMesh &mesh = *(STK::tuple_get<0>(ListDisplacement::getInstance()->at(i))); const GLMesh &mesh = *(STK::tuple_get<0>(ListDisplacement::getInstance()->at(i)));
if (!irr_driver->hasARB_base_instance())
glBindVertexArray(mesh.vao);
const core::matrix4 &AbsoluteTransformation = STK::tuple_get<1>(ListDisplacement::getInstance()->at(i)); const core::matrix4 &AbsoluteTransformation = STK::tuple_get<1>(ListDisplacement::getInstance()->at(i));
if (mesh.VAOType != video::EVT_2TCOORDS) if (mesh.VAOType != video::EVT_2TCOORDS)
continue; continue;
@ -814,12 +829,15 @@ template<typename T, enum E_VERTEX_TYPE VertexType, int...List, typename... Args
void renderShadow(const std::vector<GLuint> TextureUnits, unsigned cascade, const std::vector<STK::Tuple<Args...> > *t) void renderShadow(const std::vector<GLuint> TextureUnits, unsigned cascade, const std::vector<STK::Tuple<Args...> > *t)
{ {
glUseProgram(T::getInstance()->Program); glUseProgram(T::getInstance()->Program);
glBindVertexArray(VAOManager::getInstance()->getVAO(VertexType)); if (irr_driver->hasARB_base_instance())
glBindVertexArray(VAOManager::getInstance()->getVAO(VertexType));
for (unsigned i = 0; i < t->size(); i++) for (unsigned i = 0; i < t->size(); i++)
{ {
std::vector<uint64_t> Handles; std::vector<uint64_t> Handles;
std::vector<GLuint> Textures; std::vector<GLuint> Textures;
GLMesh *mesh = STK::tuple_get<0>(t->at(i)); GLMesh *mesh = STK::tuple_get<0>(t->at(i));
if (!irr_driver->hasARB_base_instance())
glBindVertexArray(mesh->vao);
for (unsigned j = 0; j < TextureUnits.size(); j++) for (unsigned j = 0; j < TextureUnits.size(); j++)
{ {
compressTexture(mesh->textures[TextureUnits[j]], true); compressTexture(mesh->textures[TextureUnits[j]], true);
@ -882,7 +900,7 @@ void renderInstancedShadow(const std::vector<GLuint> TextureUnits, unsigned casc
std::vector<GLuint> Textures; std::vector<GLuint> Textures;
GLMesh *mesh = STK::tuple_get<0>(t->at(i)); GLMesh *mesh = STK::tuple_get<0>(t->at(i));
if (!irr_driver->hasARB_base_instance()) if (!irr_driver->hasARB_base_instance())
glBindVertexArray(mesh->vao_shadow_pass); glBindVertexArray(mesh->vao);
for (unsigned j = 0; j < TextureUnits.size(); j++) for (unsigned j = 0; j < TextureUnits.size(); j++)
Textures.push_back(getTextureGLuint(mesh->textures[TextureUnits[j]])); Textures.push_back(getTextureGLuint(mesh->textures[TextureUnits[j]]));
@ -1062,11 +1080,14 @@ template<typename T, enum E_VERTEX_TYPE VertexType, int... Selector, typename...
void drawRSM(const core::matrix4 & rsm_matrix, const std::vector<GLuint> &TextureUnits, std::vector<STK::Tuple<Args...> > *t) void drawRSM(const core::matrix4 & rsm_matrix, const std::vector<GLuint> &TextureUnits, std::vector<STK::Tuple<Args...> > *t)
{ {
glUseProgram(T::getInstance()->Program); glUseProgram(T::getInstance()->Program);
glBindVertexArray(VAOManager::getInstance()->getVAO(VertexType)); if (irr_driver->hasARB_base_instance())
glBindVertexArray(VAOManager::getInstance()->getVAO(VertexType));
for (unsigned i = 0; i < t->size(); i++) for (unsigned i = 0; i < t->size(); i++)
{ {
std::vector<GLuint> Textures; std::vector<GLuint> Textures;
GLMesh *mesh = STK::tuple_get<0>(t->at(i)); GLMesh *mesh = STK::tuple_get<0>(t->at(i));
if (!irr_driver->hasARB_base_instance())
glBindVertexArray(mesh->vao);
for (unsigned j = 0; j < TextureUnits.size(); j++) for (unsigned j = 0; j < TextureUnits.size(); j++)
Textures.push_back(getTextureGLuint(mesh->textures[TextureUnits[j]])); Textures.push_back(getTextureGLuint(mesh->textures[TextureUnits[j]]));
T::getInstance()->SetTextureUnits(Textures); T::getInstance()->SetTextureUnits(Textures);

34
src/graphics/stkanimatedmesh.cpp
View File

@ -33,6 +33,8 @@ void STKAnimatedMesh::cleanGLMeshes()
glDeleteVertexArrays(1, &(mesh.vao)); glDeleteVertexArrays(1, &(mesh.vao));
glDeleteBuffers(1, &(mesh.vertex_buffer)); glDeleteBuffers(1, &(mesh.vertex_buffer));
glDeleteBuffers(1, &(mesh.index_buffer)); glDeleteBuffers(1, &(mesh.index_buffer));
if (mesh.instance_buffer)
glDeleteBuffers(1, &(mesh.instance_buffer));
#ifdef Bindless_Texture_Support #ifdef Bindless_Texture_Support
for (unsigned j = 0; j < 6; j++) for (unsigned j = 0; j < 6; j++)
{ {
@ -108,10 +110,29 @@ void STKAnimatedMesh::render()
MeshSolidMaterial[MatType].push_back(&mesh); MeshSolidMaterial[MatType].push_back(&mesh);
InitTextures(mesh, MatType); InitTextures(mesh, MatType);
} }
std::pair<unsigned, unsigned> p = VAOManager::getInstance()->getBase(mb);
mesh.vaoBaseVertex = p.first; if (irr_driver->hasARB_base_instance())
mesh.vaoOffset = p.second; {
mesh.VAOType = mb->getVertexType(); std::pair<unsigned, unsigned> p = VAOManager::getInstance()->getBase(mb);
mesh.vaoBaseVertex = p.first;
mesh.vaoOffset = p.second;
}
else
{
fillLocalBuffer(mesh, mb);
mesh.vao = createVAO(mesh.vertex_buffer, mesh.index_buffer, mb->getVertexType());
glGenBuffers(1, &(mesh.instance_buffer));
glBindBuffer(GL_ARRAY_BUFFER, mesh.instance_buffer);
glEnableVertexAttribArray(7);
glVertexAttribPointer(7, 3, GL_FLOAT, GL_FALSE, sizeof(InstanceData), 0);
glVertexAttribDivisor(7, 1);
glEnableVertexAttribArray(8);
glVertexAttribPointer(8, 3, GL_FLOAT, GL_FALSE, sizeof(InstanceData), (GLvoid*)(3 * sizeof(float)));
glVertexAttribDivisor(8, 1);
glEnableVertexAttribArray(9);
glVertexAttribPointer(9, 3, GL_FLOAT, GL_FALSE, sizeof(InstanceData), (GLvoid*)(6 * sizeof(float)));
glVertexAttribDivisor(9, 1);
}
} }
} }
firstTime = false; firstTime = false;
@ -126,7 +147,10 @@ void STKAnimatedMesh::render()
{ {
glBindVertexArray(0); glBindVertexArray(0);
size_t size = mb->getVertexCount() * GLmeshes[i].Stride; size_t size = mb->getVertexCount() * GLmeshes[i].Stride;
glBindBuffer(GL_ARRAY_BUFFER, VAOManager::getInstance()->getVBO(mb->getVertexType())); if (irr_driver->hasARB_base_instance())
glBindBuffer(GL_ARRAY_BUFFER, VAOManager::getInstance()->getVBO(mb->getVertexType()));
else
glBindBuffer(GL_ARRAY_BUFFER, GLmeshes[i].vertex_buffer);
GLbitfield bitfield = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_UNSYNCHRONIZED_BIT; GLbitfield bitfield = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_UNSYNCHRONIZED_BIT;
void * buf = glMapBufferRange(GL_ARRAY_BUFFER, GLmeshes[i].vaoBaseVertex * GLmeshes[i].Stride, size, bitfield); void * buf = glMapBufferRange(GL_ARRAY_BUFFER, GLmeshes[i].vaoBaseVertex * GLmeshes[i].Stride, size, bitfield);
memcpy(buf, mb->getVertices(), size); memcpy(buf, mb->getVertices(), size);

29
src/graphics/stkinstancedscenenode.cpp
View File

@ -27,10 +27,12 @@ void STKInstancedSceneNode::cleanGL()
continue; continue;
if (mesh.vao) if (mesh.vao)
glDeleteVertexArrays(1, &(mesh.vao)); glDeleteVertexArrays(1, &(mesh.vao));
if (mesh.vao_shadow_pass) if (mesh.vertex_buffer)
glDeleteVertexArrays(1, &(mesh.vao_shadow_pass)); glDeleteBuffers(1, &(mesh.vertex_buffer));
glDeleteBuffers(1, &(mesh.vertex_buffer)); if (mesh.index_buffer)
glDeleteBuffers(1, &(mesh.index_buffer)); glDeleteBuffers(1, &(mesh.index_buffer));
if (mesh.instance_buffer)
glDeleteBuffers(1, &(mesh.instance_buffer));
#ifdef Bindless_Texture_Support #ifdef Bindless_Texture_Support
for (unsigned j = 0; i < 6; i++) for (unsigned j = 0; i < 6; i++)
{ {
@ -39,7 +41,6 @@ void STKInstancedSceneNode::cleanGL()
} }
#endif #endif
} }
glDeleteBuffers(1, &instances_vbo);
} }
STKInstancedSceneNode::~STKInstancedSceneNode() STKInstancedSceneNode::~STKInstancedSceneNode()
@ -63,7 +64,6 @@ void STKInstancedSceneNode::createGLMeshes()
std::pair<unsigned, unsigned> p = VAOManager::getInstance()->getBase(mb); std::pair<unsigned, unsigned> p = VAOManager::getInstance()->getBase(mb);
mesh.vaoBaseVertex = p.first; mesh.vaoBaseVertex = p.first;
mesh.vaoOffset = p.second; mesh.vaoOffset = p.second;
mesh.VAOType = mb->getVertexType();
} }
else else
fillLocalBuffer(mesh, mb); fillLocalBuffer(mesh, mb);
@ -77,8 +77,8 @@ void STKInstancedSceneNode::initinstancedvaostate(GLMesh &mesh, const std::vecto
if (!irr_driver->hasARB_base_instance()) if (!irr_driver->hasARB_base_instance())
{ {
mesh.vao = createVAO(mesh.vertex_buffer, mesh.index_buffer, getVTXTYPEFromStride(mesh.Stride)); mesh.vao = createVAO(mesh.vertex_buffer, mesh.index_buffer, getVTXTYPEFromStride(mesh.Stride));
glGenBuffers(1, &instances_vbo); glGenBuffers(1, &(mesh.instance_buffer));
glBindBuffer(GL_ARRAY_BUFFER, instances_vbo); glBindBuffer(GL_ARRAY_BUFFER, mesh.instance_buffer);
glBufferData(GL_ARRAY_BUFFER, instances.size() * sizeof(InstanceData), instances.data(), GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, instances.size() * sizeof(InstanceData), instances.data(), GL_STATIC_DRAW);
glEnableVertexAttribArray(7); glEnableVertexAttribArray(7);
@ -90,19 +90,6 @@ void STKInstancedSceneNode::initinstancedvaostate(GLMesh &mesh, const std::vecto
glEnableVertexAttribArray(9); glEnableVertexAttribArray(9);
glVertexAttribPointer(9, 3, GL_FLOAT, GL_FALSE, sizeof(InstanceData), (GLvoid*)(6 * sizeof(float))); glVertexAttribPointer(9, 3, GL_FLOAT, GL_FALSE, sizeof(InstanceData), (GLvoid*)(6 * sizeof(float)));
glVertexAttribDivisor(9, 1); glVertexAttribDivisor(9, 1);
mesh.vao_shadow_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer, getVTXTYPEFromStride(mesh.Stride));
glBindBuffer(GL_ARRAY_BUFFER, instances_vbo);
glEnableVertexAttribArray(7);
glVertexAttribPointer(7, 3, GL_FLOAT, GL_FALSE, sizeof(InstanceData), 0);
glVertexAttribDivisor(7, 1);
glEnableVertexAttribArray(8);
glVertexAttribPointer(8, 3, GL_FLOAT, GL_FALSE, sizeof(InstanceData), (GLvoid*)(3 * sizeof(float)));
glVertexAttribDivisor(8, 1);
glEnableVertexAttribArray(9);
glVertexAttribPointer(9, 3, GL_FLOAT, GL_FALSE, sizeof(InstanceData), (GLvoid*)(6 * sizeof(float)));
glVertexAttribDivisor(9, 1);
glBindVertexArray(0); glBindVertexArray(0);
} }
} }

1
src/graphics/stkinstancedscenenode.hpp
View File

@ -24,7 +24,6 @@ protected:
std::vector<GLMesh> GLmeshes; std::vector<GLMesh> GLmeshes;
std::vector<std::vector<InstanceData> > instanceData; std::vector<std::vector<InstanceData> > instanceData;
core::matrix4 ModelViewProjectionMatrix, TransposeInverseModelView; core::matrix4 ModelViewProjectionMatrix, TransposeInverseModelView;
GLuint instances_vbo;
void createGLMeshes(); void createGLMeshes();
bool isMaterialInitialized; bool isMaterialInitialized;
void setFirstTimeMaterial(); void setFirstTimeMaterial();

1
src/graphics/stkmesh.cpp
View File

@ -178,6 +178,7 @@ GLMesh allocateMeshBuffer(scene::IMeshBuffer* mb)
for (unsigned i = 0; i < 6; i++) for (unsigned i = 0; i < 6; i++)
result.textures[i] = mb->getMaterial().getTexture(i); result.textures[i] = mb->getMaterial().getTexture(i);
result.TextureMatrix = 0; result.TextureMatrix = 0;
result.VAOType = mb->getVertexType();
return result; return result;
} }

2
src/graphics/stkmesh.hpp
View File

@ -35,9 +35,9 @@ enum TransparentMaterial
struct GLMesh { struct GLMesh {
GLuint vao; GLuint vao;
GLuint vao_shadow_pass;
GLuint vertex_buffer; GLuint vertex_buffer;
GLuint index_buffer; GLuint index_buffer;
GLuint instance_buffer;
video::ITexture *textures[6]; video::ITexture *textures[6];
GLenum PrimitiveType; GLenum PrimitiveType;
GLenum IndexType; GLenum IndexType;

56
src/graphics/stkmeshscenenode.cpp
View File

@ -70,38 +70,42 @@ void STKMeshSceneNode::setFirstTimeMaterial()
if (rnd->isTransparent()) if (rnd->isTransparent())
{ {
TransparentMaterial TranspMat = MaterialTypeToTransparentMaterial(type, MaterialTypeParam); TransparentMaterial TranspMat = MaterialTypeToTransparentMaterial(type, MaterialTypeParam);
if (immediate_draw) if (!immediate_draw)
{
fillLocalBuffer(mesh, mb);
mesh.vao = createVAO(mesh.vertex_buffer, mesh.index_buffer, mb->getVertexType());
glBindVertexArray(0);
}
else
TransparentMesh[TranspMat].push_back(&mesh); TransparentMesh[TranspMat].push_back(&mesh);
} }
else else
{ {
assert(!isDisplacement); assert(!isDisplacement);
MeshMaterial MatType = MaterialTypeToMeshMaterial(type, mb->getVertexType()); MeshMaterial MatType = MaterialTypeToMeshMaterial(type, mb->getVertexType());
if (immediate_draw) if (!immediate_draw)
{
fillLocalBuffer(mesh, mb);
mesh.vao = createVAO(mesh.vertex_buffer, mesh.index_buffer, mb->getVertexType());
glBindVertexArray(0);
}
else
{ {
InitTextures(mesh, MatType); InitTextures(mesh, MatType);
MeshSolidMaterials[MatType].push_back(&mesh); MeshSolidMaterials[MatType].push_back(&mesh);
} }
} }
if (!immediate_draw) if (!immediate_draw && irr_driver->hasARB_base_instance())
{ {
std::pair<unsigned, unsigned> p = VAOManager::getInstance()->getBase(mb); std::pair<unsigned, unsigned> p = VAOManager::getInstance()->getBase(mb);
mesh.vaoBaseVertex = p.first; mesh.vaoBaseVertex = p.first;
mesh.vaoOffset = p.second; mesh.vaoOffset = p.second;
mesh.VAOType = mb->getVertexType(); }
else
{
fillLocalBuffer(mesh, mb);
mesh.vao = createVAO(mesh.vertex_buffer, mesh.index_buffer, mb->getVertexType());
glGenBuffers(1, &(mesh.instance_buffer));
glBindBuffer(GL_ARRAY_BUFFER, mesh.instance_buffer);
glEnableVertexAttribArray(7);
glVertexAttribPointer(7, 3, GL_FLOAT, GL_FALSE, sizeof(InstanceData), 0);
glVertexAttribDivisor(7, 1);
glEnableVertexAttribArray(8);
glVertexAttribPointer(8, 3, GL_FLOAT, GL_FALSE, sizeof(InstanceData), (GLvoid*)(3 * sizeof(float)));
glVertexAttribDivisor(8, 1);
glEnableVertexAttribArray(9);
glVertexAttribPointer(9, 3, GL_FLOAT, GL_FALSE, sizeof(InstanceData), (GLvoid*)(6 * sizeof(float)));
glVertexAttribDivisor(9, 1);
glBindVertexArray(0);
} }
} }
isMaterialInitialized = true; isMaterialInitialized = true;
@ -116,8 +120,12 @@ void STKMeshSceneNode::cleanGLMeshes()
continue; continue;
if (mesh.vao) if (mesh.vao)
glDeleteVertexArrays(1, &(mesh.vao)); glDeleteVertexArrays(1, &(mesh.vao));
glDeleteBuffers(1, &(mesh.vertex_buffer)); if (mesh.vertex_buffer)
glDeleteBuffers(1, &(mesh.index_buffer)); glDeleteBuffers(1, &(mesh.vertex_buffer));
if (mesh.index_buffer)
glDeleteBuffers(1, &(mesh.index_buffer));
if (mesh.instance_buffer)
glDeleteBuffers(1, &(mesh.instance_buffer));
#ifdef Bindless_Texture_Support #ifdef Bindless_Texture_Support
for (unsigned j = 0; j < 6; j++) for (unsigned j = 0; j < 6; j++)
{ {
@ -310,7 +318,10 @@ void STKMeshSceneNode::render()
scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i);
if (!mb) if (!mb)
continue; continue;
glBindVertexArray(VAOManager::getInstance()->getVAO(video::EVT_STANDARD)); if (irr_driver->hasARB_base_instance())
glBindVertexArray(VAOManager::getInstance()->getVAO(video::EVT_STANDARD));
else
glBindVertexArray(GLmeshes[i].vao);
drawGlow(GLmeshes[i]); drawGlow(GLmeshes[i]);
} }
} }
@ -445,9 +456,14 @@ void STKMeshSceneNode::render()
if (!TransparentMesh[TM_BUBBLE].empty()) if (!TransparentMesh[TM_BUBBLE].empty())
glUseProgram(MeshShader::BubbleShader::Program); glUseProgram(MeshShader::BubbleShader::Program);
glBindVertexArray(VAOManager::getInstance()->getVAO(video::EVT_STANDARD)); if (irr_driver->hasARB_base_instance())
glBindVertexArray(VAOManager::getInstance()->getVAO(video::EVT_STANDARD));
for_in(mesh, TransparentMesh[TM_BUBBLE]) for_in(mesh, TransparentMesh[TM_BUBBLE])
{
if (irr_driver->hasARB_base_instance())
glBindVertexArray(mesh->vao);
drawBubble(*mesh, ModelViewProjectionMatrix); drawBubble(*mesh, ModelViewProjectionMatrix);
}
return; return;
} }
} }