| /* |
| --------------------------------------------------------------------------- |
| Open Asset Import Library (assimp) |
| --------------------------------------------------------------------------- |
| |
| Copyright (c) 2006-2017, assimp team |
| |
| |
| All rights reserved. |
| |
| Redistribution and use of this software in source and binary forms, |
| with or without modification, are permitted provided that the following |
| conditions are met: |
| |
| * Redistributions of source code must retain the above |
| copyright notice, this list of conditions and the |
| following disclaimer. |
| |
| * Redistributions in binary form must reproduce the above |
| copyright notice, this list of conditions and the |
| following disclaimer in the documentation and/or other |
| materials provided with the distribution. |
| |
| * Neither the name of the assimp team, nor the names of its |
| contributors may be used to endorse or promote products |
| derived from this software without specific prior |
| written permission of the assimp team. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| --------------------------------------------------------------------------- |
| */ |
| |
| /** @file SMDLoader.cpp |
| * @brief Implementation of the SMD importer class |
| */ |
| |
| |
| #ifndef ASSIMP_BUILD_NO_SMD_IMPORTER |
| |
| // internal headers |
| #include "SMDLoader.h" |
| #include "fast_atof.h" |
| #include "SkeletonMeshBuilder.h" |
| #include <assimp/Importer.hpp> |
| #include <assimp/IOSystem.hpp> |
| #include <assimp/scene.h> |
| #include <assimp/DefaultLogger.hpp> |
| #include <assimp/importerdesc.h> |
| #include <memory> |
| |
| using namespace Assimp; |
| |
| static const aiImporterDesc desc = { |
| "Valve SMD Importer", |
| "", |
| "", |
| "", |
| aiImporterFlags_SupportTextFlavour, |
| 0, |
| 0, |
| 0, |
| 0, |
| "smd vta" |
| }; |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Constructor to be privately used by Importer |
| SMDImporter::SMDImporter() |
| : configFrameID(), |
| mBuffer(), |
| pScene( nullptr ), |
| iFileSize( 0 ), |
| iSmallestFrame( -1 ), |
| dLengthOfAnim( 0.0 ), |
| bHasUVs(false ), |
| iLineNumber(-1) { |
| // empty |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Destructor, private as well |
| SMDImporter::~SMDImporter() { |
| // empty |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Returns whether the class can handle the format of the given file. |
| bool SMDImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool) const |
| { |
| // fixme: auto format detection |
| return SimpleExtensionCheck(pFile,"smd","vta"); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Get a list of all supported file extensions |
| const aiImporterDesc* SMDImporter::GetInfo () const |
| { |
| return &desc; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Setup configuration properties |
| void SMDImporter::SetupProperties(const Importer* pImp) |
| { |
| // The |
| // AI_CONFIG_IMPORT_SMD_KEYFRAME option overrides the |
| // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option. |
| configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_SMD_KEYFRAME,-1); |
| if(static_cast<unsigned int>(-1) == configFrameID) { |
| configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME,0); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Imports the given file into the given scene structure. |
| void SMDImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) |
| { |
| std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb")); |
| |
| // Check whether we can read from the file |
| if( file.get() == NULL) { |
| throw DeadlyImportError( "Failed to open SMD/VTA file " + pFile + "."); |
| } |
| |
| iFileSize = (unsigned int)file->FileSize(); |
| |
| // Allocate storage and copy the contents of the file to a memory buffer |
| this->pScene = pScene; |
| |
| mBuffer.resize( iFileSize + 1 ); |
| TextFileToBuffer(file.get(), mBuffer ); |
| |
| iSmallestFrame = (1 << 31); |
| bHasUVs = true; |
| iLineNumber = 1; |
| |
| // Reserve enough space for ... hm ... 10 textures |
| aszTextures.reserve(10); |
| |
| // Reserve enough space for ... hm ... 1000 triangles |
| asTriangles.reserve(1000); |
| |
| // Reserve enough space for ... hm ... 20 bones |
| asBones.reserve(20); |
| |
| |
| // parse the file ... |
| ParseFile(); |
| |
| // If there are no triangles it seems to be an animation SMD, |
| // containing only the animation skeleton. |
| if (asTriangles.empty()) |
| { |
| if (asBones.empty()) |
| { |
| throw DeadlyImportError("SMD: No triangles and no bones have " |
| "been found in the file. This file seems to be invalid."); |
| } |
| |
| // Set the flag in the scene structure which indicates |
| // that there is nothing than an animation skeleton |
| pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE; |
| } |
| |
| if (!asBones.empty()) |
| { |
| // Check whether all bones have been initialized |
| for (std::vector<SMD::Bone>::const_iterator |
| i = asBones.begin(); |
| i != asBones.end();++i) |
| { |
| if (!(*i).mName.length()) |
| { |
| DefaultLogger::get()->warn("SMD: Not all bones have been initialized"); |
| break; |
| } |
| } |
| |
| // now fix invalid time values and make sure the animation starts at frame 0 |
| FixTimeValues(); |
| |
| // compute absolute bone transformation matrices |
| // ComputeAbsoluteBoneTransformations(); |
| } |
| |
| if (!(pScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE)) |
| { |
| // create output meshes |
| CreateOutputMeshes(); |
| |
| // build an output material list |
| CreateOutputMaterials(); |
| } |
| |
| // build the output animation |
| CreateOutputAnimations(); |
| |
| // build output nodes (bones are added as empty dummy nodes) |
| CreateOutputNodes(); |
| |
| if (pScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE) |
| { |
| SkeletonMeshBuilder skeleton(pScene); |
| } |
| } |
| // ------------------------------------------------------------------------------------------------ |
| // Write an error message with line number to the log file |
| void SMDImporter::LogErrorNoThrow(const char* msg) |
| { |
| char szTemp[1024]; |
| ai_snprintf(szTemp,1024,"Line %u: %s",iLineNumber,msg); |
| DefaultLogger::get()->error(szTemp); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Write a warning with line number to the log file |
| void SMDImporter::LogWarning(const char* msg) |
| { |
| char szTemp[1024]; |
| ai_assert(strlen(msg) < 1000); |
| ai_snprintf(szTemp,1024,"Line %u: %s",iLineNumber,msg); |
| DefaultLogger::get()->warn(szTemp); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Fix invalid time values in the file |
| void SMDImporter::FixTimeValues() |
| { |
| double dDelta = (double)iSmallestFrame; |
| double dMax = 0.0f; |
| for (std::vector<SMD::Bone>::iterator |
| iBone = asBones.begin(); |
| iBone != asBones.end();++iBone) |
| { |
| for (std::vector<SMD::Bone::Animation::MatrixKey>::iterator |
| iKey = (*iBone).sAnim.asKeys.begin(); |
| iKey != (*iBone).sAnim.asKeys.end();++iKey) |
| { |
| (*iKey).dTime -= dDelta; |
| dMax = std::max(dMax, (*iKey).dTime); |
| } |
| } |
| dLengthOfAnim = dMax; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // create output meshes |
| void SMDImporter::CreateOutputMeshes() |
| { |
| if (aszTextures.empty()) |
| aszTextures.push_back(std::string()); |
| |
| // we need to sort all faces by their material index |
| // in opposition to other loaders we can be sure that each |
| // material is at least used once. |
| pScene->mNumMeshes = (unsigned int) aszTextures.size(); |
| pScene->mMeshes = new aiMesh*[pScene->mNumMeshes]; |
| |
| typedef std::vector<unsigned int> FaceList; |
| FaceList* aaiFaces = new FaceList[pScene->mNumMeshes]; |
| |
| // approximate the space that will be required |
| unsigned int iNum = (unsigned int)asTriangles.size() / pScene->mNumMeshes; |
| iNum += iNum >> 1; |
| for (unsigned int i = 0; i < pScene->mNumMeshes;++i) |
| aaiFaces[i].reserve(iNum); |
| |
| |
| // collect all faces |
| iNum = 0; |
| for (std::vector<SMD::Face>::const_iterator |
| iFace = asTriangles.begin(); |
| iFace != asTriangles.end();++iFace,++iNum) |
| { |
| if (UINT_MAX == (*iFace).iTexture)aaiFaces[(*iFace).iTexture].push_back( 0 ); |
| else if ((*iFace).iTexture >= aszTextures.size()) |
| { |
| DefaultLogger::get()->error("[SMD/VTA] Material index overflow in face"); |
| aaiFaces[(*iFace).iTexture].push_back((unsigned int)aszTextures.size()-1); |
| } |
| else aaiFaces[(*iFace).iTexture].push_back(iNum); |
| } |
| |
| // now create the output meshes |
| for (unsigned int i = 0; i < pScene->mNumMeshes;++i) |
| { |
| aiMesh*& pcMesh = pScene->mMeshes[i] = new aiMesh(); |
| ai_assert(!aaiFaces[i].empty()); // should not be empty ... |
| |
| pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; |
| pcMesh->mNumVertices = (unsigned int)aaiFaces[i].size()*3; |
| pcMesh->mNumFaces = (unsigned int)aaiFaces[i].size(); |
| pcMesh->mMaterialIndex = i; |
| |
| // storage for bones |
| typedef std::pair<unsigned int,float> TempWeightListEntry; |
| typedef std::vector< TempWeightListEntry > TempBoneWeightList; |
| |
| TempBoneWeightList* aaiBones = new TempBoneWeightList[asBones.size()](); |
| |
| // try to reserve enough memory without wasting too much |
| for (unsigned int iBone = 0; iBone < asBones.size();++iBone) |
| { |
| aaiBones[iBone].reserve(pcMesh->mNumVertices/asBones.size()); |
| } |
| |
| // allocate storage |
| pcMesh->mFaces = new aiFace[pcMesh->mNumFaces]; |
| aiVector3D* pcNormals = pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices]; |
| aiVector3D* pcVerts = pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices]; |
| |
| aiVector3D* pcUVs = NULL; |
| if (bHasUVs) |
| { |
| pcUVs = pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices]; |
| pcMesh->mNumUVComponents[0] = 2; |
| } |
| |
| iNum = 0; |
| for (unsigned int iFace = 0; iFace < pcMesh->mNumFaces;++iFace) |
| { |
| pcMesh->mFaces[iFace].mIndices = new unsigned int[3]; |
| pcMesh->mFaces[iFace].mNumIndices = 3; |
| |
| // fill the vertices |
| unsigned int iSrcFace = aaiFaces[i][iFace]; |
| SMD::Face& face = asTriangles[iSrcFace]; |
| |
| *pcVerts++ = face.avVertices[0].pos; |
| *pcVerts++ = face.avVertices[1].pos; |
| *pcVerts++ = face.avVertices[2].pos; |
| |
| // fill the normals |
| *pcNormals++ = face.avVertices[0].nor; |
| *pcNormals++ = face.avVertices[1].nor; |
| *pcNormals++ = face.avVertices[2].nor; |
| |
| // fill the texture coordinates |
| if (pcUVs) |
| { |
| *pcUVs++ = face.avVertices[0].uv; |
| *pcUVs++ = face.avVertices[1].uv; |
| *pcUVs++ = face.avVertices[2].uv; |
| } |
| |
| for (unsigned int iVert = 0; iVert < 3;++iVert) |
| { |
| float fSum = 0.0f; |
| for (unsigned int iBone = 0;iBone < face.avVertices[iVert].aiBoneLinks.size();++iBone) |
| { |
| TempWeightListEntry& pairval = face.avVertices[iVert].aiBoneLinks[iBone]; |
| |
| // FIX: The second check is here just to make sure we won't |
| // assign more than one weight to a single vertex index |
| if (pairval.first >= asBones.size() || |
| pairval.first == face.avVertices[iVert].iParentNode) |
| { |
| DefaultLogger::get()->error("[SMD/VTA] Bone index overflow. " |
| "The bone index will be ignored, the weight will be assigned " |
| "to the vertex' parent node"); |
| continue; |
| } |
| aaiBones[pairval.first].push_back(TempWeightListEntry(iNum,pairval.second)); |
| fSum += pairval.second; |
| } |
| // ****************************************************************** |
| // If the sum of all vertex weights is not 1.0 we must assign |
| // the rest to the vertex' parent node. Well, at least the doc says |
| // we should ... |
| // FIX: We use 0.975 as limit, floating-point inaccuracies seem to |
| // be very strong in some SMD exporters. Furthermore it is possible |
| // that the parent of a vertex is 0xffffffff (if the corresponding |
| // entry in the file was unreadable) |
| // ****************************************************************** |
| if (fSum < 0.975f && face.avVertices[iVert].iParentNode != UINT_MAX) |
| { |
| if (face.avVertices[iVert].iParentNode >= asBones.size()) |
| { |
| DefaultLogger::get()->error("[SMD/VTA] Bone index overflow. " |
| "The index of the vertex parent bone is invalid. " |
| "The remaining weights will be normalized to 1.0"); |
| |
| if (fSum) |
| { |
| fSum = 1 / fSum; |
| for (unsigned int iBone = 0;iBone < face.avVertices[iVert].aiBoneLinks.size();++iBone) |
| { |
| TempWeightListEntry& pairval = face.avVertices[iVert].aiBoneLinks[iBone]; |
| if (pairval.first >= asBones.size())continue; |
| aaiBones[pairval.first].back().second *= fSum; |
| } |
| } |
| } |
| else |
| { |
| aaiBones[face.avVertices[iVert].iParentNode].push_back( |
| TempWeightListEntry(iNum,1.0f-fSum)); |
| } |
| } |
| pcMesh->mFaces[iFace].mIndices[iVert] = iNum++; |
| } |
| } |
| |
| // now build all bones of the mesh |
| iNum = 0; |
| for (unsigned int iBone = 0; iBone < asBones.size();++iBone) |
| if (!aaiBones[iBone].empty())++iNum; |
| |
| if (false && iNum) |
| { |
| pcMesh->mNumBones = iNum; |
| pcMesh->mBones = new aiBone*[pcMesh->mNumBones]; |
| iNum = 0; |
| for (unsigned int iBone = 0; iBone < asBones.size();++iBone) |
| { |
| if (aaiBones[iBone].empty())continue; |
| aiBone*& bone = pcMesh->mBones[iNum] = new aiBone(); |
| |
| bone->mNumWeights = (unsigned int)aaiBones[iBone].size(); |
| bone->mWeights = new aiVertexWeight[bone->mNumWeights]; |
| bone->mOffsetMatrix = asBones[iBone].mOffsetMatrix; |
| bone->mName.Set( asBones[iBone].mName ); |
| |
| asBones[iBone].bIsUsed = true; |
| |
| for (unsigned int iWeight = 0; iWeight < bone->mNumWeights;++iWeight) |
| { |
| bone->mWeights[iWeight].mVertexId = aaiBones[iBone][iWeight].first; |
| bone->mWeights[iWeight].mWeight = aaiBones[iBone][iWeight].second; |
| } |
| ++iNum; |
| } |
| } |
| delete[] aaiBones; |
| } |
| delete[] aaiFaces; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // add bone child nodes |
| void SMDImporter::AddBoneChildren(aiNode* pcNode, uint32_t iParent) |
| { |
| ai_assert( NULL != pcNode ); |
| ai_assert( 0 == pcNode->mNumChildren ); |
| ai_assert( NULL == pcNode->mChildren); |
| |
| // first count ... |
| for (unsigned int i = 0; i < asBones.size();++i) |
| { |
| SMD::Bone& bone = asBones[i]; |
| if (bone.iParent == iParent)++pcNode->mNumChildren; |
| } |
| |
| // now allocate the output array |
| pcNode->mChildren = new aiNode*[pcNode->mNumChildren]; |
| |
| // and fill all subnodes |
| unsigned int qq = 0; |
| for (unsigned int i = 0; i < asBones.size();++i) |
| { |
| SMD::Bone& bone = asBones[i]; |
| if (bone.iParent != iParent)continue; |
| |
| aiNode* pc = pcNode->mChildren[qq++] = new aiNode(); |
| pc->mName.Set(bone.mName); |
| |
| // store the local transformation matrix of the bind pose |
| pc->mTransformation = bone.sAnim.asKeys[bone.sAnim.iFirstTimeKey].matrix; |
| pc->mParent = pcNode; |
| |
| // add children to this node, too |
| AddBoneChildren(pc,i); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // create output nodes |
| void SMDImporter::CreateOutputNodes() |
| { |
| pScene->mRootNode = new aiNode(); |
| if (!(pScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE)) |
| { |
| // create one root node that renders all meshes |
| pScene->mRootNode->mNumMeshes = pScene->mNumMeshes; |
| pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes]; |
| for (unsigned int i = 0; i < pScene->mNumMeshes;++i) |
| pScene->mRootNode->mMeshes[i] = i; |
| } |
| |
| // now add all bones as dummy sub nodes to the graph |
| // AddBoneChildren(pScene->mRootNode,(uint32_t)-1); |
| |
| // if we have only one bone we can even remove the root node |
| if (pScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE && |
| 1 == pScene->mRootNode->mNumChildren) |
| { |
| aiNode* pcOldRoot = pScene->mRootNode; |
| pScene->mRootNode = pcOldRoot->mChildren[0]; |
| pcOldRoot->mChildren[0] = NULL; |
| delete pcOldRoot; |
| |
| pScene->mRootNode->mParent = NULL; |
| } |
| else |
| { |
| ::strcpy(pScene->mRootNode->mName.data, "<SMD_root>"); |
| pScene->mRootNode->mName.length = 10; |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // create output animations |
| void SMDImporter::CreateOutputAnimations() |
| { |
| unsigned int iNumBones = 0; |
| for (std::vector<SMD::Bone>::const_iterator |
| i = asBones.begin(); |
| i != asBones.end();++i) |
| { |
| if ((*i).bIsUsed)++iNumBones; |
| } |
| if (!iNumBones) |
| { |
| // just make sure this case doesn't occur ... (it could occur |
| // if the file was invalid) |
| return; |
| } |
| |
| pScene->mNumAnimations = 1; |
| pScene->mAnimations = new aiAnimation*[1]; |
| aiAnimation*& anim = pScene->mAnimations[0] = new aiAnimation(); |
| |
| anim->mDuration = dLengthOfAnim; |
| anim->mNumChannels = iNumBones; |
| anim->mTicksPerSecond = 25.0; // FIXME: is this correct? |
| |
| aiNodeAnim** pp = anim->mChannels = new aiNodeAnim*[anim->mNumChannels]; |
| |
| // now build valid keys |
| unsigned int a = 0; |
| for (std::vector<SMD::Bone>::const_iterator |
| i = asBones.begin(); |
| i != asBones.end();++i) |
| { |
| if (!(*i).bIsUsed)continue; |
| |
| aiNodeAnim* p = pp[a] = new aiNodeAnim(); |
| |
| // copy the name of the bone |
| p->mNodeName.Set( i->mName); |
| |
| p->mNumRotationKeys = (unsigned int) (*i).sAnim.asKeys.size(); |
| if (p->mNumRotationKeys) |
| { |
| p->mNumPositionKeys = p->mNumRotationKeys; |
| aiVectorKey* pVecKeys = p->mPositionKeys = new aiVectorKey[p->mNumRotationKeys]; |
| aiQuatKey* pRotKeys = p->mRotationKeys = new aiQuatKey[p->mNumRotationKeys]; |
| |
| for (std::vector<SMD::Bone::Animation::MatrixKey>::const_iterator |
| qq = (*i).sAnim.asKeys.begin(); |
| qq != (*i).sAnim.asKeys.end(); ++qq) |
| { |
| pRotKeys->mTime = pVecKeys->mTime = (*qq).dTime; |
| |
| // compute the rotation quaternion from the euler angles |
| pRotKeys->mValue = aiQuaternion( (*qq).vRot.x, (*qq).vRot.y, (*qq).vRot.z ); |
| pVecKeys->mValue = (*qq).vPos; |
| |
| ++pVecKeys; ++pRotKeys; |
| } |
| } |
| ++a; |
| |
| // there are no scaling keys ... |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void SMDImporter::ComputeAbsoluteBoneTransformations() |
| { |
| // For each bone: determine the key with the lowest time value |
| // theoretically the SMD format should have all keyframes |
| // in order. However, I've seen a file where this wasn't true. |
| for (unsigned int i = 0; i < asBones.size();++i) |
| { |
| SMD::Bone& bone = asBones[i]; |
| |
| uint32_t iIndex = 0; |
| double dMin = 10e10; |
| for (unsigned int i = 0; i < bone.sAnim.asKeys.size();++i) |
| { |
| double d = std::min(bone.sAnim.asKeys[i].dTime,dMin); |
| if (d < dMin) |
| { |
| dMin = d; |
| iIndex = i; |
| } |
| } |
| bone.sAnim.iFirstTimeKey = iIndex; |
| } |
| |
| unsigned int iParent = 0; |
| while (iParent < asBones.size()) |
| { |
| for (unsigned int iBone = 0; iBone < asBones.size();++iBone) |
| { |
| SMD::Bone& bone = asBones[iBone]; |
| |
| if (iParent == bone.iParent) |
| { |
| SMD::Bone& parentBone = asBones[iParent]; |
| |
| |
| uint32_t iIndex = bone.sAnim.iFirstTimeKey; |
| const aiMatrix4x4& mat = bone.sAnim.asKeys[iIndex].matrix; |
| aiMatrix4x4& matOut = bone.sAnim.asKeys[iIndex].matrixAbsolute; |
| |
| // The same for the parent bone ... |
| iIndex = parentBone.sAnim.iFirstTimeKey; |
| const aiMatrix4x4& mat2 = parentBone.sAnim.asKeys[iIndex].matrixAbsolute; |
| |
| // Compute the absolute transformation matrix |
| matOut = mat * mat2; |
| } |
| } |
| ++iParent; |
| } |
| |
| // Store the inverse of the absolute transformation matrix |
| // of the first key as bone offset matrix |
| for (iParent = 0; iParent < asBones.size();++iParent) |
| { |
| SMD::Bone& bone = asBones[iParent]; |
| bone.mOffsetMatrix = bone.sAnim.asKeys[bone.sAnim.iFirstTimeKey].matrixAbsolute; |
| bone.mOffsetMatrix.Inverse(); |
| } |
| } |
| \ |
| // ------------------------------------------------------------------------------------------------ |
| // create output materials |
| void SMDImporter::CreateOutputMaterials() |
| { |
| ai_assert( nullptr != pScene ); |
| |
| pScene->mNumMaterials = (unsigned int)aszTextures.size(); |
| pScene->mMaterials = new aiMaterial*[std::max(1u, pScene->mNumMaterials)]; |
| |
| for (unsigned int iMat = 0; iMat < pScene->mNumMaterials; ++iMat) { |
| aiMaterial* pcMat = new aiMaterial(); |
| ai_assert( nullptr != pcMat ); |
| pScene->mMaterials[iMat] = pcMat; |
| |
| aiString szName; |
| szName.length = (size_t)ai_snprintf(szName.data,MAXLEN,"Texture_%u",iMat); |
| pcMat->AddProperty(&szName,AI_MATKEY_NAME); |
| |
| if (aszTextures[iMat].length()) |
| { |
| ::strncpy(szName.data, aszTextures[iMat].c_str(),MAXLEN-1); |
| szName.length = aszTextures[iMat].length(); |
| pcMat->AddProperty(&szName,AI_MATKEY_TEXTURE_DIFFUSE(0)); |
| } |
| } |
| |
| // create a default material if necessary |
| if (0 == pScene->mNumMaterials) |
| { |
| pScene->mNumMaterials = 1; |
| |
| aiMaterial* pcHelper = new aiMaterial(); |
| pScene->mMaterials[0] = pcHelper; |
| |
| int iMode = (int)aiShadingMode_Gouraud; |
| pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL); |
| |
| aiColor3D clr; |
| clr.b = clr.g = clr.r = 0.7f; |
| pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_DIFFUSE); |
| pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_SPECULAR); |
| |
| clr.b = clr.g = clr.r = 0.05f; |
| pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_AMBIENT); |
| |
| aiString szName; |
| szName.Set(AI_DEFAULT_MATERIAL_NAME); |
| pcHelper->AddProperty(&szName,AI_MATKEY_NAME); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Parse the file |
| void SMDImporter::ParseFile() |
| { |
| const char* szCurrent = &mBuffer[0]; |
| |
| // read line per line ... |
| for ( ;; ) |
| { |
| if(!SkipSpacesAndLineEnd(szCurrent,&szCurrent)) break; |
| |
| // "version <n> \n", <n> should be 1 for hl and hl2 SMD files |
| if (TokenMatch(szCurrent,"version",7)) |
| { |
| if(!SkipSpaces(szCurrent,&szCurrent)) break; |
| if (1 != strtoul10(szCurrent,&szCurrent)) |
| { |
| DefaultLogger::get()->warn("SMD.version is not 1. This " |
| "file format is not known. Continuing happily ..."); |
| } |
| continue; |
| } |
| // "nodes\n" - Starts the node section |
| if (TokenMatch(szCurrent,"nodes",5)) |
| { |
| ParseNodesSection(szCurrent,&szCurrent); |
| continue; |
| } |
| // "triangles\n" - Starts the triangle section |
| if (TokenMatch(szCurrent,"triangles",9)) |
| { |
| ParseTrianglesSection(szCurrent,&szCurrent); |
| continue; |
| } |
| // "vertexanimation\n" - Starts the vertex animation section |
| if (TokenMatch(szCurrent,"vertexanimation",15)) |
| { |
| bHasUVs = false; |
| ParseVASection(szCurrent,&szCurrent); |
| continue; |
| } |
| // "skeleton\n" - Starts the skeleton section |
| if (TokenMatch(szCurrent,"skeleton",8)) |
| { |
| ParseSkeletonSection(szCurrent,&szCurrent); |
| continue; |
| } |
| SkipLine(szCurrent,&szCurrent); |
| } |
| return; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| unsigned int SMDImporter::GetTextureIndex(const std::string& filename) |
| { |
| unsigned int iIndex = 0; |
| for (std::vector<std::string>::const_iterator |
| i = aszTextures.begin(); |
| i != aszTextures.end();++i,++iIndex) |
| { |
| // case-insensitive ... it's a path |
| if (0 == ASSIMP_stricmp ( filename.c_str(),(*i).c_str()))return iIndex; |
| } |
| iIndex = (unsigned int)aszTextures.size(); |
| aszTextures.push_back(filename); |
| return iIndex; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Parse the nodes section of the file |
| void SMDImporter::ParseNodesSection(const char* szCurrent, |
| const char** szCurrentOut) |
| { |
| for ( ;; ) |
| { |
| // "end\n" - Ends the nodes section |
| if (0 == ASSIMP_strincmp(szCurrent,"end",3) && |
| IsSpaceOrNewLine(*(szCurrent+3))) |
| { |
| szCurrent += 4; |
| break; |
| } |
| ParseNodeInfo(szCurrent,&szCurrent); |
| } |
| SkipSpacesAndLineEnd(szCurrent,&szCurrent); |
| *szCurrentOut = szCurrent; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Parse the triangles section of the file |
| void SMDImporter::ParseTrianglesSection(const char* szCurrent, |
| const char** szCurrentOut) |
| { |
| // Parse a triangle, parse another triangle, parse the next triangle ... |
| // and so on until we reach a token that looks quite similar to "end" |
| for ( ;; ) |
| { |
| if(!SkipSpacesAndLineEnd(szCurrent,&szCurrent)) break; |
| |
| // "end\n" - Ends the triangles section |
| if (TokenMatch(szCurrent,"end",3)) |
| break; |
| ParseTriangle(szCurrent,&szCurrent); |
| } |
| SkipSpacesAndLineEnd(szCurrent,&szCurrent); |
| *szCurrentOut = szCurrent; |
| } |
| // ------------------------------------------------------------------------------------------------ |
| // Parse the vertex animation section of the file |
| void SMDImporter::ParseVASection(const char* szCurrent, |
| const char** szCurrentOut) |
| { |
| unsigned int iCurIndex = 0; |
| for ( ;; ) |
| { |
| if(!SkipSpacesAndLineEnd(szCurrent,&szCurrent)) break; |
| |
| // "end\n" - Ends the "vertexanimation" section |
| if (TokenMatch(szCurrent,"end",3)) |
| break; |
| |
| // "time <n>\n" |
| if (TokenMatch(szCurrent,"time",4)) |
| { |
| // NOTE: The doc says that time values COULD be negative ... |
| // NOTE2: this is the shape key -> valve docs |
| int iTime = 0; |
| if(!ParseSignedInt(szCurrent,&szCurrent,iTime) || configFrameID != (unsigned int)iTime)break; |
| SkipLine(szCurrent,&szCurrent); |
| } |
| else |
| { |
| if(0 == iCurIndex) |
| { |
| asTriangles.push_back(SMD::Face()); |
| } |
| if (++iCurIndex == 3)iCurIndex = 0; |
| ParseVertex(szCurrent,&szCurrent,asTriangles.back().avVertices[iCurIndex],true); |
| } |
| } |
| |
| if (iCurIndex != 2 && !asTriangles.empty()) |
| { |
| // we want to no degenerates, so throw this triangle away |
| asTriangles.pop_back(); |
| } |
| |
| SkipSpacesAndLineEnd(szCurrent,&szCurrent); |
| *szCurrentOut = szCurrent; |
| } |
| // ------------------------------------------------------------------------------------------------ |
| // Parse the skeleton section of the file |
| void SMDImporter::ParseSkeletonSection(const char* szCurrent, |
| const char** szCurrentOut) |
| { |
| int iTime = 0; |
| for ( ;; ) |
| { |
| if(!SkipSpacesAndLineEnd(szCurrent,&szCurrent)) break; |
| |
| // "end\n" - Ends the skeleton section |
| if (TokenMatch(szCurrent,"end",3)) |
| break; |
| |
| // "time <n>\n" - Specifies the current animation frame |
| else if (TokenMatch(szCurrent,"time",4)) |
| { |
| // NOTE: The doc says that time values COULD be negative ... |
| if(!ParseSignedInt(szCurrent,&szCurrent,iTime))break; |
| |
| iSmallestFrame = std::min(iSmallestFrame,iTime); |
| SkipLine(szCurrent,&szCurrent); |
| } |
| else ParseSkeletonElement(szCurrent,&szCurrent,iTime); |
| } |
| *szCurrentOut = szCurrent; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| #define SMDI_PARSE_RETURN { \ |
| SkipLine(szCurrent,&szCurrent); \ |
| *szCurrentOut = szCurrent; \ |
| return; \ |
| } |
| // ------------------------------------------------------------------------------------------------ |
| // Parse a node line |
| void SMDImporter::ParseNodeInfo(const char* szCurrent, |
| const char** szCurrentOut) |
| { |
| unsigned int iBone = 0; |
| SkipSpacesAndLineEnd(szCurrent,&szCurrent); |
| if(!ParseUnsignedInt(szCurrent,&szCurrent,iBone) || !SkipSpaces(szCurrent,&szCurrent)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing bone index"); |
| SMDI_PARSE_RETURN; |
| } |
| // add our bone to the list |
| if (iBone >= asBones.size())asBones.resize(iBone+1); |
| SMD::Bone& bone = asBones[iBone]; |
| |
| bool bQuota = true; |
| if ('\"' != *szCurrent) |
| { |
| LogWarning("Bone name is expcted to be enclosed in " |
| "double quotation marks. "); |
| bQuota = false; |
| } |
| else ++szCurrent; |
| |
| const char* szEnd = szCurrent; |
| for ( ;; ) |
| { |
| if (bQuota && '\"' == *szEnd) |
| { |
| iBone = (unsigned int)(szEnd - szCurrent); |
| ++szEnd; |
| break; |
| } |
| else if (IsSpaceOrNewLine(*szEnd)) |
| { |
| iBone = (unsigned int)(szEnd - szCurrent); |
| break; |
| } |
| else if (!(*szEnd)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing bone name"); |
| SMDI_PARSE_RETURN; |
| } |
| ++szEnd; |
| } |
| bone.mName = std::string(szCurrent,iBone); |
| szCurrent = szEnd; |
| |
| // the only negative bone parent index that could occur is -1 AFAIK |
| if(!ParseSignedInt(szCurrent,&szCurrent,(int&)bone.iParent)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing bone parent index. Assuming -1"); |
| SMDI_PARSE_RETURN; |
| } |
| |
| // go to the beginning of the next line |
| SMDI_PARSE_RETURN; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Parse a skeleton element |
| void SMDImporter::ParseSkeletonElement(const char* szCurrent, |
| const char** szCurrentOut,int iTime) |
| { |
| aiVector3D vPos; |
| aiVector3D vRot; |
| |
| unsigned int iBone = 0; |
| if(!ParseUnsignedInt(szCurrent,&szCurrent,iBone)) |
| { |
| DefaultLogger::get()->error("Unexpected EOF/EOL while parsing bone index"); |
| SMDI_PARSE_RETURN; |
| } |
| if (iBone >= asBones.size()) |
| { |
| LogErrorNoThrow("Bone index in skeleton section is out of range"); |
| SMDI_PARSE_RETURN; |
| } |
| SMD::Bone& bone = asBones[iBone]; |
| |
| bone.sAnim.asKeys.push_back(SMD::Bone::Animation::MatrixKey()); |
| SMD::Bone::Animation::MatrixKey& key = bone.sAnim.asKeys.back(); |
| |
| key.dTime = (double)iTime; |
| if(!ParseFloat(szCurrent,&szCurrent,(float&)vPos.x)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.pos.x"); |
| SMDI_PARSE_RETURN; |
| } |
| if(!ParseFloat(szCurrent,&szCurrent,(float&)vPos.y)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.pos.y"); |
| SMDI_PARSE_RETURN; |
| } |
| if(!ParseFloat(szCurrent,&szCurrent,(float&)vPos.z)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.pos.z"); |
| SMDI_PARSE_RETURN; |
| } |
| if(!ParseFloat(szCurrent,&szCurrent,(float&)vRot.x)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.rot.x"); |
| SMDI_PARSE_RETURN; |
| } |
| if(!ParseFloat(szCurrent,&szCurrent,(float&)vRot.y)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.rot.y"); |
| SMDI_PARSE_RETURN; |
| } |
| if(!ParseFloat(szCurrent,&szCurrent,(float&)vRot.z)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.rot.z"); |
| SMDI_PARSE_RETURN; |
| } |
| // build the transformation matrix of the key |
| key.matrix.FromEulerAnglesXYZ(vRot.x,vRot.y,vRot.z); |
| { |
| aiMatrix4x4 mTemp; |
| mTemp.a4 = vPos.x; |
| mTemp.b4 = vPos.y; |
| mTemp.c4 = vPos.z; |
| key.matrix = key.matrix * mTemp; |
| } |
| |
| // go to the beginning of the next line |
| SMDI_PARSE_RETURN; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Parse a triangle |
| void SMDImporter::ParseTriangle(const char* szCurrent, |
| const char** szCurrentOut) |
| { |
| asTriangles.push_back(SMD::Face()); |
| SMD::Face& face = asTriangles.back(); |
| |
| if(!SkipSpaces(szCurrent,&szCurrent)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing a triangle"); |
| return; |
| } |
| |
| // read the texture file name |
| const char* szLast = szCurrent; |
| while (!IsSpaceOrNewLine(*++szCurrent)); |
| |
| // ... and get the index that belongs to this file name |
| face.iTexture = GetTextureIndex(std::string(szLast,(uintptr_t)szCurrent-(uintptr_t)szLast)); |
| |
| SkipSpacesAndLineEnd(szCurrent,&szCurrent); |
| |
| // load three vertices |
| for (unsigned int iVert = 0; iVert < 3;++iVert) |
| { |
| ParseVertex(szCurrent,&szCurrent, |
| face.avVertices[iVert]); |
| } |
| *szCurrentOut = szCurrent; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Parse a float |
| bool SMDImporter::ParseFloat(const char* szCurrent, |
| const char** szCurrentOut, float& out) |
| { |
| if(!SkipSpaces(&szCurrent)) |
| return false; |
| |
| *szCurrentOut = fast_atoreal_move<float>(szCurrent,out); |
| return true; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Parse an unsigned int |
| bool SMDImporter::ParseUnsignedInt(const char* szCurrent, |
| const char** szCurrentOut, unsigned int& out) |
| { |
| if(!SkipSpaces(&szCurrent)) |
| return false; |
| |
| out = strtoul10(szCurrent,szCurrentOut); |
| return true; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Parse a signed int |
| bool SMDImporter::ParseSignedInt(const char* szCurrent, |
| const char** szCurrentOut, int& out) |
| { |
| if(!SkipSpaces(&szCurrent)) |
| return false; |
| |
| out = strtol10(szCurrent,szCurrentOut); |
| return true; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Parse a vertex |
| void SMDImporter::ParseVertex(const char* szCurrent, |
| const char** szCurrentOut, SMD::Vertex& vertex, |
| bool bVASection /*= false*/) |
| { |
| if (SkipSpaces(&szCurrent) && IsLineEnd(*szCurrent)) |
| { |
| SkipSpacesAndLineEnd(szCurrent,&szCurrent); |
| return ParseVertex(szCurrent,szCurrentOut,vertex,bVASection); |
| } |
| if(!ParseSignedInt(szCurrent,&szCurrent,(int&)vertex.iParentNode)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.parent"); |
| SMDI_PARSE_RETURN; |
| } |
| if(!ParseFloat(szCurrent,&szCurrent,(float&)vertex.pos.x)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.pos.x"); |
| SMDI_PARSE_RETURN; |
| } |
| if(!ParseFloat(szCurrent,&szCurrent,(float&)vertex.pos.y)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.pos.y"); |
| SMDI_PARSE_RETURN; |
| } |
| if(!ParseFloat(szCurrent,&szCurrent,(float&)vertex.pos.z)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.pos.z"); |
| SMDI_PARSE_RETURN; |
| } |
| if(!ParseFloat(szCurrent,&szCurrent,(float&)vertex.nor.x)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.nor.x"); |
| SMDI_PARSE_RETURN; |
| } |
| if(!ParseFloat(szCurrent,&szCurrent,(float&)vertex.nor.y)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.nor.y"); |
| SMDI_PARSE_RETURN; |
| } |
| if(!ParseFloat(szCurrent,&szCurrent,(float&)vertex.nor.z)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.nor.z"); |
| SMDI_PARSE_RETURN; |
| } |
| |
| if (bVASection)SMDI_PARSE_RETURN; |
| |
| if(!ParseFloat(szCurrent,&szCurrent,(float&)vertex.uv.x)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.uv.x"); |
| SMDI_PARSE_RETURN; |
| } |
| if(!ParseFloat(szCurrent,&szCurrent,(float&)vertex.uv.y)) |
| { |
| LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.uv.y"); |
| SMDI_PARSE_RETURN; |
| } |
| |
| // now read the number of bones affecting this vertex |
| // all elements from now are fully optional, we don't need them |
| unsigned int iSize = 0; |
| if(!ParseUnsignedInt(szCurrent,&szCurrent,iSize))SMDI_PARSE_RETURN; |
| vertex.aiBoneLinks.resize(iSize,std::pair<unsigned int, float>(0,0.0f)); |
| |
| for (std::vector<std::pair<unsigned int, float> >::iterator |
| i = vertex.aiBoneLinks.begin(); |
| i != vertex.aiBoneLinks.end();++i) |
| { |
| if(!ParseUnsignedInt(szCurrent,&szCurrent,(*i).first)) |
| SMDI_PARSE_RETURN; |
| if(!ParseFloat(szCurrent,&szCurrent,(*i).second)) |
| SMDI_PARSE_RETURN; |
| } |
| |
| // go to the beginning of the next line |
| SMDI_PARSE_RETURN; |
| } |
| |
| #endif // !! ASSIMP_BUILD_NO_SMD_IMPORTER |
