kraken_engine/kraken
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated krmodel file format to support bone weights, physics collider meshes, and variable combinations of vertex attributes

Browse Source 
--HG--
extra : convert_revision : svn%3A7752d6cf-9f14-4ad2-affc-04f1e67b81a5/trunk%40183
This commit is contained in:
kearwood
2012-12-10 21:09:14 +00:00
parent 317522edd3
commit 4f5fd10e71
17 changed files with 382 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
KREngine/KREngine/Classes/KRCamera.cpp
View File

@@ -350,7 +350,7 @@ void KRCamera::renderFrame(KRScene &scene, float deltaTime) {
getContext().getTextureManager()->selectTexture(0, m_pSkyBoxTexture); getContext().getTextureManager()->selectTexture(0, m_pSkyBoxTexture);
// Render a full screen quad // Render a full screen quad
m_pContext->getModelManager()->bindVBO((void *)KRENGINE_VBO_2D_SQUARE, KRENGINE_VBO_2D_SQUARE_SIZE, true, false, false, true, false); m_pContext->getModelManager()->bindVBO((void *)KRENGINE_VBO_2D_SQUARE, KRENGINE_VBO_2D_SQUARE_SIZE, true, false, false, true, false, false, false);
GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)); GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
} }
@@ -465,7 +465,7 @@ void KRCamera::renderFrame(KRScene &scene, float deltaTime) {
KRMat4 projectionMatrix = getProjectionMatrix(); KRMat4 projectionMatrix = getProjectionMatrix();
m_pContext->getModelManager()->bindVBO((void *)KRENGINE_VBO_3D_CUBE, KRENGINE_VBO_3D_CUBE_SIZE, true, false, false, false, false); m_pContext->getModelManager()->bindVBO((void *)KRENGINE_VBO_3D_CUBE, KRENGINE_VBO_3D_CUBE_SIZE, true, false, false, false, false, false, false);
for(std::map<KRAABB, int>::iterator itr=m_viewport.getVisibleBounds().begin(); itr != m_viewport.getVisibleBounds().end(); itr++) { for(std::map<KRAABB, int>::iterator itr=m_viewport.getVisibleBounds().begin(); itr != m_viewport.getVisibleBounds().end(); itr++) {
KRMat4 matModel = KRMat4(); KRMat4 matModel = KRMat4();
matModel.scale((*itr).first.size() / 2.0f); matModel.scale((*itr).first.size() / 2.0f);
@@ -683,7 +683,7 @@ void KRCamera::renderPost()
} }
// Update attribute values. // Update attribute values.
m_pContext->getModelManager()->bindVBO((void *)KRENGINE_VBO_2D_SQUARE, KRENGINE_VBO_2D_SQUARE_SIZE, true, false, false, true, false); m_pContext->getModelManager()->bindVBO((void *)KRENGINE_VBO_2D_SQUARE, KRENGINE_VBO_2D_SQUARE_SIZE, true, false, false, true, false, false, false);
GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)); GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
@@ -755,9 +755,9 @@ void KRCamera::renderPost()
#if GL_OES_vertex_array_object #if GL_OES_vertex_array_object
GLDEBUG(glBindVertexArrayOES(0)); GLDEBUG(glBindVertexArrayOES(0));
#endif #endif
m_pContext->getModelManager()->configureAttribs(true, false, false, true, false); m_pContext->getModelManager()->configureAttribs(true, false, false, true, false, false, false);
GLDEBUG(glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TEXUVA, 2, GL_FLOAT, 0, 0, charTexCoords)); GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_TEXUVA, 2, GL_FLOAT, 0, 0, charTexCoords));
GLDEBUG(glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_VERTEX, 2, GL_FLOAT, 0, 0, charVertices)); GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_VERTEX, 2, GL_FLOAT, 0, 0, charVertices));
GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)); GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
iPos++; iPos++;

2
KREngine/KREngine/Classes/KRDirectionalLight.cpp
View File

@@ -135,7 +135,7 @@ void KRDirectionalLight::render(KRCamera *pCamera, std::vector<KRLight *> &light
GLDEBUG(glDisable(GL_DEPTH_TEST)); GLDEBUG(glDisable(GL_DEPTH_TEST));
// Render a full screen quad // Render a full screen quad
m_pContext->getModelManager()->bindVBO((void *)KRENGINE_VBO_2D_SQUARE, KRENGINE_VBO_2D_SQUARE_SIZE, true, false, false, true, false); m_pContext->getModelManager()->bindVBO((void *)KRENGINE_VBO_2D_SQUARE, KRENGINE_VBO_2D_SQUARE_SIZE, true, false, false, true, false, false, false);
GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)); GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
} }
} }

6
KREngine/KREngine/Classes/KRLight.cpp
View File

@@ -201,7 +201,7 @@ void KRLight::render(KRCamera *pCamera, std::vector<KRLight *> &lights, const KR
GLDEBUG(glUniform1f(pParticleShader->m_uniforms[KRShader::KRENGINE_UNIFORM_FLARE_SIZE], m_dust_particle_size)); GLDEBUG(glUniform1f(pParticleShader->m_uniforms[KRShader::KRENGINE_UNIFORM_FLARE_SIZE], m_dust_particle_size));
m_pContext->getModelManager()->bindVBO((void *)m_pContext->getModelManager()->getRandomParticles(), KRModelManager::KRENGINE_MAX_RANDOM_PARTICLES * 3 * sizeof(KRModelManager::RandomParticleVertexData), true, false, false, true, false); m_pContext->getModelManager()->bindVBO((void *)m_pContext->getModelManager()->getRandomParticles(), KRModelManager::KRENGINE_MAX_RANDOM_PARTICLES * 3 * sizeof(KRModelManager::RandomParticleVertexData), true, false, false, true, false, false, false);
GLDEBUG(glDrawArrays(GL_TRIANGLES, 0, particle_count*3)); GLDEBUG(glDrawArrays(GL_TRIANGLES, 0, particle_count*3));
} }
} }
@@ -228,7 +228,7 @@ void KRLight::render(KRCamera *pCamera, std::vector<KRLight *> &lights, const KR
KRVector2(slice_near, slice_spacing).setUniform(pFogShader->m_uniforms[KRShader::KRENGINE_UNIFORM_SLICE_DEPTH_SCALE]); KRVector2(slice_near, slice_spacing).setUniform(pFogShader->m_uniforms[KRShader::KRENGINE_UNIFORM_SLICE_DEPTH_SCALE]);
(m_color * pCamera->volumetric_environment_intensity * m_intensity * -slice_spacing / 1000.0f).setUniform(pFogShader->m_uniforms[KRShader::KRENGINE_UNIFORM_LIGHT_COLOR]); (m_color * pCamera->volumetric_environment_intensity * m_intensity * -slice_spacing / 1000.0f).setUniform(pFogShader->m_uniforms[KRShader::KRENGINE_UNIFORM_LIGHT_COLOR]);
m_pContext->getModelManager()->bindVBO((void *)m_pContext->getModelManager()->getVolumetricLightingVertexes(), KRModelManager::KRENGINE_MAX_VOLUMETRIC_PLANES * 6 * sizeof(KRModelManager::VolumetricLightingVertexData), true, false, false, false, false); m_pContext->getModelManager()->bindVBO((void *)m_pContext->getModelManager()->getVolumetricLightingVertexes(), KRModelManager::KRENGINE_MAX_VOLUMETRIC_PLANES * 6 * sizeof(KRModelManager::VolumetricLightingVertexData), true, false, false, false, false, false, false);
GLDEBUG(glDrawArrays(GL_TRIANGLES, 0, slice_count*6)); GLDEBUG(glDrawArrays(GL_TRIANGLES, 0, slice_count*6));
} }
@@ -253,7 +253,7 @@ void KRLight::render(KRCamera *pCamera, std::vector<KRLight *> &lights, const KR
m_flareSize m_flareSize
)); ));
m_pContext->getTextureManager()->selectTexture(0, m_pFlareTexture); m_pContext->getTextureManager()->selectTexture(0, m_pFlareTexture);
m_pContext->getModelManager()->bindVBO((void *)KRENGINE_VBO_2D_SQUARE, KRENGINE_VBO_2D_SQUARE_SIZE, true, false, false, true, false); m_pContext->getModelManager()->bindVBO((void *)KRENGINE_VBO_2D_SQUARE, KRENGINE_VBO_2D_SQUARE_SIZE, true, false, false, true, false, false, false);
GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)); GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
} }
} }

