| /* |
| --------------------------------------------------------------------------- |
| 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 ASELoader.cpp |
| * @brief Implementation of the ASE importer class |
| */ |
| |
| #ifndef ASSIMP_BUILD_NO_ASE_IMPORTER |
| |
| #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER |
| |
| // internal headers |
| #include "ASELoader.h" |
| #include "StringComparison.h" |
| #include "SkeletonMeshBuilder.h" |
| #include "TargetAnimation.h" |
| #include <assimp/Importer.hpp> |
| #include <assimp/IOSystem.hpp> |
| #include <assimp/DefaultLogger.hpp> |
| #include <assimp/scene.h> |
| #include <assimp/importerdesc.h> |
| |
| #include <memory> |
| |
| // utilities |
| #include "fast_atof.h" |
| |
| using namespace Assimp; |
| using namespace Assimp::ASE; |
| |
| static const aiImporterDesc desc = { |
| "ASE Importer", |
| "", |
| "", |
| "Similar to 3DS but text-encoded", |
| aiImporterFlags_SupportTextFlavour, |
| 0, |
| 0, |
| 0, |
| 0, |
| "ase ask" |
| }; |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Constructor to be privately used by Importer |
| ASEImporter::ASEImporter() |
| : mParser(), |
| mBuffer(), |
| pcScene(), |
| configRecomputeNormals(), |
| noSkeletonMesh() |
| {} |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Destructor, private as well |
| ASEImporter::~ASEImporter() |
| {} |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Returns whether the class can handle the format of the given file. |
| bool ASEImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool cs) const |
| { |
| // check file extension |
| const std::string extension = GetExtension(pFile); |
| |
| if( extension == "ase" || extension == "ask") |
| return true; |
| |
| if ((!extension.length() || cs) && pIOHandler) { |
| const char* tokens[] = {"*3dsmax_asciiexport"}; |
| return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1); |
| } |
| return false; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Loader meta information |
| const aiImporterDesc* ASEImporter::GetInfo () const |
| { |
| return &desc; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Setup configuration options |
| void ASEImporter::SetupProperties(const Importer* pImp) |
| { |
| configRecomputeNormals = (pImp->GetPropertyInteger( |
| AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS,1) ? true : false); |
| |
| noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES,0) != 0; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Imports the given file into the given scene structure. |
| void ASEImporter::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 ASE file " + pFile + "."); |
| } |
| |
| // Allocate storage and copy the contents of the file to a memory buffer |
| std::vector<char> mBuffer2; |
| TextFileToBuffer(file.get(),mBuffer2); |
| |
| this->mBuffer = &mBuffer2[0]; |
| this->pcScene = pScene; |
| |
| // ------------------------------------------------------------------ |
| // Guess the file format by looking at the extension |
| // ASC is considered to be the older format 110, |
| // ASE is the actual version 200 (that is currently written by max) |
| // ------------------------------------------------------------------ |
| unsigned int defaultFormat; |
| std::string::size_type s = pFile.length()-1; |
| switch (pFile.c_str()[s]) { |
| |
| case 'C': |
| case 'c': |
| defaultFormat = AI_ASE_OLD_FILE_FORMAT; |
| break; |
| default: |
| defaultFormat = AI_ASE_NEW_FILE_FORMAT; |
| }; |
| |
| // Construct an ASE parser and parse the file |
| ASE::Parser parser(mBuffer,defaultFormat); |
| mParser = &parser; |
| mParser->Parse(); |
| |
| //------------------------------------------------------------------ |
| // Check whether we god at least one mesh. If we did - generate |
| // materials and copy meshes. |
| // ------------------------------------------------------------------ |
| if ( !mParser->m_vMeshes.empty()) { |
| |
| // If absolutely no material has been loaded from the file |
| // we need to generate a default material |
| GenerateDefaultMaterial(); |
| |
| // process all meshes |
| bool tookNormals = false; |
| std::vector<aiMesh*> avOutMeshes; |
| avOutMeshes.reserve(mParser->m_vMeshes.size()*2); |
| for (std::vector<ASE::Mesh>::iterator i = mParser->m_vMeshes.begin();i != mParser->m_vMeshes.end();++i) { |
| if ((*i).bSkip) { |
| continue; |
| } |
| BuildUniqueRepresentation(*i); |
| |
| // Need to generate proper vertex normals if necessary |
| if(GenerateNormals(*i)) { |
| tookNormals = true; |
| } |
| |
| // Convert all meshes to aiMesh objects |
| ConvertMeshes(*i,avOutMeshes); |
| } |
| if (tookNormals) { |
| DefaultLogger::get()->debug("ASE: Taking normals from the file. Use " |
| "the AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS setting if you " |
| "experience problems"); |
| } |
| |
| // Now build the output mesh list. Remove dummies |
| pScene->mNumMeshes = (unsigned int)avOutMeshes.size(); |
| aiMesh** pp = pScene->mMeshes = new aiMesh*[pScene->mNumMeshes]; |
| for (std::vector<aiMesh*>::const_iterator i = avOutMeshes.begin();i != avOutMeshes.end();++i) { |
| if (!(*i)->mNumFaces) { |
| continue; |
| } |
| *pp++ = *i; |
| } |
| pScene->mNumMeshes = (unsigned int)(pp - pScene->mMeshes); |
| |
| // Build final material indices (remove submaterials and setup |
| // the final list) |
| BuildMaterialIndices(); |
| } |
| |
| // ------------------------------------------------------------------ |
| // Copy all scene graph nodes - lights, cameras, dummies and meshes |
| // into one huge list. |
| //------------------------------------------------------------------ |
| std::vector<BaseNode*> nodes; |
| nodes.reserve(mParser->m_vMeshes.size() +mParser->m_vLights.size() |
| + mParser->m_vCameras.size() + mParser->m_vDummies.size()); |
| |
| // Lights |
| for (auto &light : mParser->m_vLights)nodes.push_back(&light); |
| // Cameras |
| for (auto &camera : mParser->m_vCameras)nodes.push_back(&camera); |
| // Meshes |
| for (auto &mesh : mParser->m_vMeshes)nodes.push_back(&mesh); |
| // Dummies |
| for (auto &dummy : mParser->m_vDummies)nodes.push_back(&dummy); |
| |
| // build the final node graph |
| BuildNodes(nodes); |
| |
| // build output animations |
| BuildAnimations(nodes); |
| |
| // build output cameras |
| BuildCameras(); |
| |
| // build output lights |
| BuildLights(); |
| |
| // ------------------------------------------------------------------ |
| // If we have no meshes use the SkeletonMeshBuilder helper class |
| // to build a mesh for the animation skeleton |
| // FIXME: very strange results |
| // ------------------------------------------------------------------ |
| if (!pScene->mNumMeshes) { |
| pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE; |
| if (!noSkeletonMesh) { |
| SkeletonMeshBuilder skeleton(pScene); |
| } |
| } |
| } |
| // ------------------------------------------------------------------------------------------------ |
| void ASEImporter::GenerateDefaultMaterial() |
| { |
| ai_assert(NULL != mParser); |
| |
| bool bHas = false; |
| for (std::vector<ASE::Mesh>::iterator i = mParser->m_vMeshes.begin();i != mParser->m_vMeshes.end();++i) { |
| if ((*i).bSkip)continue; |
| if (ASE::Face::DEFAULT_MATINDEX == (*i).iMaterialIndex) { |
| (*i).iMaterialIndex = (unsigned int)mParser->m_vMaterials.size(); |
| bHas = true; |
| } |
| } |
| if (bHas || mParser->m_vMaterials.empty()) { |
| // add a simple material without submaterials to the parser's list |
| mParser->m_vMaterials.push_back ( ASE::Material() ); |
| ASE::Material& mat = mParser->m_vMaterials.back(); |
| |
| mat.mDiffuse = aiColor3D(0.6f,0.6f,0.6f); |
| mat.mSpecular = aiColor3D(1.0f,1.0f,1.0f); |
| mat.mAmbient = aiColor3D(0.05f,0.05f,0.05f); |
| mat.mShading = Discreet3DS::Gouraud; |
| mat.mName = AI_DEFAULT_MATERIAL_NAME; |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void ASEImporter::BuildAnimations(const std::vector<BaseNode*>& nodes) |
| { |
| // check whether we have at least one mesh which has animations |
| std::vector<ASE::BaseNode*>::const_iterator i = nodes.begin(); |
| unsigned int iNum = 0; |
| for (;i != nodes.end();++i) { |
| |
| // TODO: Implement Bezier & TCB support |
| if ((*i)->mAnim.mPositionType != ASE::Animation::TRACK) { |
| DefaultLogger::get()->warn("ASE: Position controller uses Bezier/TCB keys. " |
| "This is not supported."); |
| } |
| if ((*i)->mAnim.mRotationType != ASE::Animation::TRACK) { |
| DefaultLogger::get()->warn("ASE: Rotation controller uses Bezier/TCB keys. " |
| "This is not supported."); |
| } |
| if ((*i)->mAnim.mScalingType != ASE::Animation::TRACK) { |
| DefaultLogger::get()->warn("ASE: Position controller uses Bezier/TCB keys. " |
| "This is not supported."); |
| } |
| |
| // We compare against 1 here - firstly one key is not |
| // really an animation and secondly MAX writes dummies |
| // that represent the node transformation. |
| if ((*i)->mAnim.akeyPositions.size()>1 || (*i)->mAnim.akeyRotations.size()>1 || (*i)->mAnim.akeyScaling.size()>1){ |
| ++iNum; |
| } |
| if ((*i)->mTargetAnim.akeyPositions.size() > 1 && is_not_qnan( (*i)->mTargetPosition.x )) { |
| ++iNum; |
| } |
| } |
| if (iNum) { |
| // Generate a new animation channel and setup everything for it |
| pcScene->mNumAnimations = 1; |
| pcScene->mAnimations = new aiAnimation*[1]; |
| aiAnimation* pcAnim = pcScene->mAnimations[0] = new aiAnimation(); |
| pcAnim->mNumChannels = iNum; |
| pcAnim->mChannels = new aiNodeAnim*[iNum]; |
| pcAnim->mTicksPerSecond = mParser->iFrameSpeed * mParser->iTicksPerFrame; |
| |
| iNum = 0; |
| |
| // Now iterate through all meshes and collect all data we can find |
| for (i = nodes.begin();i != nodes.end();++i) { |
| |
| ASE::BaseNode* me = *i; |
| if ( me->mTargetAnim.akeyPositions.size() > 1 && is_not_qnan( me->mTargetPosition.x )) { |
| // Generate an extra channel for the camera/light target. |
| // BuildNodes() does also generate an extra node, named |
| // <baseName>.Target. |
| aiNodeAnim* nd = pcAnim->mChannels[iNum++] = new aiNodeAnim(); |
| nd->mNodeName.Set(me->mName + ".Target"); |
| |
| // If there is no input position channel we will need |
| // to supply the default position from the node's |
| // local transformation matrix. |
| /*TargetAnimationHelper helper; |
| if (me->mAnim.akeyPositions.empty()) |
| { |
| aiMatrix4x4& mat = (*i)->mTransform; |
| helper.SetFixedMainAnimationChannel(aiVector3D( |
| mat.a4, mat.b4, mat.c4)); |
| } |
| else helper.SetMainAnimationChannel (&me->mAnim.akeyPositions); |
| helper.SetTargetAnimationChannel (&me->mTargetAnim.akeyPositions); |
| |
| helper.Process(&me->mTargetAnim.akeyPositions);*/ |
| |
| // Allocate the key array and fill it |
| nd->mNumPositionKeys = (unsigned int) me->mTargetAnim.akeyPositions.size(); |
| nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys]; |
| |
| ::memcpy(nd->mPositionKeys,&me->mTargetAnim.akeyPositions[0], |
| nd->mNumPositionKeys * sizeof(aiVectorKey)); |
| } |
| |
| if (me->mAnim.akeyPositions.size() > 1 || me->mAnim.akeyRotations.size() > 1 || me->mAnim.akeyScaling.size() > 1) { |
| // Begin a new node animation channel for this node |
| aiNodeAnim* nd = pcAnim->mChannels[iNum++] = new aiNodeAnim(); |
| nd->mNodeName.Set(me->mName); |
| |
| // copy position keys |
| if (me->mAnim.akeyPositions.size() > 1 ) |
| { |
| // Allocate the key array and fill it |
| nd->mNumPositionKeys = (unsigned int) me->mAnim.akeyPositions.size(); |
| nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys]; |
| |
| ::memcpy(nd->mPositionKeys,&me->mAnim.akeyPositions[0], |
| nd->mNumPositionKeys * sizeof(aiVectorKey)); |
| } |
| // copy rotation keys |
| if (me->mAnim.akeyRotations.size() > 1 ) { |
| // Allocate the key array and fill it |
| nd->mNumRotationKeys = (unsigned int) me->mAnim.akeyRotations.size(); |
| nd->mRotationKeys = new aiQuatKey[nd->mNumRotationKeys]; |
| |
| // -------------------------------------------------------------------- |
| // Rotation keys are offsets to the previous keys. |
| // We have the quaternion representations of all |
| // of them, so we just need to concatenate all |
| // (unit-length) quaternions to get the absolute |
| // rotations. |
| // Rotation keys are ABSOLUTE for older files |
| // -------------------------------------------------------------------- |
| |
| aiQuaternion cur; |
| for (unsigned int a = 0; a < nd->mNumRotationKeys;++a) { |
| aiQuatKey q = me->mAnim.akeyRotations[a]; |
| |
| if (mParser->iFileFormat > 110) { |
| cur = (a ? cur*q.mValue : q.mValue); |
| q.mValue = cur.Normalize(); |
| } |
| nd->mRotationKeys[a] = q; |
| |
| // need this to get to Assimp quaternion conventions |
| nd->mRotationKeys[a].mValue.w *= -1.f; |
| } |
| } |
| // copy scaling keys |
| if (me->mAnim.akeyScaling.size() > 1 ) { |
| // Allocate the key array and fill it |
| nd->mNumScalingKeys = (unsigned int) me->mAnim.akeyScaling.size(); |
| nd->mScalingKeys = new aiVectorKey[nd->mNumScalingKeys]; |
| |
| ::memcpy(nd->mScalingKeys,&me->mAnim.akeyScaling[0], |
| nd->mNumScalingKeys * sizeof(aiVectorKey)); |
| } |
| } |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Build output cameras |
| void ASEImporter::BuildCameras() |
| { |
| if (!mParser->m_vCameras.empty()) { |
| pcScene->mNumCameras = (unsigned int)mParser->m_vCameras.size(); |
| pcScene->mCameras = new aiCamera*[pcScene->mNumCameras]; |
| |
| for (unsigned int i = 0; i < pcScene->mNumCameras;++i) { |
| aiCamera* out = pcScene->mCameras[i] = new aiCamera(); |
| ASE::Camera& in = mParser->m_vCameras[i]; |
| |
| // copy members |
| out->mClipPlaneFar = in.mFar; |
| out->mClipPlaneNear = (in.mNear ? in.mNear : 0.1f); |
| out->mHorizontalFOV = in.mFOV; |
| |
| out->mName.Set(in.mName); |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Build output lights |
| void ASEImporter::BuildLights() |
| { |
| if (!mParser->m_vLights.empty()) { |
| pcScene->mNumLights = (unsigned int)mParser->m_vLights.size(); |
| pcScene->mLights = new aiLight*[pcScene->mNumLights]; |
| |
| for (unsigned int i = 0; i < pcScene->mNumLights;++i) { |
| aiLight* out = pcScene->mLights[i] = new aiLight(); |
| ASE::Light& in = mParser->m_vLights[i]; |
| |
| // The direction is encoded in the transformation matrix of the node. |
| // In 3DS MAX the light source points into negative Z direction if |
| // the node transformation is the identity. |
| out->mDirection = aiVector3D(0.f,0.f,-1.f); |
| |
| out->mName.Set(in.mName); |
| switch (in.mLightType) |
| { |
| case ASE::Light::TARGET: |
| out->mType = aiLightSource_SPOT; |
| out->mAngleInnerCone = AI_DEG_TO_RAD(in.mAngle); |
| out->mAngleOuterCone = (in.mFalloff ? AI_DEG_TO_RAD(in.mFalloff) : out->mAngleInnerCone); |
| break; |
| |
| case ASE::Light::DIRECTIONAL: |
| out->mType = aiLightSource_DIRECTIONAL; |
| break; |
| |
| default: |
| //case ASE::Light::OMNI: |
| out->mType = aiLightSource_POINT; |
| break; |
| }; |
| out->mColorDiffuse = out->mColorSpecular = in.mColor * in.mIntensity; |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void ASEImporter::AddNodes(const std::vector<BaseNode*>& nodes, |
| aiNode* pcParent,const char* szName) |
| { |
| aiMatrix4x4 m; |
| AddNodes(nodes,pcParent,szName,m); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Add meshes to a given node |
| void ASEImporter::AddMeshes(const ASE::BaseNode* snode,aiNode* node) |
| { |
| for (unsigned int i = 0; i < pcScene->mNumMeshes;++i) { |
| // Get the name of the mesh (the mesh instance has been temporarily stored in the third vertex color) |
| const aiMesh* pcMesh = pcScene->mMeshes[i]; |
| const ASE::Mesh* mesh = (const ASE::Mesh*)pcMesh->mColors[2]; |
| |
| if (mesh == snode) { |
| ++node->mNumMeshes; |
| } |
| } |
| |
| if(node->mNumMeshes) { |
| node->mMeshes = new unsigned int[node->mNumMeshes]; |
| for (unsigned int i = 0, p = 0; i < pcScene->mNumMeshes;++i) { |
| |
| const aiMesh* pcMesh = pcScene->mMeshes[i]; |
| const ASE::Mesh* mesh = (const ASE::Mesh*)pcMesh->mColors[2]; |
| if (mesh == snode) { |
| node->mMeshes[p++] = i; |
| |
| // Transform all vertices of the mesh back into their local space -> |
| // at the moment they are pretransformed |
| aiMatrix4x4 m = mesh->mTransform; |
| m.Inverse(); |
| |
| aiVector3D* pvCurPtr = pcMesh->mVertices; |
| const aiVector3D* pvEndPtr = pvCurPtr + pcMesh->mNumVertices; |
| while (pvCurPtr != pvEndPtr) { |
| *pvCurPtr = m * (*pvCurPtr); |
| pvCurPtr++; |
| } |
| |
| // Do the same for the normal vectors, if we have them. |
| // As always, inverse transpose. |
| if (pcMesh->mNormals) { |
| aiMatrix3x3 m3 = aiMatrix3x3( mesh->mTransform ); |
| m3.Transpose(); |
| |
| pvCurPtr = pcMesh->mNormals; |
| pvEndPtr = pvCurPtr + pcMesh->mNumVertices; |
| while (pvCurPtr != pvEndPtr) { |
| *pvCurPtr = m3 * (*pvCurPtr); |
| pvCurPtr++; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Add child nodes to a given parent node |
| void ASEImporter::AddNodes (const std::vector<BaseNode*>& nodes, |
| aiNode* pcParent, const char* szName, |
| const aiMatrix4x4& mat) |
| { |
| const size_t len = szName ? ::strlen(szName) : 0; |
| ai_assert(4 <= AI_MAX_NUMBER_OF_COLOR_SETS); |
| |
| // Receives child nodes for the pcParent node |
| std::vector<aiNode*> apcNodes; |
| |
| // Now iterate through all nodes in the scene and search for one |
| // which has *us* as parent. |
| for (std::vector<BaseNode*>::const_iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) { |
| const BaseNode* snode = *it; |
| if (szName) { |
| if (len != snode->mParent.length() || ::strcmp(szName,snode->mParent.c_str())) |
| continue; |
| } |
| else if (snode->mParent.length()) |
| continue; |
| |
| (*it)->mProcessed = true; |
| |
| // Allocate a new node and add it to the output data structure |
| apcNodes.push_back(new aiNode()); |
| aiNode* node = apcNodes.back(); |
| |
| node->mName.Set((snode->mName.length() ? snode->mName.c_str() : "Unnamed_Node")); |
| node->mParent = pcParent; |
| |
| // Setup the transformation matrix of the node |
| aiMatrix4x4 mParentAdjust = mat; |
| mParentAdjust.Inverse(); |
| node->mTransformation = mParentAdjust*snode->mTransform; |
| |
| // Add sub nodes - prevent stack overflow due to recursive parenting |
| if (node->mName != node->mParent->mName) { |
| AddNodes(nodes,node,node->mName.data,snode->mTransform); |
| } |
| |
| // Further processing depends on the type of the node |
| if (snode->mType == ASE::BaseNode::Mesh) { |
| // If the type of this node is "Mesh" we need to search |
| // the list of output meshes in the data structure for |
| // all those that belonged to this node once. This is |
| // slightly inconvinient here and a better solution should |
| // be used when this code is refactored next. |
| AddMeshes(snode,node); |
| } |
| else if (is_not_qnan( snode->mTargetPosition.x )) { |
| // If this is a target camera or light we generate a small |
| // child node which marks the position of the camera |
| // target (the direction information is contained in *this* |
| // node's animation track but the exact target position |
| // would be lost otherwise) |
| if (!node->mNumChildren) { |
| node->mChildren = new aiNode*[1]; |
| } |
| |
| aiNode* nd = new aiNode(); |
| |
| nd->mName.Set ( snode->mName + ".Target" ); |
| |
| nd->mTransformation.a4 = snode->mTargetPosition.x - snode->mTransform.a4; |
| nd->mTransformation.b4 = snode->mTargetPosition.y - snode->mTransform.b4; |
| nd->mTransformation.c4 = snode->mTargetPosition.z - snode->mTransform.c4; |
| |
| nd->mParent = node; |
| |
| // The .Target node is always the first child node |
| for (unsigned int m = 0; m < node->mNumChildren;++m) |
| node->mChildren[m+1] = node->mChildren[m]; |
| |
| node->mChildren[0] = nd; |
| node->mNumChildren++; |
| |
| // What we did is so great, it is at least worth a debug message |
| DefaultLogger::get()->debug("ASE: Generating separate target node ("+snode->mName+")"); |
| } |
| } |
| |
| // Allocate enough space for the child nodes |
| // We allocate one slot more in case this is a target camera/light |
| pcParent->mNumChildren = (unsigned int)apcNodes.size(); |
| if (pcParent->mNumChildren) { |
| pcParent->mChildren = new aiNode*[apcNodes.size()+1 /* PLUS ONE !!! */]; |
| |
| // now build all nodes for our nice new children |
| for (unsigned int p = 0; p < apcNodes.size();++p) |
| pcParent->mChildren[p] = apcNodes[p]; |
| } |
| return; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Build the output node graph |
| void ASEImporter::BuildNodes(std::vector<BaseNode*>& nodes) { |
| ai_assert(NULL != pcScene); |
| |
| // allocate the one and only root node |
| aiNode* root = pcScene->mRootNode = new aiNode(); |
| root->mName.Set("<ASERoot>"); |
| |
| // Setup the coordinate system transformation |
| pcScene->mRootNode->mNumChildren = 1; |
| pcScene->mRootNode->mChildren = new aiNode*[1]; |
| aiNode* ch = pcScene->mRootNode->mChildren[0] = new aiNode(); |
| ch->mParent = root; |
| |
| // Change the transformation matrix of all nodes |
| for (BaseNode *node : nodes) { |
| aiMatrix4x4& m = node->mTransform; |
| m.Transpose(); // row-order vs column-order |
| } |
| |
| // add all nodes |
| AddNodes(nodes,ch,NULL); |
| |
| // now iterate through al nodes and find those that have not yet |
| // been added to the nodegraph (= their parent could not be recognized) |
| std::vector<const BaseNode*> aiList; |
| for (std::vector<BaseNode*>::iterator it = nodes.begin(), end = nodes.end();it != end; ++it) { |
| if ((*it)->mProcessed) { |
| continue; |
| } |
| |
| // check whether our parent is known |
| bool bKnowParent = false; |
| |
| // search the list another time, starting *here* and try to find out whether |
| // there is a node that references *us* as a parent |
| for (std::vector<BaseNode*>::const_iterator it2 = nodes.begin();it2 != end; ++it2) { |
| if (it2 == it) { |
| continue; |
| } |
| |
| if ((*it2)->mName == (*it)->mParent) { |
| bKnowParent = true; |
| break; |
| } |
| } |
| if (!bKnowParent) { |
| aiList.push_back(*it); |
| } |
| } |
| |
| // Are there ane orphaned nodes? |
| if (!aiList.empty()) { |
| std::vector<aiNode*> apcNodes; |
| apcNodes.reserve(aiList.size() + pcScene->mRootNode->mNumChildren); |
| |
| for (unsigned int i = 0; i < pcScene->mRootNode->mNumChildren;++i) |
| apcNodes.push_back(pcScene->mRootNode->mChildren[i]); |
| |
| delete[] pcScene->mRootNode->mChildren; |
| for (std::vector<const BaseNode*>::/*const_*/iterator i = aiList.begin();i != aiList.end();++i) { |
| const ASE::BaseNode* src = *i; |
| |
| // The parent is not known, so we can assume that we must add |
| // this node to the root node of the whole scene |
| aiNode* pcNode = new aiNode(); |
| pcNode->mParent = pcScene->mRootNode; |
| pcNode->mName.Set(src->mName); |
| AddMeshes(src,pcNode); |
| AddNodes(nodes,pcNode,pcNode->mName.data); |
| apcNodes.push_back(pcNode); |
| } |
| |
| // Regenerate our output array |
| pcScene->mRootNode->mChildren = new aiNode*[apcNodes.size()]; |
| for (unsigned int i = 0; i < apcNodes.size();++i) |
| pcScene->mRootNode->mChildren[i] = apcNodes[i]; |
| |
| pcScene->mRootNode->mNumChildren = (unsigned int)apcNodes.size(); |
| } |
| |
| // Reset the third color set to NULL - we used this field to store a temporary pointer |
| for (unsigned int i = 0; i < pcScene->mNumMeshes;++i) |
| pcScene->mMeshes[i]->mColors[2] = NULL; |
| |
| // The root node should not have at least one child or the file is valid |
| if (!pcScene->mRootNode->mNumChildren) { |
| throw DeadlyImportError("ASE: No nodes loaded. The file is either empty or corrupt"); |
| } |
| |
| // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system |
| pcScene->mRootNode->mTransformation = aiMatrix4x4(1.f,0.f,0.f,0.f, |
| 0.f,0.f,1.f,0.f,0.f,-1.f,0.f,0.f,0.f,0.f,0.f,1.f); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Convert the imported data to the internal verbose representation |
| void ASEImporter::BuildUniqueRepresentation(ASE::Mesh& mesh) { |
| // allocate output storage |
| std::vector<aiVector3D> mPositions; |
| std::vector<aiVector3D> amTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS]; |
| std::vector<aiColor4D> mVertexColors; |
| std::vector<aiVector3D> mNormals; |
| std::vector<BoneVertex> mBoneVertices; |
| |
| unsigned int iSize = (unsigned int)mesh.mFaces.size() * 3; |
| mPositions.resize(iSize); |
| |
| // optional texture coordinates |
| for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i) { |
| if (!mesh.amTexCoords[i].empty()) { |
| amTexCoords[i].resize(iSize); |
| } |
| } |
| // optional vertex colors |
| if (!mesh.mVertexColors.empty()) { |
| mVertexColors.resize(iSize); |
| } |
| |
| // optional vertex normals (vertex normals can simply be copied) |
| if (!mesh.mNormals.empty()) { |
| mNormals.resize(iSize); |
| } |
| // bone vertices. There is no need to change the bone list |
| if (!mesh.mBoneVertices.empty()) { |
| mBoneVertices.resize(iSize); |
| } |
| |
| // iterate through all faces in the mesh |
| unsigned int iCurrent = 0, fi = 0; |
| for (std::vector<ASE::Face>::iterator i = mesh.mFaces.begin();i != mesh.mFaces.end();++i,++fi) { |
| for (unsigned int n = 0; n < 3;++n,++iCurrent) |
| { |
| mPositions[iCurrent] = mesh.mPositions[(*i).mIndices[n]]; |
| |
| // add texture coordinates |
| for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c) { |
| if (mesh.amTexCoords[c].empty())break; |
| amTexCoords[c][iCurrent] = mesh.amTexCoords[c][(*i).amUVIndices[c][n]]; |
| } |
| // add vertex colors |
| if (!mesh.mVertexColors.empty()) { |
| mVertexColors[iCurrent] = mesh.mVertexColors[(*i).mColorIndices[n]]; |
| } |
| // add normal vectors |
| if (!mesh.mNormals.empty()) { |
| mNormals[iCurrent] = mesh.mNormals[fi*3+n]; |
| mNormals[iCurrent].Normalize(); |
| } |
| |
| // handle bone vertices |
| if ((*i).mIndices[n] < mesh.mBoneVertices.size()) { |
| // (sometimes this will cause bone verts to be duplicated |
| // however, I' quite sure Schrompf' JoinVerticesStep |
| // will fix that again ...) |
| mBoneVertices[iCurrent] = mesh.mBoneVertices[(*i).mIndices[n]]; |
| } |
| (*i).mIndices[n] = iCurrent; |
| } |
| } |
| |
| // replace the old arrays |
| mesh.mNormals = mNormals; |
| mesh.mPositions = mPositions; |
| mesh.mVertexColors = mVertexColors; |
| |
| for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c) |
| mesh.amTexCoords[c] = amTexCoords[c]; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Copy a texture from the ASE structs to the output material |
| void CopyASETexture(aiMaterial& mat, ASE::Texture& texture, aiTextureType type) |
| { |
| // Setup the texture name |
| aiString tex; |
| tex.Set( texture.mMapName); |
| mat.AddProperty( &tex, AI_MATKEY_TEXTURE(type,0)); |
| |
| // Setup the texture blend factor |
| if (is_not_qnan(texture.mTextureBlend)) |
| mat.AddProperty<ai_real>( &texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type,0)); |
| |
| // Setup texture UV transformations |
| mat.AddProperty<ai_real>(&texture.mOffsetU,5,AI_MATKEY_UVTRANSFORM(type,0)); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Convert from ASE material to output material |
| void ASEImporter::ConvertMaterial(ASE::Material& mat) |
| { |
| // LARGE TODO: Much code her is copied from 3DS ... join them maybe? |
| |
| // Allocate the output material |
| mat.pcInstance = new aiMaterial(); |
| |
| // At first add the base ambient color of the |
| // scene to the material |
| mat.mAmbient.r += mParser->m_clrAmbient.r; |
| mat.mAmbient.g += mParser->m_clrAmbient.g; |
| mat.mAmbient.b += mParser->m_clrAmbient.b; |
| |
| aiString name; |
| name.Set( mat.mName); |
| mat.pcInstance->AddProperty( &name, AI_MATKEY_NAME); |
| |
| // material colors |
| mat.pcInstance->AddProperty( &mat.mAmbient, 1, AI_MATKEY_COLOR_AMBIENT); |
| mat.pcInstance->AddProperty( &mat.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE); |
| mat.pcInstance->AddProperty( &mat.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR); |
| mat.pcInstance->AddProperty( &mat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE); |
| |
| // shininess |
| if (0.0f != mat.mSpecularExponent && 0.0f != mat.mShininessStrength) |
| { |
| mat.pcInstance->AddProperty( &mat.mSpecularExponent, 1, AI_MATKEY_SHININESS); |
| mat.pcInstance->AddProperty( &mat.mShininessStrength, 1, AI_MATKEY_SHININESS_STRENGTH); |
| } |
| // If there is no shininess, we can disable phong lighting |
| else if (D3DS::Discreet3DS::Metal == mat.mShading || |
| D3DS::Discreet3DS::Phong == mat.mShading || |
| D3DS::Discreet3DS::Blinn == mat.mShading) |
| { |
| mat.mShading = D3DS::Discreet3DS::Gouraud; |
| } |
| |
| // opacity |
| mat.pcInstance->AddProperty<ai_real>( &mat.mTransparency,1,AI_MATKEY_OPACITY); |
| |
| // Two sided rendering? |
| if (mat.mTwoSided) |
| { |
| int i = 1; |
| mat.pcInstance->AddProperty<int>(&i,1,AI_MATKEY_TWOSIDED); |
| } |
| |
| // shading mode |
| aiShadingMode eShading = aiShadingMode_NoShading; |
| switch (mat.mShading) |
| { |
| case D3DS::Discreet3DS::Flat: |
| eShading = aiShadingMode_Flat; break; |
| case D3DS::Discreet3DS::Phong : |
| eShading = aiShadingMode_Phong; break; |
| case D3DS::Discreet3DS::Blinn : |
| eShading = aiShadingMode_Blinn; break; |
| |
| // I don't know what "Wire" shading should be, |
| // assume it is simple lambertian diffuse (L dot N) shading |
| case D3DS::Discreet3DS::Wire: |
| { |
| // set the wireframe flag |
| unsigned int iWire = 1; |
| mat.pcInstance->AddProperty<int>( (int*)&iWire,1,AI_MATKEY_ENABLE_WIREFRAME); |
| } |
| case D3DS::Discreet3DS::Gouraud: |
| eShading = aiShadingMode_Gouraud; break; |
| case D3DS::Discreet3DS::Metal : |
| eShading = aiShadingMode_CookTorrance; break; |
| } |
| mat.pcInstance->AddProperty<int>( (int*)&eShading,1,AI_MATKEY_SHADING_MODEL); |
| |
| // DIFFUSE texture |
| if( mat.sTexDiffuse.mMapName.length() > 0) |
| CopyASETexture(*mat.pcInstance,mat.sTexDiffuse, aiTextureType_DIFFUSE); |
| |
| // SPECULAR texture |
| if( mat.sTexSpecular.mMapName.length() > 0) |
| CopyASETexture(*mat.pcInstance,mat.sTexSpecular, aiTextureType_SPECULAR); |
| |
| // AMBIENT texture |
| if( mat.sTexAmbient.mMapName.length() > 0) |
| CopyASETexture(*mat.pcInstance,mat.sTexAmbient, aiTextureType_AMBIENT); |
| |
| // OPACITY texture |
| if( mat.sTexOpacity.mMapName.length() > 0) |
| CopyASETexture(*mat.pcInstance,mat.sTexOpacity, aiTextureType_OPACITY); |
| |
| // EMISSIVE texture |
| if( mat.sTexEmissive.mMapName.length() > 0) |
| CopyASETexture(*mat.pcInstance,mat.sTexEmissive, aiTextureType_EMISSIVE); |
| |
| // BUMP texture |
| if( mat.sTexBump.mMapName.length() > 0) |
| CopyASETexture(*mat.pcInstance,mat.sTexBump, aiTextureType_HEIGHT); |
| |
| // SHININESS texture |
| if( mat.sTexShininess.mMapName.length() > 0) |
| CopyASETexture(*mat.pcInstance,mat.sTexShininess, aiTextureType_SHININESS); |
| |
| // store the name of the material itself, too |
| if( mat.mName.length() > 0) { |
| aiString tex;tex.Set( mat.mName); |
| mat.pcInstance->AddProperty( &tex, AI_MATKEY_NAME); |
| } |
| return; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Build output meshes |
| void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMeshes) |
| { |
| // validate the material index of the mesh |
| if (mesh.iMaterialIndex >= mParser->m_vMaterials.size()) { |
| mesh.iMaterialIndex = (unsigned int)mParser->m_vMaterials.size()-1; |
| DefaultLogger::get()->warn("Material index is out of range"); |
| } |
| |
| // If the material the mesh is assigned to is consisting of submeshes, split it |
| if (!mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials.empty()) { |
| std::vector<ASE::Material> vSubMaterials = mParser-> |
| m_vMaterials[mesh.iMaterialIndex].avSubMaterials; |
| |
| std::vector<unsigned int>* aiSplit = new std::vector<unsigned int>[vSubMaterials.size()]; |
| |
| // build a list of all faces per submaterial |
| for (unsigned int i = 0; i < mesh.mFaces.size();++i) { |
| // check range |
| if (mesh.mFaces[i].iMaterial >= vSubMaterials.size()) { |
| DefaultLogger::get()->warn("Submaterial index is out of range"); |
| |
| // use the last material instead |
| aiSplit[vSubMaterials.size()-1].push_back(i); |
| } |
| else aiSplit[mesh.mFaces[i].iMaterial].push_back(i); |
| } |
| |
| // now generate submeshes |
| for (unsigned int p = 0; p < vSubMaterials.size();++p) { |
| if (!aiSplit[p].empty()) { |
| |
| aiMesh* p_pcOut = new aiMesh(); |
| p_pcOut->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; |
| |
| // let the sub material index |
| p_pcOut->mMaterialIndex = p; |
| |
| // we will need this material |
| mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials[p].bNeed = true; |
| |
| // store the real index here ... color channel 3 |
| p_pcOut->mColors[3] = (aiColor4D*)(uintptr_t)mesh.iMaterialIndex; |
| |
| // store a pointer to the mesh in color channel 2 |
| p_pcOut->mColors[2] = (aiColor4D*) &mesh; |
| avOutMeshes.push_back(p_pcOut); |
| |
| // convert vertices |
| p_pcOut->mNumVertices = (unsigned int)aiSplit[p].size()*3; |
| p_pcOut->mNumFaces = (unsigned int)aiSplit[p].size(); |
| |
| // receive output vertex weights |
| std::vector<std::pair<unsigned int, float> > *avOutputBones = NULL; |
| if (!mesh.mBones.empty()) { |
| avOutputBones = new std::vector<std::pair<unsigned int, float> >[mesh.mBones.size()]; |
| } |
| |
| // allocate enough storage for faces |
| p_pcOut->mFaces = new aiFace[p_pcOut->mNumFaces]; |
| |
| unsigned int iBase = 0,iIndex; |
| if (p_pcOut->mNumVertices) { |
| p_pcOut->mVertices = new aiVector3D[p_pcOut->mNumVertices]; |
| p_pcOut->mNormals = new aiVector3D[p_pcOut->mNumVertices]; |
| for (unsigned int q = 0; q < aiSplit[p].size();++q) { |
| |
| iIndex = aiSplit[p][q]; |
| |
| p_pcOut->mFaces[q].mIndices = new unsigned int[3]; |
| p_pcOut->mFaces[q].mNumIndices = 3; |
| |
| for (unsigned int t = 0; t < 3;++t, ++iBase) { |
| const uint32_t iIndex2 = mesh.mFaces[iIndex].mIndices[t]; |
| |
| p_pcOut->mVertices[iBase] = mesh.mPositions [iIndex2]; |
| p_pcOut->mNormals [iBase] = mesh.mNormals [iIndex2]; |
| |
| // convert bones, if existing |
| if (!mesh.mBones.empty()) { |
| ai_assert(avOutputBones); |
| // check whether there is a vertex weight for this vertex index |
| if (iIndex2 < mesh.mBoneVertices.size()) { |
| |
| for (std::vector<std::pair<int,float> >::const_iterator |
| blubb = mesh.mBoneVertices[iIndex2].mBoneWeights.begin(); |
| blubb != mesh.mBoneVertices[iIndex2].mBoneWeights.end();++blubb) { |
| |
| // NOTE: illegal cases have already been filtered out |
| avOutputBones[(*blubb).first].push_back(std::pair<unsigned int, float>( |
| iBase,(*blubb).second)); |
| } |
| } |
| } |
| p_pcOut->mFaces[q].mIndices[t] = iBase; |
| } |
| } |
| } |
| // convert texture coordinates (up to AI_MAX_NUMBER_OF_TEXTURECOORDS sets supported) |
| for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c) { |
| if (!mesh.amTexCoords[c].empty()) |
| { |
| p_pcOut->mTextureCoords[c] = new aiVector3D[p_pcOut->mNumVertices]; |
| iBase = 0; |
| for (unsigned int q = 0; q < aiSplit[p].size();++q) { |
| iIndex = aiSplit[p][q]; |
| for (unsigned int t = 0; t < 3;++t) { |
| p_pcOut->mTextureCoords[c][iBase++] = mesh.amTexCoords[c][mesh.mFaces[iIndex].mIndices[t]]; |
| } |
| } |
| // Setup the number of valid vertex components |
| p_pcOut->mNumUVComponents[c] = mesh.mNumUVComponents[c]; |
| } |
| } |
| |
| // Convert vertex colors (only one set supported) |
| if (!mesh.mVertexColors.empty()){ |
| p_pcOut->mColors[0] = new aiColor4D[p_pcOut->mNumVertices]; |
| iBase = 0; |
| for (unsigned int q = 0; q < aiSplit[p].size();++q) { |
| iIndex = aiSplit[p][q]; |
| for (unsigned int t = 0; t < 3;++t) { |
| p_pcOut->mColors[0][iBase++] = mesh.mVertexColors[mesh.mFaces[iIndex].mIndices[t]]; |
| } |
| } |
| } |
| // Copy bones |
| if (!mesh.mBones.empty()) { |
| p_pcOut->mNumBones = 0; |
| for (unsigned int mrspock = 0; mrspock < mesh.mBones.size();++mrspock) |
| if (!avOutputBones[mrspock].empty())p_pcOut->mNumBones++; |
| |
| p_pcOut->mBones = new aiBone* [ p_pcOut->mNumBones ]; |
| aiBone** pcBone = p_pcOut->mBones; |
| for (unsigned int mrspock = 0; mrspock < mesh.mBones.size();++mrspock) |
| { |
| if (!avOutputBones[mrspock].empty()) { |
| // we will need this bone. add it to the output mesh and |
| // add all per-vertex weights |
| aiBone* pc = *pcBone = new aiBone(); |
| pc->mName.Set(mesh.mBones[mrspock].mName); |
| |
| pc->mNumWeights = (unsigned int)avOutputBones[mrspock].size(); |
| pc->mWeights = new aiVertexWeight[pc->mNumWeights]; |
| |
| for (unsigned int captainkirk = 0; captainkirk < pc->mNumWeights;++captainkirk) |
| { |
| const std::pair<unsigned int,float>& ref = avOutputBones[mrspock][captainkirk]; |
| pc->mWeights[captainkirk].mVertexId = ref.first; |
| pc->mWeights[captainkirk].mWeight = ref.second; |
| } |
| ++pcBone; |
| } |
| } |
| // delete allocated storage |
| delete[] avOutputBones; |
| } |
| } |
| } |
| // delete storage |
| delete[] aiSplit; |
| } |
| else |
| { |
| // Otherwise we can simply copy the data to one output mesh |
| // This codepath needs less memory and uses fast memcpy()s |
| // to do the actual copying. So I think it is worth the |
| // effort here. |
| |
| aiMesh* p_pcOut = new aiMesh(); |
| p_pcOut->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; |
| |
| // set an empty sub material index |
| p_pcOut->mMaterialIndex = ASE::Face::DEFAULT_MATINDEX; |
| mParser->m_vMaterials[mesh.iMaterialIndex].bNeed = true; |
| |
| // store the real index here ... in color channel 3 |
| p_pcOut->mColors[3] = (aiColor4D*)(uintptr_t)mesh.iMaterialIndex; |
| |
| // store a pointer to the mesh in color channel 2 |
| p_pcOut->mColors[2] = (aiColor4D*) &mesh; |
| avOutMeshes.push_back(p_pcOut); |
| |
| // If the mesh hasn't faces or vertices, there are two cases |
| // possible: 1. the model is invalid. 2. This is a dummy |
| // helper object which we are going to remove later ... |
| if (mesh.mFaces.empty() || mesh.mPositions.empty()) { |
| return; |
| } |
| |
| // convert vertices |
| p_pcOut->mNumVertices = (unsigned int)mesh.mPositions.size(); |
| p_pcOut->mNumFaces = (unsigned int)mesh.mFaces.size(); |
| |
| // allocate enough storage for faces |
| p_pcOut->mFaces = new aiFace[p_pcOut->mNumFaces]; |
| |
| // copy vertices |
| p_pcOut->mVertices = new aiVector3D[mesh.mPositions.size()]; |
| memcpy(p_pcOut->mVertices,&mesh.mPositions[0], |
| mesh.mPositions.size() * sizeof(aiVector3D)); |
| |
| // copy normals |
| p_pcOut->mNormals = new aiVector3D[mesh.mNormals.size()]; |
| memcpy(p_pcOut->mNormals,&mesh.mNormals[0], |
| mesh.mNormals.size() * sizeof(aiVector3D)); |
| |
| // copy texture coordinates |
| for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c) { |
| if (!mesh.amTexCoords[c].empty()) { |
| p_pcOut->mTextureCoords[c] = new aiVector3D[mesh.amTexCoords[c].size()]; |
| memcpy(p_pcOut->mTextureCoords[c],&mesh.amTexCoords[c][0], |
| mesh.amTexCoords[c].size() * sizeof(aiVector3D)); |
| |
| // setup the number of valid vertex components |
| p_pcOut->mNumUVComponents[c] = mesh.mNumUVComponents[c]; |
| } |
| } |
| |
| // copy vertex colors |
| if (!mesh.mVertexColors.empty()) { |
| p_pcOut->mColors[0] = new aiColor4D[mesh.mVertexColors.size()]; |
| memcpy(p_pcOut->mColors[0],&mesh.mVertexColors[0], |
| mesh.mVertexColors.size() * sizeof(aiColor4D)); |
| } |
| |
| // copy faces |
| for (unsigned int iFace = 0; iFace < p_pcOut->mNumFaces;++iFace) { |
| p_pcOut->mFaces[iFace].mNumIndices = 3; |
| p_pcOut->mFaces[iFace].mIndices = new unsigned int[3]; |
| |
| // copy indices |
| p_pcOut->mFaces[iFace].mIndices[0] = mesh.mFaces[iFace].mIndices[0]; |
| p_pcOut->mFaces[iFace].mIndices[1] = mesh.mFaces[iFace].mIndices[1]; |
| p_pcOut->mFaces[iFace].mIndices[2] = mesh.mFaces[iFace].mIndices[2]; |
| } |
| |
| // copy vertex bones |
| if (!mesh.mBones.empty() && !mesh.mBoneVertices.empty()) { |
| std::vector<std::vector<aiVertexWeight> > avBonesOut( mesh.mBones.size() ); |
| |
| // find all vertex weights for this bone |
| unsigned int quak = 0; |
| for (std::vector<BoneVertex>::const_iterator harrypotter = mesh.mBoneVertices.begin(); |
| harrypotter != mesh.mBoneVertices.end();++harrypotter,++quak) { |
| |
| for (std::vector<std::pair<int,float> >::const_iterator |
| ronaldweasley = (*harrypotter).mBoneWeights.begin(); |
| ronaldweasley != (*harrypotter).mBoneWeights.end();++ronaldweasley) |
| { |
| aiVertexWeight weight; |
| weight.mVertexId = quak; |
| weight.mWeight = (*ronaldweasley).second; |
| avBonesOut[(*ronaldweasley).first].push_back(weight); |
| } |
| } |
| |
| // now build a final bone list |
| p_pcOut->mNumBones = 0; |
| for (unsigned int jfkennedy = 0; jfkennedy < mesh.mBones.size();++jfkennedy) |
| if (!avBonesOut[jfkennedy].empty())p_pcOut->mNumBones++; |
| |
| p_pcOut->mBones = new aiBone*[p_pcOut->mNumBones]; |
| aiBone** pcBone = p_pcOut->mBones; |
| for (unsigned int jfkennedy = 0; jfkennedy < mesh.mBones.size();++jfkennedy) { |
| if (!avBonesOut[jfkennedy].empty()) { |
| aiBone* pc = *pcBone = new aiBone(); |
| pc->mName.Set(mesh.mBones[jfkennedy].mName); |
| pc->mNumWeights = (unsigned int)avBonesOut[jfkennedy].size(); |
| pc->mWeights = new aiVertexWeight[pc->mNumWeights]; |
| ::memcpy(pc->mWeights,&avBonesOut[jfkennedy][0], |
| sizeof(aiVertexWeight) * pc->mNumWeights); |
| ++pcBone; |
| } |
| } |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Setup proper material indices and build output materials |
| void ASEImporter::BuildMaterialIndices() |
| { |
| ai_assert(NULL != pcScene); |
| |
| // iterate through all materials and check whether we need them |
| for (unsigned int iMat = 0; iMat < mParser->m_vMaterials.size();++iMat) |
| { |
| ASE::Material& mat = mParser->m_vMaterials[iMat]; |
| if (mat.bNeed) { |
| // Convert it to the aiMaterial layout |
| ConvertMaterial(mat); |
| ++pcScene->mNumMaterials; |
| } |
| for (unsigned int iSubMat = 0; iSubMat < mat.avSubMaterials.size();++iSubMat) |
| { |
| ASE::Material& submat = mat.avSubMaterials[iSubMat]; |
| if (submat.bNeed) { |
| // Convert it to the aiMaterial layout |
| ConvertMaterial(submat); |
| ++pcScene->mNumMaterials; |
| } |
| } |
| } |
| |
| // allocate the output material array |
| pcScene->mMaterials = new aiMaterial*[pcScene->mNumMaterials]; |
| D3DS::Material** pcIntMaterials = new D3DS::Material*[pcScene->mNumMaterials]; |
| |
| unsigned int iNum = 0; |
| for (unsigned int iMat = 0; iMat < mParser->m_vMaterials.size();++iMat) { |
| ASE::Material& mat = mParser->m_vMaterials[iMat]; |
| if (mat.bNeed) |
| { |
| ai_assert(NULL != mat.pcInstance); |
| pcScene->mMaterials[iNum] = mat.pcInstance; |
| |
| // Store the internal material, too |
| pcIntMaterials[iNum] = &mat; |
| |
| // Iterate through all meshes and search for one which is using |
| // this top-level material index |
| for (unsigned int iMesh = 0; iMesh < pcScene->mNumMeshes;++iMesh) |
| { |
| aiMesh* mesh = pcScene->mMeshes[iMesh]; |
| if (ASE::Face::DEFAULT_MATINDEX == mesh->mMaterialIndex && |
| iMat == (uintptr_t)mesh->mColors[3]) |
| { |
| mesh->mMaterialIndex = iNum; |
| mesh->mColors[3] = NULL; |
| } |
| } |
| iNum++; |
| } |
| for (unsigned int iSubMat = 0; iSubMat < mat.avSubMaterials.size();++iSubMat) { |
| ASE::Material& submat = mat.avSubMaterials[iSubMat]; |
| if (submat.bNeed) { |
| ai_assert(NULL != submat.pcInstance); |
| pcScene->mMaterials[iNum] = submat.pcInstance; |
| |
| // Store the internal material, too |
| pcIntMaterials[iNum] = &submat; |
| |
| // Iterate through all meshes and search for one which is using |
| // this sub-level material index |
| for (unsigned int iMesh = 0; iMesh < pcScene->mNumMeshes;++iMesh) { |
| aiMesh* mesh = pcScene->mMeshes[iMesh]; |
| |
| if (iSubMat == mesh->mMaterialIndex && iMat == (uintptr_t)mesh->mColors[3]) { |
| mesh->mMaterialIndex = iNum; |
| mesh->mColors[3] = NULL; |
| } |
| } |
| iNum++; |
| } |
| } |
| } |
| |
| // Dekete our temporary array |
| delete[] pcIntMaterials; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Generate normal vectors basing on smoothing groups |
| bool ASEImporter::GenerateNormals(ASE::Mesh& mesh) { |
| |
| if (!mesh.mNormals.empty() && !configRecomputeNormals) |
| { |
| // Check whether there are only uninitialized normals. If there are |
| // some, skip all normals from the file and compute them on our own |
| for (std::vector<aiVector3D>::const_iterator qq = mesh.mNormals.begin();qq != mesh.mNormals.end();++qq) { |
| if ((*qq).x || (*qq).y || (*qq).z) |
| { |
| return true; |
| } |
| } |
| } |
| // The array is reused. |
| ComputeNormalsWithSmoothingsGroups<ASE::Face>(mesh); |
| return false; |
| } |
| |
| #endif // ASSIMP_BUILD_NO_3DS_IMPORTER |
| |
| #endif // !! ASSIMP_BUILD_NO_BASE_IMPORTER |
