From fe7d4f8238f6f695a2f5b6dd2824038febb8adeb Mon Sep 17 00:00:00 2001 From: kearwood Date: Wed, 12 Dec 2012 22:15:09 +0000 Subject: [PATCH] Final KRObject file format for v1.1 --HG-- extra : convert_revision : svn%3A7752d6cf-9f14-4ad2-affc-04f1e67b81a5/trunk%40185 --- KREngine/KREngine/Classes/KRModel.cpp | 111 +++++++++++++------ KREngine/KREngine/Classes/KRModel.h | 29 +++-- KREngine/KREngine/Classes/KRModelManager.cpp | 56 +++------- KREngine/KREngine/Classes/KRResource+fbx.cpp | 28 +++-- KREngine/KREngine/Classes/KRResource+obj.cpp | 2 +- 5 files changed, 134 insertions(+), 92 deletions(-) diff --git a/KREngine/KREngine/Classes/KRModel.cpp b/KREngine/KREngine/Classes/KRModel.cpp index 0c0c62b..7e3f067 100644 --- a/KREngine/KREngine/Classes/KRModel.cpp +++ b/KREngine/KREngine/Classes/KRModel.cpp @@ -213,7 +213,7 @@ bool KRModel::hasTransparency() { vector KRModel::getSubmeshes() { if(m_submeshes.size() == 0) { - pack_header *pHeader = (pack_header *)m_pData->getStart(); + pack_header *pHeader = getHeader(); pack_material *pPackMaterials = (pack_material *)(pHeader+1); m_submeshes.clear(); for(int iMaterial=0; iMaterial < pHeader->submesh_count; iMaterial++) { @@ -223,8 +223,8 @@ vector KRModel::getSubmeshes() { pSubmesh->start_vertex = pPackMaterial->start_vertex; pSubmesh->vertex_count = pPackMaterial->vertex_count; - strncpy(pSubmesh->szMaterialName, pPackMaterial->szName, 256); - pSubmesh->szMaterialName[255] = '\0'; + strncpy(pSubmesh->szMaterialName, pPackMaterial->szName, KRENGINE_MAX_NAME_LENGTH); + pSubmesh->szMaterialName[KRENGINE_MAX_NAME_LENGTH-1] = '\0'; //fprintf(stderr, "Submesh material: \"%s\"\n", pSubmesh->szMaterialName); m_submeshes.push_back(pSubmesh); } @@ -235,7 +235,7 @@ vector KRModel::getSubmeshes() { void KRModel::renderSubmesh(int iSubmesh) { unsigned char *pVertexData = getVertexData(); - pack_header *pHeader = (pack_header *)m_pData->getStart(); + pack_header *pHeader = getHeader(); int cBuffers = (pHeader->vertex_count + MAX_VBO_SIZE - 1) / MAX_VBO_SIZE; vector submeshes = getSubmeshes(); @@ -248,7 +248,6 @@ void KRModel::renderSubmesh(int iSubmesh) { while(cVertexes > 0) { GLsizei cBufferVertexes = iBuffer < cBuffers - 1 ? MAX_VBO_SIZE : pHeader->vertex_count % MAX_VBO_SIZE; int vertex_size = m_vertex_size; - 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 *buffer_end = m_pData->getEnd(); @@ -277,14 +276,7 @@ void KRModel::renderSubmesh(int iSubmesh) { } } -unsigned char *KRModel::getVertexData() const { - pack_header *pHeader = (pack_header *)m_pData->getStart(); - pack_material *pPackMaterials = (pack_material *)(pHeader+1); - return (unsigned char *)(pPackMaterials + pHeader->submesh_count); -} - - -void KRModel::LoadData(std::vector vertices, std::vector uva, std::vector uvb, std::vector normals, std::vector tangents, std::vector submesh_starts, std::vector submesh_lengths, std::vector material_names, std::list bone_names, std::vector > bone_indexes, std::vector > bone_weights) { +void KRModel::LoadData(std::vector vertices, std::vector uva, std::vector uvb, std::vector normals, std::vector tangents, std::vector submesh_starts, std::vector submesh_lengths, std::vector material_names, std::vector bone_names, std::vector > bone_indexes, std::vector > bone_weights) { clearData(); @@ -308,18 +300,23 @@ void KRModel::LoadData(std::vector vertices, std::vector u if(uvb.size()) { vertex_attrib_flags += (1 << KRENGINE_ATTRIB_TEXUVB); } + if(bone_names.size()) { + vertex_attrib_flags += (1 << KRENGINE_ATTRIB_BONEINDEXES) + (1 << KRENGINE_ATTRIB_BONEWEIGHTS); + } size_t vertex_size = VertexSizeForAttributes(vertex_attrib_flags); - int submesh_count = submesh_lengths.size(); - int vertex_count = vertices.size(); - size_t new_file_size = sizeof(pack_header) + sizeof(pack_material) * submesh_count + vertex_size * vertex_count; + size_t submesh_count = submesh_lengths.size(); + size_t vertex_count = vertices.size(); + size_t bone_count = bone_names.size(); + size_t new_file_size = sizeof(pack_header) + sizeof(pack_material) * submesh_count + sizeof(pack_bone) * bone_count + vertex_size * vertex_count; m_pData->expand(new_file_size); - pack_header *pHeader = (pack_header *)m_pData->getStart(); + pack_header *pHeader = getHeader(); memset(pHeader, 0, sizeof(pack_header)); pHeader->vertex_attrib_flags = vertex_attrib_flags; - pHeader->submesh_count = submesh_lengths.size(); - pHeader->vertex_count = vertices.size(); + pHeader->submesh_count = (__int32_t)submesh_count; + pHeader->vertex_count = (__int32_t)vertex_count; + pHeader->bone_count = (__int32_t)bone_count; strcpy(pHeader->szTag, "KROBJPACK1.1 "); updateAttributeOffsets(); @@ -329,7 +326,14 @@ void KRModel::LoadData(std::vector vertices, std::vector u pack_material *pPackMaterial = pPackMaterials + iMaterial; pPackMaterial->start_vertex = submesh_starts[iMaterial]; pPackMaterial->vertex_count = submesh_lengths[iMaterial]; - strncpy(pPackMaterial->szName, material_names[iMaterial].c_str(), 256); + memset(pPackMaterial->szName, 0, KRENGINE_MAX_NAME_LENGTH); + strncpy(pPackMaterial->szName, material_names[iMaterial].c_str(), KRENGINE_MAX_NAME_LENGTH); + } + + for(int bone_index=0; bone_index < bone_count; bone_index++) { + pack_bone *bone = getBone(bone_index); + memset(bone->szName, 0, KRENGINE_MAX_NAME_LENGTH); + strncpy(bone->szName, bone_names[bone_index].c_str(), KRENGINE_MAX_NAME_LENGTH); } bool bFirstVertex = true; @@ -340,6 +344,12 @@ void KRModel::LoadData(std::vector vertices, std::vector u for(int iVertex=0; iVertex < vertices.size(); iVertex++) { KRVector3 source_vertex = vertices[iVertex]; setVertexPosition(iVertex, source_vertex); + if(bone_names.size()) { + for(int bone_weight_index=0; bone_weight_index vertices, std::vector u } if(uva.size() > iVertex) { setVertexUVA(iVertex, uva[iVertex]); - } else { - setVertexUVA(iVertex, KRVector2::Zero()); } if(uvb.size() > iVertex) { setVertexUVB(iVertex, uvb[iVertex]); - } else { - setVertexUVB(iVertex, KRVector2::Zero()); } if(normals.size() > iVertex) { setVertexNormal(iVertex, normals[iVertex]); - } else { - setVertexNormal(iVertex, KRVector3::Zero()); } if(tangents.size() > iVertex) { setVertexTangent(iVertex, tangents[iVertex]); - } else { - setVertexTangent(iVertex, KRVector3::Zero()); } } @@ -475,9 +477,20 @@ KRModel::pack_header *KRModel::getHeader() const return (pack_header *)m_pData->getStart(); } +KRModel::pack_bone *KRModel::getBone(int index) +{ + pack_header *header = getHeader(); + return (pack_bone *)((unsigned char *)m_pData->getStart()) + sizeof(pack_header) + sizeof(pack_material) * header->submesh_count; +} + +unsigned char *KRModel::getVertexData() const { + pack_header *pHeader = getHeader(); + return ((unsigned char *)m_pData->getStart()) + sizeof(pack_header) + sizeof(pack_material) * pHeader->submesh_count + sizeof(pack_bone) * pHeader->bone_count; +} + KRModel::pack_material *KRModel::getSubmesh(int mesh_index) { - return (pack_material *)(getHeader()+1) + mesh_index; + return (pack_material *)((unsigned char *)m_pData->getStart() + sizeof(pack_header)) + mesh_index; } unsigned char *KRModel::getVertexData(int index) const @@ -487,7 +500,7 @@ unsigned char *KRModel::getVertexData(int index) const int KRModel::getSubmeshCount() { - pack_header *header = (pack_header *)m_pData->getStart(); + pack_header *header = getHeader(); return header->submesh_count; } @@ -579,6 +592,31 @@ void KRModel::setVertexUVB(int index, const KRVector2 &v) vert[1] = v.y; } + +int KRModel::getBoneIndex(int index, int weight_index) const +{ + unsigned char *vert = (unsigned char *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_BONEINDEXES]); + return vert[weight_index]; +} + +void KRModel::setBoneIndex(int index, int weight_index, int bone_index) +{ + unsigned char *vert = (unsigned char *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_BONEINDEXES]); + vert[weight_index] = bone_index; +} + +float KRModel::getBoneWeight(int index, int weight_index) const +{ + float *vert = (float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_BONEWEIGHTS]); + return vert[weight_index]; +} + +void KRModel::setBoneWeight(int index, int weight_index, float bone_weight) +{ + float *vert = (float *)(getVertexData(index) + m_vertex_attribute_offset[KRENGINE_ATTRIB_BONEWEIGHTS]); + vert[weight_index] = bone_weight; +} + size_t KRModel::VertexSizeForAttributes(__int32_t vertex_attrib_flags) { size_t data_size = 0; @@ -616,7 +654,18 @@ void KRModel::updateAttributeOffsets() } else { m_vertex_attribute_offset[i] = -1; } - mask = (mask << 1) & 1; + mask = (mask << 1) | 1; } m_vertex_size = VertexSizeForAttributes(header->vertex_attrib_flags); } + +size_t KRModel::AttributeOffset(__int32_t vertex_attrib, __int32_t vertex_attrib_flags) +{ + int mask = 0; + for(int i=0; i < vertex_attrib; i++) { + if(vertex_attrib_flags & (1 << i)) { + mask |= (1 << i); + } + } + return VertexSizeForAttributes(mask); +} diff --git a/KREngine/KREngine/Classes/KRModel.h b/KREngine/KREngine/Classes/KRModel.h index 509a941..700ed17 100644 --- a/KREngine/KREngine/Classes/KRModel.h +++ b/KREngine/KREngine/Classes/KRModel.h @@ -43,6 +43,8 @@ using std::list; #define MAX_VBO_SIZE 65535 +#define KRENGINE_MAX_BONE_WEIGHTS_PER_VERTEX 4 +#define KRENGINE_MAX_NAME_LENGTH 256 // MAX_VBO_SIZE must be divisible by 3 so triangles aren't split across VBO objects... #define BUFFER_OFFSET(i) ((char *)NULL + (i)) @@ -78,7 +80,7 @@ public: virtual std::string getExtension(); virtual bool save(const std::string& path); - void LoadData(std::vector vertices, std::vector uva, std::vector uvb, std::vector normals, std::vector tangents, std::vector submesh_starts, std::vector submesh_lengths, std::vector material_names, std::list bone_names, std::vector > bone_indexes, std::vector > bone_weights); + void LoadData(std::vector vertices, std::vector uva, std::vector uvb, std::vector normals, std::vector tangents, std::vector submesh_starts, std::vector submesh_lengths, std::vector material_names, std::vector bone_names, std::vector > bone_indexes, std::vector > bone_weights); void loadPack(KRDataBlock *data); @@ -108,7 +110,7 @@ public: typedef struct { GLint start_vertex; GLsizei vertex_count; - char szMaterialName[256]; + char szMaterialName[KRENGINE_MAX_NAME_LENGTH]; } Submesh; typedef struct { @@ -135,8 +137,12 @@ public: typedef struct { int32_t start_vertex; int32_t vertex_count; - char szName[256]; + char szName[KRENGINE_MAX_NAME_LENGTH]; } pack_material; + + typedef struct { + char szName[KRENGINE_MAX_NAME_LENGTH]; + } pack_bone; int getLODCoverage() const; std::string getLODBaseName() const; @@ -152,11 +158,19 @@ public: KRVector3 getVertexTangent(int index) const; KRVector2 getVertexUVA(int index) const; KRVector2 getVertexUVB(int index) const; + int getBoneIndex(int index, int weight_index) const; + float getBoneWeight(int index, int weight_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); + void setBoneIndex(int index, int weight_index, int bone_index); + void setBoneWeight(int index, int weight_index, float bone_weight); + + static size_t VertexSizeForAttributes(__int32_t vertex_attrib_flags); + static size_t AttributeOffset(__int32_t vertex_attrib, __int32_t vertex_attrib_flags); 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) @@ -172,12 +186,13 @@ private: typedef struct { char szTag[16]; - int32_t format_type; // 0 == Triangle list, 1 == Indexed list, rest are reserved (model_format_t enum) + int32_t format_type; // 0 == Triangle list, 1 == Indexed triangle list, 2 == Indexed triangle strips, rest are reserved (model_format_t enum) int32_t vertex_attrib_flags; int32_t vertex_count; int32_t submesh_count; + int32_t bone_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 + unsigned char reserved[452]; // Pad out to 512 bytes } pack_header; vector m_submeshes; @@ -191,13 +206,13 @@ private: 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; - + pack_bone *getBone(int index); }; diff --git a/KREngine/KREngine/Classes/KRModelManager.cpp b/KREngine/KREngine/Classes/KRModelManager.cpp index 2a91496..e137b86 100644 --- a/KREngine/KREngine/Classes/KRModelManager.cpp +++ b/KREngine/KREngine/Classes/KRModelManager.cpp @@ -165,99 +165,79 @@ 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, bool enable_bone_indexes, bool enable_bone_weights) { + __int32_t attributes = 0; + if(enable_vertex) { + attributes |= (1 << KRModel::KRENGINE_ATTRIB_VERTEX); GLDEBUG(glEnableVertexAttribArray(KRModel::KRENGINE_ATTRIB_VERTEX)); } else { GLDEBUG(glDisableVertexAttribArray(KRModel::KRENGINE_ATTRIB_VERTEX)); } if(enable_normal) { + attributes |= (1 << KRModel::KRENGINE_ATTRIB_NORMAL); GLDEBUG(glEnableVertexAttribArray(KRModel::KRENGINE_ATTRIB_NORMAL)); } else { GLDEBUG(glDisableVertexAttribArray(KRModel::KRENGINE_ATTRIB_NORMAL)); } if(enable_tangent) { + attributes |= (1 << KRModel::KRENGINE_ATTRIB_TANGENT); GLDEBUG(glEnableVertexAttribArray(KRModel::KRENGINE_ATTRIB_TANGENT)); } else { GLDEBUG(glDisableVertexAttribArray(KRModel::KRENGINE_ATTRIB_TANGENT)); } if(enable_uva) { + attributes |= (1 << KRModel::KRENGINE_ATTRIB_TEXUVA); GLDEBUG(glEnableVertexAttribArray(KRModel::KRENGINE_ATTRIB_TEXUVA)); } else { GLDEBUG(glDisableVertexAttribArray(KRModel::KRENGINE_ATTRIB_TEXUVA)); } if(enable_uvb) { + attributes |= (1 << KRModel::KRENGINE_ATTRIB_TEXUVB); GLDEBUG(glEnableVertexAttribArray(KRModel::KRENGINE_ATTRIB_TEXUVB)); } else { GLDEBUG(glDisableVertexAttribArray(KRModel::KRENGINE_ATTRIB_TEXUVB)); } if(enable_bone_indexes) { + attributes |= (1 << KRModel::KRENGINE_ATTRIB_BONEINDEXES); GLDEBUG(glEnableVertexAttribArray(KRModel::KRENGINE_ATTRIB_BONEINDEXES)); } else { GLDEBUG(glDisableVertexAttribArray(KRModel::KRENGINE_ATTRIB_BONEINDEXES)); } if(enable_bone_weights) { + attributes |= (1 << KRModel::KRENGINE_ATTRIB_BONEWEIGHTS); GLDEBUG(glEnableVertexAttribArray(KRModel::KRENGINE_ATTRIB_BONEWEIGHTS)); } else { GLDEBUG(glDisableVertexAttribArray(KRModel::KRENGINE_ATTRIB_BONEWEIGHTS)); } - - int data_size = 0; - if(enable_vertex) { - data_size += sizeof(GLfloat) * 3; - } - if(enable_normal) { - data_size += sizeof(GLfloat) * 3; - } - if(enable_tangent) { - data_size += sizeof(GLfloat) * 3; - } - if(enable_uva) { - data_size += sizeof(GLfloat) * 2; - } - if(enable_uvb) { - 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; + GLsizei data_size = (GLsizei)KRModel::VertexSizeForAttributes(attributes); + if(enable_vertex) { - GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_VERTEX, 3, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset))); - offset += sizeof(KRModel::KRVector3D); + GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_VERTEX, 3, GL_FLOAT, 0, data_size, BUFFER_OFFSET(KRModel::AttributeOffset(KRModel::KRENGINE_ATTRIB_VERTEX, attributes)))); } if(enable_normal) { - GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_NORMAL, 3, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset))); - offset += sizeof(KRModel::KRVector3D); + GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_NORMAL, 3, GL_FLOAT, 0, data_size, BUFFER_OFFSET(KRModel::AttributeOffset(KRModel::KRENGINE_ATTRIB_NORMAL, attributes)))); } if(enable_tangent) { - GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_TANGENT, 3, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset))); - offset += sizeof(KRModel::KRVector3D); + GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_TANGENT, 3, GL_FLOAT, 0, data_size, BUFFER_OFFSET(KRModel::AttributeOffset(KRModel::KRENGINE_ATTRIB_TANGENT, attributes)))); } if(enable_uva) { - GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_TEXUVA, 2, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset))); - offset += sizeof(KRModel::TexCoord); + GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_TEXUVA, 2, GL_FLOAT, 0, data_size, BUFFER_OFFSET(KRModel::AttributeOffset(KRModel::KRENGINE_ATTRIB_TEXUVA, attributes)))); } if(enable_uvb) { - GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_TEXUVB, 2, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset))); - offset += sizeof(KRModel::TexCoord); + GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_TEXUVB, 2, GL_FLOAT, 0, data_size, BUFFER_OFFSET(KRModel::AttributeOffset(KRModel::KRENGINE_ATTRIB_TEXUVB, attributes)))); } if(enable_bone_indexes ) { - GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_BONEINDEXES, 1, GL_UNSIGNED_BYTE, 0, data_size, BUFFER_OFFSET(offset))); - offset += 4; // 4 bytes + GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_BONEINDEXES, 1, GL_UNSIGNED_BYTE, 0, data_size, BUFFER_OFFSET(KRModel::AttributeOffset(KRModel::KRENGINE_ATTRIB_BONEINDEXES, attributes)))); } if(enable_bone_weights) { - GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_BONEWEIGHTS, 4, GL_FLOAT, 0, data_size, BUFFER_OFFSET(offset))); - offset += sizeof(GLfloat) * 4; + GLDEBUG(glVertexAttribPointer(KRModel::KRENGINE_ATTRIB_BONEWEIGHTS, 4, GL_FLOAT, 0, data_size, BUFFER_OFFSET(KRModel::AttributeOffset(KRModel::KRENGINE_ATTRIB_BONEWEIGHTS, attributes)))); } } diff --git a/KREngine/KREngine/Classes/KRResource+fbx.cpp b/KREngine/KREngine/Classes/KRResource+fbx.cpp index b4094c9..7d18357 100644 --- a/KREngine/KREngine/Classes/KRResource+fbx.cpp +++ b/KREngine/KREngine/Classes/KRResource+fbx.cpp @@ -703,23 +703,21 @@ KRNode *LoadMesh(KRNode *parent_node, std::vector &resources, FbxG int control_point_count = pMesh->GetControlPointsCount(); KFbxVector4* control_points = pMesh->GetControlPoints(); - const int MAX_BONE_WEIGHTS = 4; - struct control_point_weight_info { - float weights[MAX_BONE_WEIGHTS]; - int bone_indexes[MAX_BONE_WEIGHTS]; + float weights[KRENGINE_MAX_BONE_WEIGHTS_PER_VERTEX]; + int bone_indexes[KRENGINE_MAX_BONE_WEIGHTS_PER_VERTEX]; }; control_point_weight_info *control_point_weights = new control_point_weight_info[control_point_count]; for(int control_point=0; control_point < control_point_count; control_point++) { - for(int i=0; i bone_names; + std::vector bone_names; bool too_many_bone_weights = false; // Collect the top 4 bone weights per vertex ... @@ -741,13 +739,13 @@ KRNode *LoadMesh(KRNode *parent_node, std::vector &resources, FbxG for(int control_point=0; control_pointGetControlPointIndices()[control_point]]; float bone_weight = cluster->GetControlPointWeights()[control_point]; - if(bone_weight > weight_info.weights[MAX_BONE_WEIGHTS - 1]) { - if(weight_info.weights[MAX_BONE_WEIGHTS - 1] != 0.0f) { + if(bone_weight > weight_info.weights[KRENGINE_MAX_BONE_WEIGHTS_PER_VERTEX - 1]) { + if(weight_info.weights[KRENGINE_MAX_BONE_WEIGHTS_PER_VERTEX - 1] != 0.0f) { too_many_bone_weights = true; } - weight_info.weights[MAX_BONE_WEIGHTS - 1] = bone_weight; - weight_info.bone_indexes[MAX_BONE_WEIGHTS - 1] = target_bone_index; - for(int bone_index=MAX_BONE_WEIGHTS - 1; bone_index >=0; bone_index--) { + weight_info.weights[KRENGINE_MAX_BONE_WEIGHTS_PER_VERTEX - 1] = bone_weight; + weight_info.bone_indexes[KRENGINE_MAX_BONE_WEIGHTS_PER_VERTEX - 1] = target_bone_index; + for(int bone_index=KRENGINE_MAX_BONE_WEIGHTS_PER_VERTEX - 1; bone_index >=0; bone_index--) { if(bone_weight > weight_info.weights[bone_index]) { weight_info.weights[bone_index+1] = weight_info.weights[bone_index]; weight_info.bone_indexes[bone_index+1] = weight_info.bone_indexes[bone_index]; @@ -764,18 +762,18 @@ KRNode *LoadMesh(KRNode *parent_node, std::vector &resources, FbxG } if(too_many_bone_weights) { - printf(" WARNING! - Clipped bone weights to limit of %i per vertex (selecting largest weights and re-normalizing).\n", MAX_BONE_WEIGHTS); + printf(" WARNING! - Clipped bone weights to limit of %i per vertex (selecting largest weights and re-normalizing).\n", KRENGINE_MAX_BONE_WEIGHTS_PER_VERTEX); } // Normalize bone weights if(bone_names.size() > 0) { for(int control_point_index=0; control_point_index < control_point_count; control_point_index++) { control_point_weight_info &weight_info = control_point_weights[control_point_index]; float total_weights = 0.0f; - for(int i=0; i < MAX_BONE_WEIGHTS; i++) { + for(int i=0; i < KRENGINE_MAX_BONE_WEIGHTS_PER_VERTEX; i++) { total_weights += weight_info.weights[i]; } if(total_weights == 0.0f) total_weights = 1.0f; // Prevent any divisions by zero - for(int i=0; i < MAX_BONE_WEIGHTS; i++) { + for(int i=0; i < KRENGINE_MAX_BONE_WEIGHTS_PER_VERTEX; i++) { weight_info.weights[i] = weight_info.weights[i] / total_weights; } } @@ -843,7 +841,7 @@ KRNode *LoadMesh(KRNode *parent_node, std::vector &resources, FbxG control_point_weight_info &weight_info = control_point_weights[lControlPointIndex]; std::vector vertex_bone_indexes; std::vector vertex_bone_weights; - for(int i=0; i KRResource::LoadObj(KRContext &context, const std::str } // TODO: Bones not yet supported for OBJ - std::list bone_names; + std::vector bone_names; std::vector > bone_indexes; std::vector > bone_weights;