318
KREngine/KREngine/Classes/KRModel.cpp
View File

@@ -104,7 +104,8 @@ void KRModel::loadPack(KRDataBlock *data) {
clearData(); clearData();
delete m_pData; delete m_pData;
m_pData = data; m_pData = data;
pack_header *pHeader = (pack_header *)m_pData->getStart(); updateAttributeOffsets();
pack_header *pHeader = getHeader();
m_minPoint = KRVector3(pHeader->minx, pHeader->miny, pHeader->minz); m_minPoint = KRVector3(pHeader->minx, pHeader->miny, pHeader->minz);
m_maxPoint = KRVector3(pHeader->maxx, pHeader->maxy, pHeader->maxz); m_maxPoint = KRVector3(pHeader->maxx, pHeader->maxy, pHeader->maxz);
} }
@@ -232,7 +233,7 @@ vector<KRModel::Submesh *> KRModel::getSubmeshes() {
} }
void KRModel::renderSubmesh(int iSubmesh) { void KRModel::renderSubmesh(int iSubmesh) {
VertexData *pVertexData = getVertexData(); unsigned char *pVertexData = getVertexData();
pack_header *pHeader = (pack_header *)m_pData->getStart(); pack_header *pHeader = (pack_header *)m_pData->getStart();
int cBuffers = (pHeader->vertex_count + MAX_VBO_SIZE - 1) / MAX_VBO_SIZE; int cBuffers = (pHeader->vertex_count + MAX_VBO_SIZE - 1) / MAX_VBO_SIZE;
@@ -246,7 +247,7 @@ void KRModel::renderSubmesh(int iSubmesh) {
int cVertexes = pSubmesh->vertex_count; int cVertexes = pSubmesh->vertex_count;
while(cVertexes > 0) { while(cVertexes > 0) {
GLsizei cBufferVertexes = iBuffer < cBuffers - 1 ? MAX_VBO_SIZE : pHeader->vertex_count % MAX_VBO_SIZE; GLsizei cBufferVertexes = iBuffer < cBuffers - 1 ? MAX_VBO_SIZE : pHeader->vertex_count % MAX_VBO_SIZE;
int vertex_size = sizeof(VertexData) ; int vertex_size = m_vertex_size;
assert(pVertexData + iBuffer * MAX_VBO_SIZE * vertex_size >= m_pData->getStart()); assert(pVertexData + iBuffer * MAX_VBO_SIZE * vertex_size >= m_pData->getStart());
void *vbo_end = (unsigned char *)pVertexData + iBuffer * MAX_VBO_SIZE * vertex_size + vertex_size * cBufferVertexes; void *vbo_end = (unsigned char *)pVertexData + iBuffer * MAX_VBO_SIZE * vertex_size + vertex_size * cBufferVertexes;
@@ -254,7 +255,9 @@ void KRModel::renderSubmesh(int iSubmesh) {
assert(vbo_end <= buffer_end); assert(vbo_end <= buffer_end);
assert(cBufferVertexes <= 65535); assert(cBufferVertexes <= 65535);
m_pContext->getModelManager()->bindVBO((unsigned char *)pVertexData + iBuffer * MAX_VBO_SIZE * vertex_size, vertex_size * cBufferVertexes, true, true, true, true, true);
m_pContext->getModelManager()->bindVBO((unsigned char *)pVertexData + iBuffer * MAX_VBO_SIZE * vertex_size, vertex_size * cBufferVertexes, has_vertex_attribute(KRENGINE_ATTRIB_VERTEX), has_vertex_attribute(KRENGINE_ATTRIB_NORMAL), has_vertex_attribute(KRENGINE_ATTRIB_TANGENT), has_vertex_attribute(KRENGINE_ATTRIB_TEXUVA), has_vertex_attribute(KRENGINE_ATTRIB_TEXUVB), has_vertex_attribute(KRENGINE_ATTRIB_BONEINDEXES),
has_vertex_attribute(KRENGINE_ATTRIB_BONEWEIGHTS));
if(iVertex + cVertexes >= MAX_VBO_SIZE) { if(iVertex + cVertexes >= MAX_VBO_SIZE) {
@@ -274,27 +277,51 @@ void KRModel::renderSubmesh(int iSubmesh) {
} }
} }
KRModel::VertexData *KRModel::getVertexData() { unsigned char *KRModel::getVertexData() const {
pack_header *pHeader = (pack_header *)m_pData->getStart(); pack_header *pHeader = (pack_header *)m_pData->getStart();
pack_material *pPackMaterials = (pack_material *)(pHeader+1); pack_material *pPackMaterials = (pack_material *)(pHeader+1);
return (VertexData *)(pPackMaterials + pHeader->submesh_count); return (unsigned char *)(pPackMaterials + pHeader->submesh_count);
} }
void KRModel::LoadData(std::vector<KRVector3> vertices, std::vector<KRVector2> uva, std::vector<KRVector2> uvb, std::vector<KRVector3> normals, std::vector<KRVector3> tangents, std::vector<int> submesh_starts, std::vector<int> submesh_lengths, std::vector<std::string> material_names) { void KRModel::LoadData(std::vector<KRVector3> vertices, std::vector<KRVector2> uva, std::vector<KRVector2> uvb, std::vector<KRVector3> normals, std::vector<KRVector3> tangents, std::vector<int> submesh_starts, std::vector<int> submesh_lengths, std::vector<std::string> material_names) {
clearData(); clearData();
bool calculate_normals = true;
bool calculate_tangents = true;
__int32_t vertex_attrib_flags = 0;
if(vertices.size()) {
vertex_attrib_flags |= (1 << KRENGINE_ATTRIB_VERTEX);
}
if(normals.size() || calculate_normals) {
vertex_attrib_flags += (1 << KRENGINE_ATTRIB_NORMAL);
}
if(tangents.size() || calculate_tangents) {
vertex_attrib_flags += (1 << KRENGINE_ATTRIB_TANGENT);
}
if(uva.size()) {
vertex_attrib_flags += (1 << KRENGINE_ATTRIB_TEXUVA);
}
if(uvb.size()) {
vertex_attrib_flags += (1 << KRENGINE_ATTRIB_TEXUVB);
}
size_t vertex_size = VertexSizeForAttributes(vertex_attrib_flags);
int submesh_count = submesh_lengths.size(); int submesh_count = submesh_lengths.size();
int vertex_count = vertices.size(); int vertex_count = vertices.size();
size_t new_file_size = sizeof(pack_header) + sizeof(pack_material) * submesh_count + sizeof(VertexData) * vertex_count; size_t new_file_size = sizeof(pack_header) + sizeof(pack_material) * submesh_count + vertex_size * vertex_count;
m_pData->expand(new_file_size); m_pData->expand(new_file_size);
pack_header *pHeader = (pack_header *)m_pData->getStart(); pack_header *pHeader = (pack_header *)m_pData->getStart();
memset(pHeader, 0, sizeof(pack_header)); memset(pHeader, 0, sizeof(pack_header));
pHeader->vertex_attrib_flags = vertex_attrib_flags;
pHeader->submesh_count = submesh_lengths.size(); pHeader->submesh_count = submesh_lengths.size();
pHeader->vertex_count = vertices.size(); pHeader->vertex_count = vertices.size();
strcpy(pHeader->szTag, "KROBJPACK1.0 "); strcpy(pHeader->szTag, "KROBJPACK1.1 ");
updateAttributeOffsets();
pack_material *pPackMaterials = (pack_material *)(pHeader+1); pack_material *pPackMaterials = (pack_material *)(pHeader+1);
@@ -307,14 +334,12 @@ void KRModel::LoadData(std::vector<KRVector3> vertices, std::vector<KRVector2> u
bool bFirstVertex = true; bool bFirstVertex = true;
VertexData *pVertexData = (VertexData *)(pPackMaterials + pHeader->submesh_count); // VertexData *pVertexData = (VertexData *)(pPackMaterials + pHeader->submesh_count);
VertexData *pVertex = pVertexData; // VertexData *pVertex = pVertexData;
memset(getVertexData(), 0, m_vertex_size * vertices.size());
for(int iVertex=0; iVertex < vertices.size(); iVertex++) { for(int iVertex=0; iVertex < vertices.size(); iVertex++) {
memset(pVertex, 0, sizeof(VertexData));
KRVector3 source_vertex = vertices[iVertex]; KRVector3 source_vertex = vertices[iVertex];
pVertex->vertex.x = source_vertex.x; setVertexPosition(iVertex, source_vertex);
pVertex->vertex.y = source_vertex.y;
pVertex->vertex.z = source_vertex.z;
if(bFirstVertex) { if(bFirstVertex) {
bFirstVertex = false; bFirstVertex = false;
m_minPoint = source_vertex; m_minPoint = source_vertex;
@@ -328,43 +353,25 @@ void KRModel::LoadData(std::vector<KRVector3> vertices, std::vector<KRVector2> u
if(source_vertex.z > m_maxPoint.z) m_maxPoint.z = source_vertex.z; if(source_vertex.z > m_maxPoint.z) m_maxPoint.z = source_vertex.z;
} }
if(uva.size() > iVertex) { if(uva.size() > iVertex) {
KRVector2 source_uva = uva[iVertex]; setVertexUVA(iVertex, uva[iVertex]);
pVertex->uva.u = source_uva.x;
pVertex->uva.v = source_uva.y;
} else { } else {
pVertex->uva.u = 0.0; setVertexUVA(iVertex, KRVector2::Zero());
pVertex->uva.v = 0.0;
} }
if(uvb.size() > iVertex) { if(uvb.size() > iVertex) {
KRVector2 source_uvb = uvb[iVertex]; setVertexUVB(iVertex, uvb[iVertex]);
pVertex->uvb.u = source_uvb.x;
pVertex->uvb.v = source_uvb.y;
} else { } else {
pVertex->uvb.u = 0.0; setVertexUVB(iVertex, KRVector2::Zero());
pVertex->uvb.v = 0.0;
} }
if(normals.size() > iVertex) { if(normals.size() > iVertex) {
KRVector3 source_normal = normals[iVertex]; setVertexNormal(iVertex, normals[iVertex]);
pVertex->normal.x = source_normal.x;
pVertex->normal.y = source_normal.y;
pVertex->normal.z = source_normal.z;
} else { } else {
pVertex->normal.x = 0.0f; setVertexNormal(iVertex, KRVector3::Zero());
pVertex->normal.y = 0.0f;
pVertex->normal.z = 0.0f;
} }
if(tangents.size() > iVertex) { if(tangents.size() > iVertex) {
KRVector3 source_tangent = tangents[iVertex]; setVertexTangent(iVertex, tangents[iVertex]);
pVertex->tangent.x = source_tangent.x;
pVertex->tangent.y = source_tangent.y;
pVertex->tangent.z = source_tangent.z;
} else { } else {
pVertex->tangent.x = 0.0f; setVertexTangent(iVertex, KRVector3::Zero());
pVertex->tangent.y = 0.0f;
pVertex->tangent.z = 0.0f;
} }
pVertex++;
} }
pHeader->minx = m_minPoint.x; pHeader->minx = m_minPoint.x;
@@ -377,67 +384,53 @@ void KRModel::LoadData(std::vector<KRVector3> vertices, std::vector<KRVector2> u
// Calculate missing surface normals and tangents // Calculate missing surface normals and tangents
//cout << " Calculate surface normals and tangents\n"; //cout << " Calculate surface normals and tangents\n";
VertexData *pStart = pVertexData;
VertexData *pEnd = pStart + vertex_count;
for(VertexData *pVertex = pStart; pVertex < pEnd; pVertex+=3) { for(int iVertex=0; iVertex < vertices.size(); iVertex+= 3) {
KRVector3 p1(pVertex[0].vertex.x, pVertex[0].vertex.y, pVertex[0].vertex.z); KRVector3 p1 = getVertexPosition(iVertex);
KRVector3 p2(pVertex[1].vertex.x, pVertex[1].vertex.y, pVertex[1].vertex.z); KRVector3 p2 = getVertexPosition(iVertex+1);
KRVector3 p3(pVertex[2].vertex.x, pVertex[2].vertex.y, pVertex[2].vertex.z); KRVector3 p3 = getVertexPosition(iVertex+2);
KRVector3 v1 = p2 - p1; KRVector3 v1 = p2 - p1;
KRVector3 v2 = p3 - p1; KRVector3 v2 = p3 - p1;
// -- Calculate normal --
if(pVertex->normal.x == 0 && pVertex->normal.y == 0 && pVertex->normal.z == 0) {
// -- Calculate normal if missing --
if(calculate_normals) {
KRVector3 first_normal = getVertexNormal(iVertex);
if(first_normal.x == 0.0f && first_normal.y == 0.0f && first_normal.z == 0.0f) {
// Note - We don't take into consideration smoothing groups or smoothing angles when generating normals; all generated normals represent flat shaded polygons
KRVector3 normal = KRVector3::Cross(v1, v2); KRVector3 normal = KRVector3::Cross(v1, v2);
normal.normalize(); normal.normalize();
setVertexNormal(iVertex, normal);
pVertex[0].normal.x = normal.x; setVertexNormal(iVertex+1, normal);
pVertex[0].normal.y = normal.y; setVertexNormal(iVertex+2, normal);
pVertex[0].normal.z = normal.z; }
pVertex[1].normal.x = normal.x;
pVertex[1].normal.y = normal.y;
pVertex[1].normal.z = normal.z;
pVertex[2].normal.x = normal.x;
pVertex[2].normal.y = normal.y;
pVertex[2].normal.z = normal.z;
} }
// -- Calculate tangent vector for normal mapping -- // -- Calculate tangent vector for normal mapping --
if(pVertex->tangent.x == 0 && pVertex->tangent.y == 0 && pVertex->tangent.z == 0) { if(calculate_tangents) {
TexCoord st1; // = pVertex[2].texcoord; KRVector3 first_tangent = getVertexTangent(iVertex);
TexCoord st2; // = pVertex[1].texcoord; if(first_tangent.x == 0.0f && first_tangent.y == 0.0f && first_tangent.z == 0.0f) {
st1.u = pVertex[1].uva.u - pVertex[0].uva.u;
st1.v = pVertex[1].uva.v - pVertex[0].uva.v;
st2.u = pVertex[2].uva.u - pVertex[0].uva.u;
st2.v = pVertex[2].uva.v - pVertex[0].uva.v;
double coef = 1/ (st1.u * st2.v - st2.u * st1.v);
pVertex[0].tangent.x = coef * ((v1.x * st2.v) + (v2.x * -st1.v)); KRVector2 uv0 = getVertexUVA(iVertex);
pVertex[0].tangent.y = coef * ((v1.y * st2.v) + (v2.y * -st1.v)); KRVector2 uv1 = getVertexUVA(iVertex + 1);
pVertex[0].tangent.z = coef * ((v1.z * st2.v) + (v2.z * -st1.v)); KRVector2 uv2 = getVertexUVA(iVertex + 2);
KRVector2 st1 = KRVector2(uv1.x - uv0.x, uv1.y - uv0.y);
KRVector2 st2 = KRVector2(uv2.x - uv0.x, uv2.y - uv0.y);
double coef = 1/ (st1.x * st2.y - st2.x * st1.y);
KRVector3 tangent( KRVector3 tangent(
coef * ((v1.x * st2.v) + (v2.x * -st1.v)), coef * ((v1.x * st2.y) + (v2.x * -st1.y)),
coef * ((v1.y * st2.v) + (v2.y * -st1.v)), coef * ((v1.y * st2.y) + (v2.y * -st1.y)),
coef * ((v1.z * st2.v) + (v2.z * -st1.v)) coef * ((v1.z * st2.y) + (v2.z * -st1.y))
); );
tangent.normalize(); tangent.normalize();
setVertexTangent(iVertex, tangent);
pVertex[0].tangent.x = tangent.x; setVertexTangent(iVertex+1, tangent);
pVertex[0].tangent.y = tangent.y; setVertexTangent(iVertex+2, tangent);
pVertex[0].tangent.z = tangent.z; }
pVertex[1].tangent.x = tangent.x;
pVertex[1].tangent.y = tangent.y;
pVertex[1].tangent.z = tangent.z;
pVertex[2].tangent.x = tangent.x;
pVertex[2].tangent.y = tangent.y;
pVertex[2].tangent.z = tangent.z;
} }
} }
} }
@@ -472,3 +465,158 @@ bool KRModel::lod_sort_predicate(const KRModel *m1, const KRModel *m2)
return m1->m_lodCoverage > m2->m_lodCoverage; return m1->m_lodCoverage > m2->m_lodCoverage;
} }
bool KRModel::has_vertex_attribute(vertex_attrib_t attribute_type) const
{
return (getHeader()->vertex_attrib_flags & (1 << attribute_type)) != 0;
}
KRModel::pack_header *KRModel::getHeader() const
{
return (pack_header *)m_pData->getStart();
}
KRModel::pack_material *KRModel::getSubmesh(int mesh_index)
{
return (pack_material *)(getHeader()+1) + mesh_index;
}
unsigned char *KRModel::getVertexData(int index) const
{
return getVertexData() + m_vertex_size * index;
}
int KRModel::getSubmeshCount()
{
pack_header *header = (pack_header *)m_pData->getStart();
return header->submesh_count;
}
int KRModel::getVertexCount(int submesh)
{
return getSubmesh(submesh)->vertex_count;
}
KRVector3 KRModel::getVertexPosition(int index) const
{
if(has_vertex_attribute(KRENGINE_ATTRIB_VERTEX)) {
return KRVector3((float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_VERTEX]));
} else {
return KRVector3::Zero();
}
}
KRVector3 KRModel::getVertexNormal(int index) const
{
if(has_vertex_attribute(KRENGINE_ATTRIB_NORMAL)) {
return KRVector3((float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_NORMAL]));
} else {
return KRVector3::Zero();
}
}
KRVector3 KRModel::getVertexTangent(int index) const
{
if(has_vertex_attribute(KRENGINE_ATTRIB_TANGENT)) {
return KRVector3((float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_TANGENT]));
} else {
return KRVector3::Zero();
}
}
KRVector2 KRModel::getVertexUVA(int index) const
{
if(has_vertex_attribute(KRENGINE_ATTRIB_TEXUVA)) {
return KRVector2((float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_TEXUVA]));
} else {
return KRVector2::Zero();
}
}
KRVector2 KRModel::getVertexUVB(int index) const
{
if(has_vertex_attribute(KRENGINE_ATTRIB_TEXUVB)) {
return KRVector2((float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_TEXUVB]));
} else {
return KRVector2::Zero();
}
}
void KRModel::setVertexPosition(int index, const KRVector3 &v)
{
float *vert = (float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_VERTEX]);
vert[0] = v.x;
vert[1] = v.y;
vert[2] = v.z;
}
void KRModel::setVertexNormal(int index, const KRVector3 &v)
{
float *vert = (float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_NORMAL]);
vert[0] = v.x;
vert[1] = v.y;
vert[2] = v.z;
}
void KRModel::setVertexTangent(int index, const KRVector3 & v)
{
float *vert = (float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_TANGENT]);
vert[0] = v.x;
vert[1] = v.y;
vert[2] = v.z;
}
void KRModel::setVertexUVA(int index, const KRVector2 &v)
{
float *vert = (float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_TEXUVA]);
vert[0] = v.x;
vert[1] = v.y;
}
void KRModel::setVertexUVB(int index, const KRVector2 &v)
{
float *vert = (float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_TEXUVB]);
vert[0] = v.x;
vert[1] = v.y;
}
size_t KRModel::VertexSizeForAttributes(__int32_t vertex_attrib_flags)
{
size_t data_size = 0;
if(vertex_attrib_flags & (1 << KRENGINE_ATTRIB_VERTEX)) {
data_size += sizeof(float) * 3;
}
if(vertex_attrib_flags & (1 << KRENGINE_ATTRIB_NORMAL)) {
data_size += sizeof(float) * 3;
}
if(vertex_attrib_flags & (1 << KRENGINE_ATTRIB_TANGENT)) {
data_size += sizeof(float) * 3;
}
if(vertex_attrib_flags & (1 << KRENGINE_ATTRIB_TEXUVA)) {
data_size += sizeof(float) * 2;
}
if(vertex_attrib_flags & (1 << KRENGINE_ATTRIB_TEXUVB)) {
data_size += sizeof(float) * 2;
}
if(vertex_attrib_flags & (1 << KRENGINE_ATTRIB_BONEINDEXES)) {
data_size += 4; // 4 bytes
}
if(vertex_attrib_flags & (1 << KRENGINE_ATTRIB_BONEWEIGHTS)) {
data_size += sizeof(float) * 4;
}
return data_size;
}
void KRModel::updateAttributeOffsets()
{
pack_header *header = getHeader();
int mask = 0;
for(int i=0; i < KRENGINE_NUM_ATTRIBUTES; i++) {
if(has_vertex_attribute((vertex_attrib_t)i)) {
m_vertex_attribute_offset[i] = VertexSizeForAttributes(header->vertex_attrib_flags & mask);
} else {
m_vertex_attribute_offset[i] = -1;
}
mask = (mask << 1) & 1;
}
m_vertex_size = VertexSizeForAttributes(header->vertex_attrib_flags);
}

48
KREngine/KREngine/Classes/KRModel.h
View File

@@ -89,6 +89,22 @@ public:
KRVector3 getMinPoint() const; KRVector3 getMinPoint() const;
KRVector3 getMaxPoint() const; KRVector3 getMaxPoint() const;
typedef enum {
KRENGINE_ATTRIB_VERTEX = 0,
KRENGINE_ATTRIB_NORMAL,
KRENGINE_ATTRIB_TANGENT,
KRENGINE_ATTRIB_TEXUVA,
KRENGINE_ATTRIB_TEXUVB,
KRENGINE_ATTRIB_BONEINDEXES,
KRENGINE_ATTRIB_BONEWEIGHTS,
KRENGINE_NUM_ATTRIBUTES
} vertex_attrib_t;
typedef enum {
KRENGINE_MODEL_FORMAT_TRIANGLES = 1,
KRENGINE_MODEL_FORMAT_INDEXED
} model_format_t;
typedef struct { typedef struct {
GLint start_vertex; GLint start_vertex;
GLsizei vertex_count; GLsizei vertex_count;
@@ -114,8 +130,6 @@ public:
TexCoord uvb; TexCoord uvb;
} VertexData; } VertexData;
VertexData *getVertexData();
vector<Submesh *> getSubmeshes(); vector<Submesh *> getSubmeshes();
typedef struct { typedef struct {
@@ -129,6 +143,20 @@ public:
static bool lod_sort_predicate(const KRModel *m1, const KRModel *m2); static bool lod_sort_predicate(const KRModel *m1, const KRModel *m2);
bool has_vertex_attribute(vertex_attrib_t attribute_type) const;
int getSubmeshCount();
int getVertexCount(int submesh);
KRVector3 getVertexPosition(int index) const;
KRVector3 getVertexNormal(int index) const;
KRVector3 getVertexTangent(int index) const;
KRVector2 getVertexUVA(int index) const;
KRVector2 getVertexUVB(int index) const;
void setVertexPosition(int index, const KRVector3 &v);
void setVertexNormal(int index, const KRVector3 &v);
void setVertexTangent(int index, const KRVector3 & v);
void setVertexUVA(int index, const KRVector2 &v);
void setVertexUVB(int index, const KRVector2 &v);
private: private:
int m_lodCoverage; // This LOD level is activated when the bounding box of the model will cover less than this percent of the screen (100 = highest detail model) int m_lodCoverage; // This LOD level is activated when the bounding box of the model will cover less than this percent of the screen (100 = highest detail model)
@@ -144,18 +172,32 @@ private:
typedef struct { typedef struct {
char szTag[16]; char szTag[16];
float minx, miny, minz, maxx, maxy, maxz; int32_t format_type; // 0 == Triangle list, 1 == Indexed list, rest are reserved (model_format_t enum)
int32_t vertex_attrib_flags;
int32_t vertex_count; int32_t vertex_count;
int32_t submesh_count; int32_t submesh_count;
float minx, miny, minz, maxx, maxy, maxz; // Axis aligned bounding box, in model's coordinate space
unsigned char reserved[412]; // Pad out to 512 bytes
} pack_header; } pack_header;
vector<Submesh *> m_submeshes; vector<Submesh *> m_submeshes;
int m_vertex_attribute_offset[KRENGINE_NUM_ATTRIBUTES];
int m_vertex_size;
void updateAttributeOffsets();
void clearData(); void clearData();
void clearBuffers(); void clearBuffers();
void setName(const std::string name); void setName(const std::string name);
static size_t VertexSizeForAttributes(__int32_t vertex_attrib_flags);
pack_material *getSubmesh(int mesh_index);
unsigned char *getVertexData() const;
unsigned char *getVertexData(int index) const;
pack_header *getHeader() const;
}; };

76
KREngine/KREngine/Classes/KRModelManager.cpp
View File

@@ -101,7 +101,7 @@ void KRModelManager::unbindVBO() {
} }
} }
void KRModelManager::bindVBO(GLvoid *data, GLsizeiptr size, bool enable_vertex, bool enable_normal, bool enable_tangent, bool enable_uva, bool enable_uvb) { void KRModelManager::bindVBO(GLvoid *data, GLsizeiptr size, bool enable_vertex, bool enable_normal, bool enable_tangent, bool enable_uva, bool enable_uvb, bool enable_bone_indexes, bool enable_bone_weights) {
if(m_currentVBO.data != data || m_currentVBO.size != size) { if(m_currentVBO.data != data || m_currentVBO.size != size) {
@@ -111,7 +111,7 @@ void KRModelManager::bindVBO(GLvoid *data, GLsizeiptr size, bool enable_vertex,
GLDEBUG(glBindVertexArrayOES(m_currentVBO.vao_handle)); GLDEBUG(glBindVertexArrayOES(m_currentVBO.vao_handle));
#else #else
GLDEBUG(glBindBuffer(GL_ARRAY_BUFFER, m_currentVBO.vbo_handle)); GLDEBUG(glBindBuffer(GL_ARRAY_BUFFER, m_currentVBO.vbo_handle));
configureAttribs(enable_vertex, enable_normal, enable_tangent, enable_uva, enable_uvb); configureAttribs(enable_vertex, enable_normal, enable_tangent, enable_uva, enable_uvb, enable_bone_indexes, enable_bone_weights);
#endif #endif
} else if(m_vbosPool.find(data) != m_vbosPool.end()) { } else if(m_vbosPool.find(data) != m_vbosPool.end()) {
m_currentVBO = m_vbosPool[data]; m_currentVBO = m_vbosPool[data];
@@ -121,7 +121,7 @@ void KRModelManager::bindVBO(GLvoid *data, GLsizeiptr size, bool enable_vertex,
GLDEBUG(glBindVertexArrayOES(m_currentVBO.vao_handle)); GLDEBUG(glBindVertexArrayOES(m_currentVBO.vao_handle));
#else #else
GLDEBUG(glBindBuffer(GL_ARRAY_BUFFER, m_currentVBO.vbo_handle)); GLDEBUG(glBindBuffer(GL_ARRAY_BUFFER, m_currentVBO.vbo_handle));
configureAttribs(enable_vertex, enable_normal, enable_tangent, enable_uva, enable_uvb); configureAttribs(enable_vertex, enable_normal, enable_tangent, enable_uva, enable_uvb, enable_bone_indexes, enable_bone_weights);
#endif #endif
} else { } else {
@@ -153,7 +153,7 @@ void KRModelManager::bindVBO(GLvoid *data, GLsizeiptr size, bool enable_vertex,
GLDEBUG(glBindBuffer(GL_ARRAY_BUFFER, m_currentVBO.vbo_handle)); GLDEBUG(glBindBuffer(GL_ARRAY_BUFFER, m_currentVBO.vbo_handle));
GLDEBUG(glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW)); GLDEBUG(glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW));
m_vboMemUsed += size; m_vboMemUsed += size;
configureAttribs(enable_vertex, enable_normal, enable_tangent, enable_uva, enable_uvb); configureAttribs(enable_vertex, enable_normal, enable_tangent, enable_uva, enable_uvb, enable_bone_indexes, enable_bone_weights);
m_currentVBO.size = size; m_currentVBO.size = size;
m_currentVBO.data = data; m_currentVBO.data = data;
@@ -163,76 +163,102 @@ void KRModelManager::bindVBO(GLvoid *data, GLsizeiptr size, bool enable_vertex,
} }
} }
void KRModelManager::configureAttribs(bool enable_vertex, bool enable_normal, bool enable_tangent, bool enable_uva, bool enable_uvb) void KRModelManager::configureAttribs(bool enable_vertex, bool enable_normal, bool enable_tangent, bool enable_uva, bool enable_uvb, bool enable_bone_indexes, bool enable_bone_weights)
{ {
if(enable_vertex) { if(enable_vertex) {
GLDEBUG(glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_VERTEX)); GLDEBUG(glEnableVertexAttribArray(KRModel::KRENGINE_ATTRIB_VERTEX));
} else { } else {
GLDEBUG(glDisableVertexAttribArray(KRShader::KRENGINE_ATTRIB_VERTEX)); GLDEBUG(glDisableVertexAttribArray(KRModel::KRENGINE_ATTRIB_VERTEX));
} }
if(enable_normal) { if(enable_normal) {
GLDEBUG(glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_NORMAL)); GLDEBUG(glEnableVertexAttribArray(KRModel::KRENGINE_ATTRIB_NORMAL));
} else { } else {
GLDEBUG(glDisableVertexAttribArray(KRShader::KRENGINE_ATTRIB_NORMAL)); GLDEBUG(glDisableVertexAttribArray(KRModel::KRENGINE_ATTRIB_NORMAL));
} }
if(enable_tangent) { if(enable_tangent) {
GLDEBUG(glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TANGENT)); GLDEBUG(glEnableVertexAttribArray(KRModel::KRENGINE_ATTRIB_TANGENT));
} else { } else {
GLDEBUG(glDisableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TANGENT)); GLDEBUG(glDisableVertexAttribArray(KRModel::KRENGINE_ATTRIB_TANGENT));
} }
if(enable_uva) { if(enable_uva) {
GLDEBUG(glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TEXUVA)); GLDEBUG(glEnableVertexAttribArray(KRModel::KRENGINE_ATTRIB_TEXUVA));
} else { } else {
GLDEBUG(glDisableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TEXUVA)); GLDEBUG(glDisableVertexAttribArray(KRModel::KRENGINE_ATTRIB_TEXUVA));
} }
if(enable_uvb) { if(enable_uvb) {
GLDEBUG(glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TEXUVB)); GLDEBUG(glEnableVertexAttribArray(KRModel::KRENGINE_ATTRIB_TEXUVB));
} else { } else {
GLDEBUG(glDisableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TEXUVB)); GLDEBUG(glDisableVertexAttribArray(KRModel::KRENGINE_ATTRIB_TEXUVB));
}
if(enable_bone_indexes) {
GLDEBUG(glEnableVertexAttribArray(KRModel::KRENGINE_ATTRIB_BONEINDEXES));
} else {
GLDEBUG(glDisableVertexAttribArray(KRModel::KRENGINE_ATTRIB_BONEINDEXES));
}
if(enable_bone_weights) {
GLDEBUG(glEnableVertexAttribArray(KRModel::KRENGINE_ATTRIB_BONEWEIGHTS));
} else {
GLDEBUG(glDisableVertexAttribArray(KRModel::KRENGINE_ATTRIB_BONEWEIGHTS));
} }
int data_size = 0; int data_size = 0;
if(enable_vertex) { if(enable_vertex) {
data_size += sizeof(KRModel::KRVector3D); data_size += sizeof(GLfloat) * 3;
} }
if(enable_normal) { if(enable_normal) {
data_size += sizeof(KRModel::KRVector3D); data_size += sizeof(GLfloat) * 3;
} }
if(enable_tangent) { if(enable_tangent) {
data_size += sizeof(KRModel::KRVector3D); data_size += sizeof(GLfloat) * 3;
} }
if(enable_uva) { if(enable_uva) {
data_size += sizeof(KRModel::TexCoord); data_size += sizeof(GLfloat) * 2;
} }
if(enable_uvb) { if(enable_uvb) {
data_size += sizeof(KRModel::TexCoord); data_size += sizeof(GLfloat) * 2;
}
if(enable_bone_indexes ) {
data_size += 4; // 4 bytes
}
if(enable_bone_weights) {
data_size += sizeof(GLfloat) * 4;
} }
int offset = 0; int offset = 0;
if(enable_vertex) { if(enable_vertex) {
GLDEBUG(glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_VERTEX, 3, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset))); GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_VERTEX, 3, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset)));
offset += sizeof(KRModel::KRVector3D); offset += sizeof(KRModel::KRVector3D);
} }
if(enable_normal) { if(enable_normal) {
GLDEBUG(glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_NORMAL, 3, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset))); GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_NORMAL, 3, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset)));
offset += sizeof(KRModel::KRVector3D); offset += sizeof(KRModel::KRVector3D);
} }
if(enable_tangent) { if(enable_tangent) {
GLDEBUG(glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TANGENT, 3, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset))); GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_TANGENT, 3, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset)));
offset += sizeof(KRModel::KRVector3D); offset += sizeof(KRModel::KRVector3D);
} }
if(enable_uva) { if(enable_uva) {
GLDEBUG(glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TEXUVA, 2, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset))); GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_TEXUVA, 2, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset)));
offset += sizeof(KRModel::TexCoord); offset += sizeof(KRModel::TexCoord);
} }
if(enable_uvb) { if(enable_uvb) {
GLDEBUG(glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TEXUVB, 2, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset))); GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_TEXUVB, 2, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset)));
offset += sizeof(KRModel::TexCoord); offset += sizeof(KRModel::TexCoord);
} }
if(enable_bone_indexes ) {
GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_BONEINDEXES, 1, GL_UNSIGNED_BYTE, 0, data_size, BUFFER_OFFSET(offset)));
offset += 4; // 4 bytes
}
if(enable_bone_weights) {
GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_BONEWEIGHTS, 4, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset)));
offset += sizeof(GLfloat) * 4;
}
} }
long KRModelManager::getMemUsed() long KRModelManager::getMemUsed()

4
KREngine/KREngine/Classes/KRModelManager.h
View File

@@ -60,11 +60,11 @@ public:
std::multimap<std::string, KRModel *> getModels(); std::multimap<std::string, KRModel *> getModels();
void bindVBO(GLvoid *data, GLsizeiptr size, bool enable_vertex, bool enable_normal, bool enable_tangent, bool enable_uva, bool enable_uvb); void bindVBO(GLvoid *data, GLsizeiptr size, bool enable_vertex, bool enable_normal, bool enable_tangent, bool enable_uva, bool enable_uvb, bool enable_bone_indexes, bool enable_bone_weights);
void unbindVBO(); void unbindVBO();
long getMemUsed(); long getMemUsed();
void configureAttribs(bool enable_vertex, bool enable_normal, bool enable_tangent, bool enable_uva, bool enable_uvb); void configureAttribs(bool enable_vertex, bool enable_normal, bool enable_tangent, bool enable_uva, bool enable_uvb, bool enable_bone_indexes, bool enable_bone_weights);
typedef struct { typedef struct {

2
KREngine/KREngine/Classes/KRParticleSystemNewtonian.cpp
View File

@@ -79,7 +79,7 @@ void KRParticleSystemNewtonian::render(KRCamera *pCamera, std::vector<KRLight *>
1.0f 1.0f
)); ));
m_pContext->getModelManager()->bindVBO((void *)m_pContext->getModelManager()->getRandomParticles(), particle_count * 3 * sizeof(KRModelManager::RandomParticleVertexData), true, false, false, true, false); m_pContext->getModelManager()->bindVBO((void *)m_pContext->getModelManager()->getRandomParticles(), particle_count * 3 * sizeof(KRModelManager::RandomParticleVertexData), true, false, false, true, false, false, false);
GLDEBUG(glDrawArrays(GL_TRIANGLES, 0, particle_count*3)); GLDEBUG(glDrawArrays(GL_TRIANGLES, 0, particle_count*3));
} }
} }

6
KREngine/KREngine/Classes/KRPointLight.cpp
View File

@@ -112,13 +112,13 @@ void KRPointLight::render(KRCamera *pCamera, std::vector<KRLight *> &lights, con
GLDEBUG(glDisable(GL_DEPTH_TEST)); GLDEBUG(glDisable(GL_DEPTH_TEST));
// Render a full screen quad // Render a full screen quad
m_pContext->getModelManager()->bindVBO((void *)KRENGINE_VBO_2D_SQUARE, KRENGINE_VBO_2D_SQUARE_SIZE, true, false, false, true, false); m_pContext->getModelManager()->bindVBO((void *)KRENGINE_VBO_2D_SQUARE, KRENGINE_VBO_2D_SQUARE_SIZE, true, false, false, true, false, false, false);
GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)); GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
} else { } else {
#if GL_OES_vertex_array_object #if GL_OES_vertex_array_object
GLDEBUG(glBindVertexArrayOES(0)); GLDEBUG(glBindVertexArrayOES(0));
#endif #endif
m_pContext->getModelManager()->configureAttribs(true, false, false, false, false); m_pContext->getModelManager()->configureAttribs(true, false, false, false, false, false, false);
// Render sphere of light's influence // Render sphere of light's influence
generateMesh(); generateMesh();
@@ -127,7 +127,7 @@ void KRPointLight::render(KRCamera *pCamera, std::vector<KRLight *> &lights, con
GLDEBUG(glDepthFunc(GL_LEQUAL)); GLDEBUG(glDepthFunc(GL_LEQUAL));
GLDEBUG(glDepthRangef(0.0, 1.0)); GLDEBUG(glDepthRangef(0.0, 1.0));
GLDEBUG(glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_VERTEX, 3, GL_FLOAT, 0, 0, m_sphereVertices)); GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_VERTEX, 3, GL_FLOAT, 0, 0, m_sphereVertices));
GLDEBUG(glDrawArrays(GL_TRIANGLES, 0, m_cVertices)); GLDEBUG(glDrawArrays(GL_TRIANGLES, 0, m_cVertices));
} }
} }

6
KREngine/KREngine/Classes/KRResource+fbx.cpp
View File

@@ -700,6 +700,12 @@ KRNode *LoadMesh(KRNode *parent_node, std::vector<KRResource *> &resources, FbxG
KFbxMesh* pSourceMesh = (KFbxMesh*) pNode->GetNodeAttribute(); KFbxMesh* pSourceMesh = (KFbxMesh*) pNode->GetNodeAttribute();
KFbxMesh* pMesh = pGeometryConverter->TriangulateMesh(pSourceMesh); KFbxMesh* pMesh = pGeometryConverter->TriangulateMesh(pSourceMesh);
int skin_count = pMesh->GetDeformerCount(FbxDeformer::eSkin);
for(int skin_index=0; skin_index<skin_count; skin_index++) {
FbxSkin *skin = (FbxSkin *)pMesh->GetDeformer(skin_index, FbxDeformer::eSkin);
skin->GetControlPointBlendWeights()
}
KFbxVector4* control_points = pMesh->GetControlPoints(); KFbxVector4* control_points = pMesh->GetControlPoints();
int polygon_count = pMesh->GetPolygonCount(); int polygon_count = pMesh->GetPolygonCount();

2
KREngine/KREngine/Classes/KRScene.cpp
View File

@@ -221,7 +221,7 @@ void KRScene::render(KROctreeNode *pOctreeNode, std::map<KRAABB, int> &visibleBo
KRMat4 mvpmatrix = matModel * viewport.getViewProjectionMatrix(); KRMat4 mvpmatrix = matModel * viewport.getViewProjectionMatrix();
getContext().getModelManager()->bindVBO((void *)KRENGINE_VBO_3D_CUBE, KRENGINE_VBO_3D_CUBE_SIZE, true, false, false, false, false); getContext().getModelManager()->bindVBO((void *)KRENGINE_VBO_3D_CUBE, KRENGINE_VBO_3D_CUBE_SIZE, true, false, false, false, false, false, false);
// Enable additive blending // Enable additive blending
if(renderPass != KRNode::RENDER_PASS_FORWARD_TRANSPARENT && renderPass != KRNode::RENDER_PASS_ADDITIVE_PARTICLES && renderPass != KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE) { if(renderPass != KRNode::RENDER_PASS_FORWARD_TRANSPARENT && renderPass != KRNode::RENDER_PASS_ADDITIVE_PARTICLES && renderPass != KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE) {

13
KREngine/KREngine/Classes/KRShader.cpp
View File

@@ -88,12 +88,13 @@ KRShader::KRShader(KRContext &context, char *szKey, std::string options, std::st
// Bind attribute locations. // Bind attribute locations.
// This needs to be done prior to linking. // This needs to be done prior to linking.
GLDEBUG(glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_VERTEX, "vertex_position")); GLDEBUG(glBindAttribLocation(m_iProgram, KRModel::KRENGINE_ATTRIB_VERTEX, "vertex_position"));
GLDEBUG(glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_NORMAL, "vertex_normal")); GLDEBUG(glBindAttribLocation(m_iProgram, KRModel::KRENGINE_ATTRIB_NORMAL, "vertex_normal"));
GLDEBUG(glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_TANGENT, "vertex_tangent")); GLDEBUG(glBindAttribLocation(m_iProgram, KRModel::KRENGINE_ATTRIB_TANGENT, "vertex_tangent"));
GLDEBUG(glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_TEXUVA, "vertex_uv")); GLDEBUG(glBindAttribLocation(m_iProgram, KRModel::KRENGINE_ATTRIB_TEXUVA, "vertex_uv"));
GLDEBUG(glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_TEXUVB, "vertex_lightmap_uv")); GLDEBUG(glBindAttribLocation(m_iProgram, KRModel::KRENGINE_ATTRIB_TEXUVB, "vertex_lightmap_uv"));
GLDEBUG(glBindAttribLocation(m_iProgram, KRModel::KRENGINE_ATTRIB_BONEINDEXES, "bone_indexes"));
GLDEBUG(glBindAttribLocation(m_iProgram, KRModel::KRENGINE_ATTRIB_BONEWEIGHTS, "bone_weights"));
// Link program. // Link program.
GLDEBUG(glLinkProgram(m_iProgram)); GLDEBUG(glLinkProgram(m_iProgram));

9
KREngine/KREngine/Classes/KRShader.h
View File

@@ -60,15 +60,6 @@ public:
#endif #endif
enum {
KRENGINE_ATTRIB_VERTEX,
KRENGINE_ATTRIB_NORMAL,
KRENGINE_ATTRIB_TANGENT,
KRENGINE_ATTRIB_TEXUVA,
KRENGINE_ATTRIB_TEXUVB,
KRENGINE_NUM_ATTRIBUTES
};
enum { enum {
KRENGINE_UNIFORM_MATERIAL_AMBIENT, KRENGINE_UNIFORM_MATERIAL_AMBIENT,
KRENGINE_UNIFORM_MATERIAL_DIFFUSE, KRENGINE_UNIFORM_MATERIAL_DIFFUSE,

5
KREngine/KREngine/Classes/KRVector2.cpp
View File

@@ -26,6 +26,11 @@ KRVector2::KRVector2(float v) {
y = v; y = v;
} }
KRVector2::KRVector2(float *v) {
x = v[0];
y = v[1];
}
KRVector2::KRVector2(const KRVector2 &v) { KRVector2::KRVector2(const KRVector2 &v) {
x = v.x; x = v.x;
y = v.y; y = v.y;

1
KREngine/KREngine/Classes/KRVector2.h
View File

@@ -42,6 +42,7 @@ public:
KRVector2(); KRVector2();
KRVector2(float X, float Y); KRVector2(float X, float Y);
KRVector2(float v); KRVector2(float v);
KRVector2(float *v);
KRVector2(const KRVector2 &v); KRVector2(const KRVector2 &v);
~KRVector2(); ~KRVector2();

6
KREngine/KREngine/Classes/KRVector3.cpp
View File

@@ -48,6 +48,12 @@ KRVector3::KRVector3(const KRVector3 &v) {
z = v.z; z = v.z;
} }
KRVector3::KRVector3(float *v) {
x = v[0];
y = v[1];
z = v[2];
}
KRVector3 KRVector3::Min() { KRVector3 KRVector3::Min() {
return KRVector3(-std::numeric_limits<float>::max()); return KRVector3(-std::numeric_limits<float>::max());
} }

1
KREngine/KREngine/Classes/KRVector3.h
View File

@@ -42,6 +42,7 @@ public:
KRVector3(); KRVector3();
KRVector3(float X, float Y, float Z); KRVector3(float X, float Y, float Z);
KRVector3(float v); KRVector3(float v);
KRVector3(float *v);
KRVector3(const KRVector3 &v); KRVector3(const KRVector3 &v);
~KRVector3(); ~KRVector3();