diff options
Diffstat (limited to 'libs/assimp/code/AssetLib/ASE')
| -rw-r--r-- | libs/assimp/code/AssetLib/ASE/ASELoader.cpp | 1288 | ||||
| -rw-r--r-- | libs/assimp/code/AssetLib/ASE/ASELoader.h | 192 | ||||
| -rw-r--r-- | libs/assimp/code/AssetLib/ASE/ASEParser.cpp | 1869 | ||||
| -rw-r--r-- | libs/assimp/code/AssetLib/ASE/ASEParser.h | 676 |
4 files changed, 0 insertions, 4025 deletions
diff --git a/libs/assimp/code/AssetLib/ASE/ASELoader.cpp b/libs/assimp/code/AssetLib/ASE/ASELoader.cpp deleted file mode 100644 index caa7089..0000000 --- a/libs/assimp/code/AssetLib/ASE/ASELoader.cpp +++ /dev/null @@ -1,1288 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (assimp) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2022, 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 "Common/TargetAnimation.h" -#include <assimp/SkeletonMeshBuilder.h> -#include <assimp/StringComparison.h> - -#include <assimp/importerdesc.h> -#include <assimp/scene.h> -#include <assimp/DefaultLogger.hpp> -#include <assimp/IOSystem.hpp> -#include <assimp/Importer.hpp> - -#include <memory> - -// utilities -#include <assimp/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() { - // empty -} - -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -ASEImporter::~ASEImporter() { - // empty -} - -// ------------------------------------------------------------------------------------------------ -// Returns whether the class can handle the format of the given file. -bool ASEImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { - static const char *tokens[] = { "*3dsmax_asciiexport" }; - return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); -} - -// ------------------------------------------------------------------------------------------------ -// 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() == nullptr) { - 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) { - ASSIMP_LOG_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(nullptr != 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(AI_DEFAULT_MATERIAL_NAME)); - 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; - } -} - -// ------------------------------------------------------------------------------------------------ -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) { - ASSIMP_LOG_WARN("ASE: Position controller uses Bezier/TCB keys. " - "This is not supported."); - } - if ((*i)->mAnim.mRotationType != ASE::Animation::TRACK) { - ASSIMP_LOG_WARN("ASE: Rotation controller uses Bezier/TCB keys. " - "This is not supported."); - } - if ((*i)->mAnim.mScalingType != ASE::Animation::TRACK) { - ASSIMP_LOG_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 && node->mName != node->mParent->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 - ASSIMP_LOG_VERBOSE_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(nullptr != 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, nullptr); - - // 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 any 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 nullptr - we used this field to store a temporary pointer - for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i) - pcScene->mMeshes[i]->mColors[2] = nullptr; - - // 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; - ASSIMP_LOG_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 sub-material - for (unsigned int i = 0; i < mesh.mFaces.size(); ++i) { - // check range - if (mesh.mFaces[i].iMaterial >= vSubMaterials.size()) { - ASSIMP_LOG_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 = nullptr; - 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(nullptr != 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(nullptr != 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] = nullptr; - } - } - iNum++; - } - for (unsigned int iSubMat = 0; iSubMat < mat.avSubMaterials.size(); ++iSubMat) { - ASE::Material &submat = mat.avSubMaterials[iSubMat]; - if (submat.bNeed) { - ai_assert(nullptr != 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] = nullptr; - } - } - iNum++; - } - } - } - - // Delete 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 diff --git a/libs/assimp/code/AssetLib/ASE/ASELoader.h b/libs/assimp/code/AssetLib/ASE/ASELoader.h deleted file mode 100644 index cd91235..0000000 --- a/libs/assimp/code/AssetLib/ASE/ASELoader.h +++ /dev/null @@ -1,192 +0,0 @@ -/* -Open Asset Import Library (assimp) ----------------------------------------------------------------------- - -Copyright (c) 2006-2022, 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.h - * @brief Definition of the .ASE importer class. - */ -#ifndef AI_ASELOADER_H_INCLUDED -#define AI_ASELOADER_H_INCLUDED - -#include <assimp/BaseImporter.h> -#include <assimp/types.h> -#include "ASEParser.h" - -struct aiNode; - -namespace Assimp { - -#ifndef ASSIMP_BUILD_NO_3DS_IMPORTER - -// -------------------------------------------------------------------------------- -/** Importer class for the 3DS ASE ASCII format. - * - */ -class ASEImporter : public BaseImporter { -public: - ASEImporter(); - ~ASEImporter() override; - - // ------------------------------------------------------------------- - /** Returns whether the class can handle the format of the given file. - * See BaseImporter::CanRead() for details. - */ - bool CanRead( const std::string& pFile, IOSystem* pIOHandler, - bool checkSig) const override; - -protected: - // ------------------------------------------------------------------- - /** Return importer meta information. - * See #BaseImporter::GetInfo for the details - */ - const aiImporterDesc* GetInfo () const override; - - // ------------------------------------------------------------------- - /** Imports the given file into the given scene structure. - * See BaseImporter::InternReadFile() for details - */ - void InternReadFile( const std::string& pFile, aiScene* pScene, - IOSystem* pIOHandler) override; - - // ------------------------------------------------------------------- - /** Called prior to ReadFile(). - * The function is a request to the importer to update its configuration - * basing on the Importer's configuration property list. - */ - void SetupProperties(const Importer* pImp) override; - -private: - // ------------------------------------------------------------------- - /** Generate normal vectors basing on smoothing groups - * (in some cases the normal are already contained in the file) - * \param mesh Mesh to work on - * \return false if the normals have been recomputed - */ - bool GenerateNormals(ASE::Mesh& mesh); - - // ------------------------------------------------------------------- - /** Create valid vertex/normal/UV/color/face lists. - * All elements are unique, faces have only one set of indices - * after this step occurs. - * \param mesh Mesh to work on - */ - void BuildUniqueRepresentation(ASE::Mesh& mesh); - - /** Create one-material-per-mesh meshes ;-) - * \param mesh Mesh to work with - * \param Receives the list of all created meshes - */ - void ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOut); - - // ------------------------------------------------------------------- - /** Convert a material to a aiMaterial object - * \param mat Input material - */ - void ConvertMaterial(ASE::Material& mat); - - // ------------------------------------------------------------------- - /** Setup the final material indices for each mesh - */ - void BuildMaterialIndices(); - - // ------------------------------------------------------------------- - /** Build the node graph - */ - void BuildNodes(std::vector<ASE::BaseNode*>& nodes); - - // ------------------------------------------------------------------- - /** Build output cameras - */ - void BuildCameras(); - - // ------------------------------------------------------------------- - /** Build output lights - */ - void BuildLights(); - - // ------------------------------------------------------------------- - /** Build output animations - */ - void BuildAnimations(const std::vector<ASE::BaseNode*>& nodes); - - // ------------------------------------------------------------------- - /** Add sub nodes to a node - * \param pcParent parent node to be filled - * \param szName Name of the parent node - * \param matrix Current transform - */ - void AddNodes(const std::vector<ASE::BaseNode*>& nodes, - aiNode* pcParent,const char* szName); - - void AddNodes(const std::vector<ASE::BaseNode*>& nodes, - aiNode* pcParent,const char* szName, - const aiMatrix4x4& matrix); - - void AddMeshes(const ASE::BaseNode* snode,aiNode* node); - - // ------------------------------------------------------------------- - /** Generate a default material and add it to the parser's list - * Called if no material has been found in the file (rare for ASE, - * but not impossible) - */ - void GenerateDefaultMaterial(); - -protected: - /** Parser instance */ - ASE::Parser* mParser; - - /** Buffer to hold the loaded file */ - char* mBuffer; - - /** Scene to be filled */ - aiScene* pcScene; - - /** Config options: Recompute the normals in every case - WA - for 3DS Max broken ASE normal export */ - bool configRecomputeNormals; - bool noSkeletonMesh; -}; - -#endif // ASSIMP_BUILD_NO_3DS_IMPORTER - -} // end of namespace Assimp - - -#endif // AI_3DSIMPORTER_H_INC diff --git a/libs/assimp/code/AssetLib/ASE/ASEParser.cpp b/libs/assimp/code/AssetLib/ASE/ASEParser.cpp deleted file mode 100644 index 14eb720..0000000 --- a/libs/assimp/code/AssetLib/ASE/ASEParser.cpp +++ /dev/null @@ -1,1869 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (assimp) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2022, 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 ASEParser.cpp - * @brief Implementation of the ASE parser class - */ - -#ifndef ASSIMP_BUILD_NO_ASE_IMPORTER -#ifndef ASSIMP_BUILD_NO_3DS_IMPORTER - -// internal headers -#include "ASELoader.h" -#include "PostProcessing/TextureTransform.h" - -#include <assimp/fast_atof.h> -#include <assimp/DefaultLogger.hpp> - -using namespace Assimp; -using namespace Assimp::ASE; - -// ------------------------------------------------------------------------------------------------ -// Begin an ASE parsing function - -#define AI_ASE_PARSER_INIT() \ - int iDepth = 0; - -// ------------------------------------------------------------------------------------------------ -// Handle a "top-level" section in the file. EOF is no error in this case. - -#define AI_ASE_HANDLE_TOP_LEVEL_SECTION() \ - else if ('{' == *filePtr) iDepth++; \ - else if ('}' == *filePtr) { \ - if (0 == --iDepth) { \ - ++filePtr; \ - SkipToNextToken(); \ - return; \ - } \ - } \ - else if ('\0' == *filePtr) { \ - return; \ - } \ - if (IsLineEnd(*filePtr) && !bLastWasEndLine) { \ - ++iLineNumber; \ - bLastWasEndLine = true; \ - } else \ - bLastWasEndLine = false; \ - ++filePtr; - -// ------------------------------------------------------------------------------------------------ -// Handle a nested section in the file. EOF is an error in this case -// @param level "Depth" of the section -// @param msg Full name of the section (including the asterisk) - -#define AI_ASE_HANDLE_SECTION(level, msg) \ - if ('{' == *filePtr) \ - iDepth++; \ - else if ('}' == *filePtr) { \ - if (0 == --iDepth) { \ - ++filePtr; \ - SkipToNextToken(); \ - return; \ - } \ - } else if ('\0' == *filePtr) { \ - LogError("Encountered unexpected EOL while parsing a " msg \ - " chunk (Level " level ")"); \ - } \ - if (IsLineEnd(*filePtr) && !bLastWasEndLine) { \ - ++iLineNumber; \ - bLastWasEndLine = true; \ - } else \ - bLastWasEndLine = false; \ - ++filePtr; - -// ------------------------------------------------------------------------------------------------ -Parser::Parser(const char *szFile, unsigned int fileFormatDefault) { - ai_assert(nullptr != szFile); - - filePtr = szFile; - iFileFormat = fileFormatDefault; - - // make sure that the color values are invalid - m_clrBackground.r = get_qnan(); - m_clrAmbient.r = get_qnan(); - - // setup some default values - iLineNumber = 0; - iFirstFrame = 0; - iLastFrame = 0; - iFrameSpeed = 30; // use 30 as default value for this property - iTicksPerFrame = 1; // use 1 as default value for this property - bLastWasEndLine = false; // need to handle \r\n seqs due to binary file mapping -} - -// ------------------------------------------------------------------------------------------------ -void Parser::LogWarning(const char *szWarn) { - ai_assert(nullptr != szWarn); - - char szTemp[2048]; -#if _MSC_VER >= 1400 - sprintf_s(szTemp, "Line %u: %s", iLineNumber, szWarn); -#else - ai_snprintf(szTemp, sizeof(szTemp), "Line %u: %s", iLineNumber, szWarn); -#endif - - // output the warning to the logger ... - ASSIMP_LOG_WARN(szTemp); -} - -// ------------------------------------------------------------------------------------------------ -void Parser::LogInfo(const char *szWarn) { - ai_assert(nullptr != szWarn); - - char szTemp[1024]; -#if _MSC_VER >= 1400 - sprintf_s(szTemp, "Line %u: %s", iLineNumber, szWarn); -#else - ai_snprintf(szTemp, 1024, "Line %u: %s", iLineNumber, szWarn); -#endif - - // output the information to the logger ... - ASSIMP_LOG_INFO(szTemp); -} - -// ------------------------------------------------------------------------------------------------ -AI_WONT_RETURN void Parser::LogError(const char *szWarn) { - ai_assert(nullptr != szWarn); - - char szTemp[1024]; -#if _MSC_VER >= 1400 - sprintf_s(szTemp, "Line %u: %s", iLineNumber, szWarn); -#else - ai_snprintf(szTemp, 1024, "Line %u: %s", iLineNumber, szWarn); -#endif - - // throw an exception - throw DeadlyImportError(szTemp); -} - -// ------------------------------------------------------------------------------------------------ -bool Parser::SkipToNextToken() { - while (true) { - char me = *filePtr; - - // increase the line number counter if necessary - if (IsLineEnd(me) && !bLastWasEndLine) { - ++iLineNumber; - bLastWasEndLine = true; - } else - bLastWasEndLine = false; - if ('*' == me || '}' == me || '{' == me) return true; - if ('\0' == me) return false; - - ++filePtr; - } -} - -// ------------------------------------------------------------------------------------------------ -bool Parser::SkipSection() { - // must handle subsections ... - int iCnt = 0; - while (true) { - if ('}' == *filePtr) { - --iCnt; - if (0 == iCnt) { - // go to the next valid token ... - ++filePtr; - SkipToNextToken(); - return true; - } - } else if ('{' == *filePtr) { - ++iCnt; - } else if ('\0' == *filePtr) { - LogWarning("Unable to parse block: Unexpected EOF, closing bracket \'}\' was expected [#1]"); - return false; - } else if (IsLineEnd(*filePtr)) - ++iLineNumber; - ++filePtr; - } -} - -// ------------------------------------------------------------------------------------------------ -void Parser::Parse() { - AI_ASE_PARSER_INIT(); - while (true) { - if ('*' == *filePtr) { - ++filePtr; - - // Version should be 200. Validate this ... - if (TokenMatch(filePtr, "3DSMAX_ASCIIEXPORT", 18)) { - unsigned int fmt; - ParseLV4MeshLong(fmt); - - if (fmt > 200) { - LogWarning("Unknown file format version: *3DSMAX_ASCIIEXPORT should \ - be <= 200"); - } - // ************************************************************* - // - fmt will be 0 if we're unable to read the version number - // there are some faulty files without a version number ... - // in this case we'll guess the exact file format by looking - // at the file extension (ASE, ASK, ASC) - // ************************************************************* - - if (fmt) { - iFileFormat = fmt; - } - continue; - } - // main scene information - if (TokenMatch(filePtr, "SCENE", 5)) { - ParseLV1SceneBlock(); - continue; - } - // "group" - no implementation yet, in facte - // we're just ignoring them for the moment - if (TokenMatch(filePtr, "GROUP", 5)) { - Parse(); - continue; - } - // material list - if (TokenMatch(filePtr, "MATERIAL_LIST", 13)) { - ParseLV1MaterialListBlock(); - continue; - } - // geometric object (mesh) - if (TokenMatch(filePtr, "GEOMOBJECT", 10)) - - { - m_vMeshes.push_back(Mesh("UNNAMED")); - ParseLV1ObjectBlock(m_vMeshes.back()); - continue; - } - // helper object = dummy in the hierarchy - if (TokenMatch(filePtr, "HELPEROBJECT", 12)) - - { - m_vDummies.push_back(Dummy()); - ParseLV1ObjectBlock(m_vDummies.back()); - continue; - } - // light object - if (TokenMatch(filePtr, "LIGHTOBJECT", 11)) - - { - m_vLights.push_back(Light("UNNAMED")); - ParseLV1ObjectBlock(m_vLights.back()); - continue; - } - // camera object - if (TokenMatch(filePtr, "CAMERAOBJECT", 12)) { - m_vCameras.push_back(Camera("UNNAMED")); - ParseLV1ObjectBlock(m_vCameras.back()); - continue; - } - // comment - print it on the console - if (TokenMatch(filePtr, "COMMENT", 7)) { - std::string out = "<unknown>"; - ParseString(out, "*COMMENT"); - LogInfo(("Comment: " + out).c_str()); - continue; - } - // ASC bone weights - if (AI_ASE_IS_OLD_FILE_FORMAT() && TokenMatch(filePtr, "MESH_SOFTSKINVERTS", 18)) { - ParseLV1SoftSkinBlock(); - } - } - AI_ASE_HANDLE_TOP_LEVEL_SECTION(); - } - return; -} - -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV1SoftSkinBlock() { - // TODO: fix line counting here - - // ************************************************************** - // The soft skin block is formatted differently. There are no - // nested sections supported and the single elements aren't - // marked by keywords starting with an asterisk. - - /** - FORMAT BEGIN - - *MESH_SOFTSKINVERTS { - <nodename> - <number of vertices> - - [for <number of vertices> times:] - <number of weights> [for <number of weights> times:] <bone name> <weight> - } - - FORMAT END - */ - // ************************************************************** - while (true) { - if (*filePtr == '}') { - ++filePtr; - return; - } else if (*filePtr == '\0') - return; - else if (*filePtr == '{') - ++filePtr; - - else // if (!IsSpace(*filePtr) && !IsLineEnd(*filePtr)) - { - ASE::Mesh *curMesh = nullptr; - unsigned int numVerts = 0; - - const char *sz = filePtr; - while (!IsSpaceOrNewLine(*filePtr)) - ++filePtr; - - const unsigned int diff = (unsigned int)(filePtr - sz); - if (diff) { - std::string name = std::string(sz, diff); - for (std::vector<ASE::Mesh>::iterator it = m_vMeshes.begin(); - it != m_vMeshes.end(); ++it) { - if ((*it).mName == name) { - curMesh = &(*it); - break; - } - } - if (!curMesh) { - LogWarning("Encountered unknown mesh in *MESH_SOFTSKINVERTS section"); - - // Skip the mesh data - until we find a new mesh - // or the end of the *MESH_SOFTSKINVERTS section - while (true) { - SkipSpacesAndLineEnd(&filePtr); - if (*filePtr == '}') { - ++filePtr; - return; - } else if (!IsNumeric(*filePtr)) - break; - - SkipLine(&filePtr); - } - } else { - SkipSpacesAndLineEnd(&filePtr); - ParseLV4MeshLong(numVerts); - - // Reserve enough storage - curMesh->mBoneVertices.reserve(numVerts); - - for (unsigned int i = 0; i < numVerts; ++i) { - SkipSpacesAndLineEnd(&filePtr); - unsigned int numWeights; - ParseLV4MeshLong(numWeights); - - curMesh->mBoneVertices.push_back(ASE::BoneVertex()); - ASE::BoneVertex &vert = curMesh->mBoneVertices.back(); - - // Reserve enough storage - vert.mBoneWeights.reserve(numWeights); - - std::string bone; - for (unsigned int w = 0; w < numWeights; ++w) { - bone.clear(); - ParseString(bone, "*MESH_SOFTSKINVERTS.Bone"); - - // Find the bone in the mesh's list - std::pair<int, ai_real> me; - me.first = -1; - - for (unsigned int n = 0; n < curMesh->mBones.size(); ++n) { - if (curMesh->mBones[n].mName == bone) { - me.first = n; - break; - } - } - if (-1 == me.first) { - // We don't have this bone yet, so add it to the list - me.first = static_cast<int>(curMesh->mBones.size()); - curMesh->mBones.push_back(ASE::Bone(bone)); - } - ParseLV4MeshFloat(me.second); - - // Add the new bone weight to list - vert.mBoneWeights.push_back(me); - } - } - } - } - } - ++filePtr; - SkipSpacesAndLineEnd(&filePtr); - } -} - -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV1SceneBlock() { - AI_ASE_PARSER_INIT(); - while (true) { - if ('*' == *filePtr) { - ++filePtr; - if (TokenMatch(filePtr, "SCENE_BACKGROUND_STATIC", 23)) - - { - // parse a color triple and assume it is really the bg color - ParseLV4MeshFloatTriple(&m_clrBackground.r); - continue; - } - if (TokenMatch(filePtr, "SCENE_AMBIENT_STATIC", 20)) - - { - // parse a color triple and assume it is really the bg color - ParseLV4MeshFloatTriple(&m_clrAmbient.r); - continue; - } - if (TokenMatch(filePtr, "SCENE_FIRSTFRAME", 16)) { - ParseLV4MeshLong(iFirstFrame); - continue; - } - if (TokenMatch(filePtr, "SCENE_LASTFRAME", 15)) { - ParseLV4MeshLong(iLastFrame); - continue; - } - if (TokenMatch(filePtr, "SCENE_FRAMESPEED", 16)) { - ParseLV4MeshLong(iFrameSpeed); - continue; - } - if (TokenMatch(filePtr, "SCENE_TICKSPERFRAME", 19)) { - ParseLV4MeshLong(iTicksPerFrame); - continue; - } - } - AI_ASE_HANDLE_TOP_LEVEL_SECTION(); - } -} - -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV1MaterialListBlock() { - AI_ASE_PARSER_INIT(); - - unsigned int iMaterialCount = 0; - unsigned int iOldMaterialCount = (unsigned int)m_vMaterials.size(); - while (true) { - if ('*' == *filePtr) { - ++filePtr; - if (TokenMatch(filePtr, "MATERIAL_COUNT", 14)) { - ParseLV4MeshLong(iMaterialCount); - - // now allocate enough storage to hold all materials - m_vMaterials.resize(iOldMaterialCount + iMaterialCount, Material("INVALID")); - continue; - } - if (TokenMatch(filePtr, "MATERIAL", 8)) { - unsigned int iIndex = 0; - ParseLV4MeshLong(iIndex); - - if (iIndex >= iMaterialCount) { - LogWarning("Out of range: material index is too large"); - iIndex = iMaterialCount - 1; - return; - } - - // get a reference to the material - Material &sMat = m_vMaterials[iIndex + iOldMaterialCount]; - // parse the material block - ParseLV2MaterialBlock(sMat); - continue; - } - if( iDepth == 1 ){ - // CRUDE HACK: support missing brace after "Ascii Scene Exporter v2.51" - LogWarning("Missing closing brace in material list"); - --filePtr; - return; - } - } - AI_ASE_HANDLE_TOP_LEVEL_SECTION(); - } -} - -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV2MaterialBlock(ASE::Material &mat) { - AI_ASE_PARSER_INIT(); - - unsigned int iNumSubMaterials = 0; - while (true) { - if ('*' == *filePtr) { - ++filePtr; - if (TokenMatch(filePtr, "MATERIAL_NAME", 13)) { - if (!ParseString(mat.mName, "*MATERIAL_NAME")) - SkipToNextToken(); - continue; - } - // ambient material color - if (TokenMatch(filePtr, "MATERIAL_AMBIENT", 16)) { - ParseLV4MeshFloatTriple(&mat.mAmbient.r); - continue; - } - // diffuse material color - if (TokenMatch(filePtr, "MATERIAL_DIFFUSE", 16)) { - ParseLV4MeshFloatTriple(&mat.mDiffuse.r); - continue; - } - // specular material color - if (TokenMatch(filePtr, "MATERIAL_SPECULAR", 17)) { - ParseLV4MeshFloatTriple(&mat.mSpecular.r); - continue; - } - // material shading type - if (TokenMatch(filePtr, "MATERIAL_SHADING", 16)) { - if (TokenMatch(filePtr, "Blinn", 5)) { - mat.mShading = Discreet3DS::Blinn; - } else if (TokenMatch(filePtr, "Phong", 5)) { - mat.mShading = Discreet3DS::Phong; - } else if (TokenMatch(filePtr, "Flat", 4)) { - mat.mShading = Discreet3DS::Flat; - } else if (TokenMatch(filePtr, "Wire", 4)) { - mat.mShading = Discreet3DS::Wire; - } else { - // assume gouraud shading - mat.mShading = Discreet3DS::Gouraud; - SkipToNextToken(); - } - continue; - } - // material transparency - if (TokenMatch(filePtr, "MATERIAL_TRANSPARENCY", 21)) { - ParseLV4MeshFloat(mat.mTransparency); - mat.mTransparency = ai_real(1.0) - mat.mTransparency; - continue; - } - // material self illumination - if (TokenMatch(filePtr, "MATERIAL_SELFILLUM", 18)) { - ai_real f = 0.0; - ParseLV4MeshFloat(f); - - mat.mEmissive.r = f; - mat.mEmissive.g = f; - mat.mEmissive.b = f; - continue; - } - // material shininess - if (TokenMatch(filePtr, "MATERIAL_SHINE", 14)) { - ParseLV4MeshFloat(mat.mSpecularExponent); - mat.mSpecularExponent *= 15; - continue; - } - // two-sided material - if (TokenMatch(filePtr, "MATERIAL_TWOSIDED", 17)) { - mat.mTwoSided = true; - continue; - } - // material shininess strength - if (TokenMatch(filePtr, "MATERIAL_SHINESTRENGTH", 22)) { - ParseLV4MeshFloat(mat.mShininessStrength); - continue; - } - // diffuse color map - if (TokenMatch(filePtr, "MAP_DIFFUSE", 11)) { - // parse the texture block - ParseLV3MapBlock(mat.sTexDiffuse); - continue; - } - // ambient color map - if (TokenMatch(filePtr, "MAP_AMBIENT", 11)) { - // parse the texture block - ParseLV3MapBlock(mat.sTexAmbient); - continue; - } - // specular color map - if (TokenMatch(filePtr, "MAP_SPECULAR", 12)) { - // parse the texture block - ParseLV3MapBlock(mat.sTexSpecular); - continue; - } - // opacity map - if (TokenMatch(filePtr, "MAP_OPACITY", 11)) { - // parse the texture block - ParseLV3MapBlock(mat.sTexOpacity); - continue; - } - // emissive map - if (TokenMatch(filePtr, "MAP_SELFILLUM", 13)) { - // parse the texture block - ParseLV3MapBlock(mat.sTexEmissive); - continue; - } - // bump map - if (TokenMatch(filePtr, "MAP_BUMP", 8)) { - // parse the texture block - ParseLV3MapBlock(mat.sTexBump); - } - // specular/shininess map - if (TokenMatch(filePtr, "MAP_SHINESTRENGTH", 17)) { - // parse the texture block - ParseLV3MapBlock(mat.sTexShininess); - continue; - } - // number of submaterials - if (TokenMatch(filePtr, "NUMSUBMTLS", 10)) { - ParseLV4MeshLong(iNumSubMaterials); - - // allocate enough storage - mat.avSubMaterials.resize(iNumSubMaterials, Material("INVALID SUBMATERIAL")); - } - // submaterial chunks - if (TokenMatch(filePtr, "SUBMATERIAL", 11)) { - - unsigned int iIndex = 0; - ParseLV4MeshLong(iIndex); - - if (iIndex >= iNumSubMaterials) { - LogWarning("Out of range: submaterial index is too large"); - iIndex = iNumSubMaterials - 1; - } - - // get a reference to the material - Material &sMat = mat.avSubMaterials[iIndex]; - - // parse the material block - ParseLV2MaterialBlock(sMat); - continue; - } - } - AI_ASE_HANDLE_SECTION("2", "*MATERIAL"); - } -} - -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV3MapBlock(Texture &map) { - AI_ASE_PARSER_INIT(); - - // *********************************************************** - // *BITMAP should not be there if *MAP_CLASS is not BITMAP, - // but we need to expect that case ... if the path is - // empty the texture won't be used later. - // *********************************************************** - bool parsePath = true; - std::string temp; - while (true) { - if ('*' == *filePtr) { - ++filePtr; - // type of map - if (TokenMatch(filePtr, "MAP_CLASS", 9)) { - temp.clear(); - if (!ParseString(temp, "*MAP_CLASS")) - SkipToNextToken(); - if (temp != "Bitmap" && temp != "Normal Bump") { - ASSIMP_LOG_WARN("ASE: Skipping unknown map type: ", temp); - parsePath = false; - } - continue; - } - // path to the texture - if (parsePath && TokenMatch(filePtr, "BITMAP", 6)) { - if (!ParseString(map.mMapName, "*BITMAP")) - SkipToNextToken(); - - if (map.mMapName == "None") { - // Files with 'None' as map name are produced by - // an Maja to ASE exporter which name I forgot .. - ASSIMP_LOG_WARN("ASE: Skipping invalid map entry"); - map.mMapName = std::string(); - } - - continue; - } - // offset on the u axis - if (TokenMatch(filePtr, "UVW_U_OFFSET", 12)) { - ParseLV4MeshFloat(map.mOffsetU); - continue; - } - // offset on the v axis - if (TokenMatch(filePtr, "UVW_V_OFFSET", 12)) { - ParseLV4MeshFloat(map.mOffsetV); - continue; - } - // tiling on the u axis - if (TokenMatch(filePtr, "UVW_U_TILING", 12)) { - ParseLV4MeshFloat(map.mScaleU); - continue; - } - // tiling on the v axis - if (TokenMatch(filePtr, "UVW_V_TILING", 12)) { - ParseLV4MeshFloat(map.mScaleV); - continue; - } - // rotation around the z-axis - if (TokenMatch(filePtr, "UVW_ANGLE", 9)) { - ParseLV4MeshFloat(map.mRotation); - continue; - } - // map blending factor - if (TokenMatch(filePtr, "MAP_AMOUNT", 10)) { - ParseLV4MeshFloat(map.mTextureBlend); - continue; - } - } - AI_ASE_HANDLE_SECTION("3", "*MAP_XXXXXX"); - } - return; -} - -// ------------------------------------------------------------------------------------------------ -bool Parser::ParseString(std::string &out, const char *szName) { - char szBuffer[1024]; - if (!SkipSpaces(&filePtr)) { - - ai_snprintf(szBuffer, 1024, "Unable to parse %s block: Unexpected EOL", szName); - LogWarning(szBuffer); - return false; - } - // there must be '"' - if ('\"' != *filePtr) { - - ai_snprintf(szBuffer, 1024, "Unable to parse %s block: Strings are expected " - "to be enclosed in double quotation marks", - szName); - LogWarning(szBuffer); - return false; - } - ++filePtr; - const char *sz = filePtr; - while (true) { - if ('\"' == *sz) - break; - else if ('\0' == *sz) { - ai_snprintf(szBuffer, 1024, "Unable to parse %s block: Strings are expected to " - "be enclosed in double quotation marks but EOF was reached before " - "a closing quotation mark was encountered", - szName); - LogWarning(szBuffer); - return false; - } - sz++; - } - out = std::string(filePtr, (uintptr_t)sz - (uintptr_t)filePtr); - filePtr = sz + 1; - return true; -} - -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV1ObjectBlock(ASE::BaseNode &node) { - AI_ASE_PARSER_INIT(); - while (true) { - if ('*' == *filePtr) { - ++filePtr; - - // first process common tokens such as node name and transform - // name of the mesh/node - if (TokenMatch(filePtr, "NODE_NAME", 9)) { - if (!ParseString(node.mName, "*NODE_NAME")) - SkipToNextToken(); - continue; - } - // name of the parent of the node - if (TokenMatch(filePtr, "NODE_PARENT", 11)) { - if (!ParseString(node.mParent, "*NODE_PARENT")) - SkipToNextToken(); - continue; - } - // transformation matrix of the node - if (TokenMatch(filePtr, "NODE_TM", 7)) { - ParseLV2NodeTransformBlock(node); - continue; - } - // animation data of the node - if (TokenMatch(filePtr, "TM_ANIMATION", 12)) { - ParseLV2AnimationBlock(node); - continue; - } - - if (node.mType == BaseNode::Light) { - // light settings - if (TokenMatch(filePtr, "LIGHT_SETTINGS", 14)) { - ParseLV2LightSettingsBlock((ASE::Light &)node); - continue; - } - // type of the light source - if (TokenMatch(filePtr, "LIGHT_TYPE", 10)) { - if (!ASSIMP_strincmp("omni", filePtr, 4)) { - ((ASE::Light &)node).mLightType = ASE::Light::OMNI; - } else if (!ASSIMP_strincmp("target", filePtr, 6)) { - ((ASE::Light &)node).mLightType = ASE::Light::TARGET; - } else if (!ASSIMP_strincmp("free", filePtr, 4)) { - ((ASE::Light &)node).mLightType = ASE::Light::FREE; - } else if (!ASSIMP_strincmp("directional", filePtr, 11)) { - ((ASE::Light &)node).mLightType = ASE::Light::DIRECTIONAL; - } else { - LogWarning("Unknown kind of light source"); - } - continue; - } - } else if (node.mType == BaseNode::Camera) { - // Camera settings - if (TokenMatch(filePtr, "CAMERA_SETTINGS", 15)) { - ParseLV2CameraSettingsBlock((ASE::Camera &)node); - continue; - } else if (TokenMatch(filePtr, "CAMERA_TYPE", 11)) { - if (!ASSIMP_strincmp("target", filePtr, 6)) { - ((ASE::Camera &)node).mCameraType = ASE::Camera::TARGET; - } else if (!ASSIMP_strincmp("free", filePtr, 4)) { - ((ASE::Camera &)node).mCameraType = ASE::Camera::FREE; - } else { - LogWarning("Unknown kind of camera"); - } - continue; - } - } else if (node.mType == BaseNode::Mesh) { - // mesh data - // FIX: Older files use MESH_SOFTSKIN - if (TokenMatch(filePtr, "MESH", 4) || - TokenMatch(filePtr, "MESH_SOFTSKIN", 13)) { - ParseLV2MeshBlock((ASE::Mesh &)node); - continue; - } - // mesh material index - if (TokenMatch(filePtr, "MATERIAL_REF", 12)) { - ParseLV4MeshLong(((ASE::Mesh &)node).iMaterialIndex); - continue; - } - } - } - AI_ASE_HANDLE_TOP_LEVEL_SECTION(); - } - return; -} - -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV2CameraSettingsBlock(ASE::Camera &camera) { - AI_ASE_PARSER_INIT(); - while (true) { - if ('*' == *filePtr) { - ++filePtr; - if (TokenMatch(filePtr, "CAMERA_NEAR", 11)) { - ParseLV4MeshFloat(camera.mNear); - continue; - } - if (TokenMatch(filePtr, "CAMERA_FAR", 10)) { - ParseLV4MeshFloat(camera.mFar); - continue; - } - if (TokenMatch(filePtr, "CAMERA_FOV", 10)) { - ParseLV4MeshFloat(camera.mFOV); - continue; - } - } - AI_ASE_HANDLE_SECTION("2", "CAMERA_SETTINGS"); - } - return; -} - -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV2LightSettingsBlock(ASE::Light &light) { - AI_ASE_PARSER_INIT(); - while (true) { - if ('*' == *filePtr) { - ++filePtr; - if (TokenMatch(filePtr, "LIGHT_COLOR", 11)) { - ParseLV4MeshFloatTriple(&light.mColor.r); - continue; - } - if (TokenMatch(filePtr, "LIGHT_INTENS", 12)) { - ParseLV4MeshFloat(light.mIntensity); - continue; - } - if (TokenMatch(filePtr, "LIGHT_HOTSPOT", 13)) { - ParseLV4MeshFloat(light.mAngle); - continue; - } - if (TokenMatch(filePtr, "LIGHT_FALLOFF", 13)) { - ParseLV4MeshFloat(light.mFalloff); - continue; - } - } - AI_ASE_HANDLE_SECTION("2", "LIGHT_SETTINGS"); - } -} - -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV2AnimationBlock(ASE::BaseNode &mesh) { - AI_ASE_PARSER_INIT(); - - ASE::Animation *anim = &mesh.mAnim; - while (true) { - if ('*' == *filePtr) { - ++filePtr; - if (TokenMatch(filePtr, "NODE_NAME", 9)) { - std::string temp; - if (!ParseString(temp, "*NODE_NAME")) - SkipToNextToken(); - - // If the name of the node contains .target it - // represents an animated camera or spot light - // target. - if (std::string::npos != temp.find(".Target")) { - if ((mesh.mType != BaseNode::Camera || ((ASE::Camera &)mesh).mCameraType != ASE::Camera::TARGET) && - (mesh.mType != BaseNode::Light || ((ASE::Light &)mesh).mLightType != ASE::Light::TARGET)) { - - ASSIMP_LOG_ERROR("ASE: Found target animation channel " - "but the node is neither a camera nor a spot light"); - anim = nullptr; - } else - anim = &mesh.mTargetAnim; - } - continue; - } - - // position keyframes - if (TokenMatch(filePtr, "CONTROL_POS_TRACK", 17) || - TokenMatch(filePtr, "CONTROL_POS_BEZIER", 18) || - TokenMatch(filePtr, "CONTROL_POS_TCB", 15)) { - if (!anim) - SkipSection(); - else - ParseLV3PosAnimationBlock(*anim); - continue; - } - // scaling keyframes - if (TokenMatch(filePtr, "CONTROL_SCALE_TRACK", 19) || - TokenMatch(filePtr, "CONTROL_SCALE_BEZIER", 20) || - TokenMatch(filePtr, "CONTROL_SCALE_TCB", 17)) { - if (!anim || anim == &mesh.mTargetAnim) { - // Target animation channels may have no rotation channels - ASSIMP_LOG_ERROR("ASE: Ignoring scaling channel in target animation"); - SkipSection(); - } else - ParseLV3ScaleAnimationBlock(*anim); - continue; - } - // rotation keyframes - if (TokenMatch(filePtr, "CONTROL_ROT_TRACK", 17) || - TokenMatch(filePtr, "CONTROL_ROT_BEZIER", 18) || - TokenMatch(filePtr, "CONTROL_ROT_TCB", 15)) { - if (!anim || anim == &mesh.mTargetAnim) { - // Target animation channels may have no rotation channels - ASSIMP_LOG_ERROR("ASE: Ignoring rotation channel in target animation"); - SkipSection(); - } else - ParseLV3RotAnimationBlock(*anim); - continue; - } - } - AI_ASE_HANDLE_SECTION("2", "TM_ANIMATION"); - } -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV3ScaleAnimationBlock(ASE::Animation &anim) { - AI_ASE_PARSER_INIT(); - unsigned int iIndex; - - while (true) { - if ('*' == *filePtr) { - ++filePtr; - - bool b = false; - - // For the moment we're just reading the three floats - - // we ignore the additional information for bezier's and TCBs - - // simple scaling keyframe - if (TokenMatch(filePtr, "CONTROL_SCALE_SAMPLE", 20)) { - b = true; - anim.mScalingType = ASE::Animation::TRACK; - } - - // Bezier scaling keyframe - if (TokenMatch(filePtr, "CONTROL_BEZIER_SCALE_KEY", 24)) { - b = true; - anim.mScalingType = ASE::Animation::BEZIER; - } - // TCB scaling keyframe - if (TokenMatch(filePtr, "CONTROL_TCB_SCALE_KEY", 21)) { - b = true; - anim.mScalingType = ASE::Animation::TCB; - } - if (b) { - anim.akeyScaling.push_back(aiVectorKey()); - aiVectorKey &key = anim.akeyScaling.back(); - ParseLV4MeshFloatTriple(&key.mValue.x, iIndex); - key.mTime = (double)iIndex; - } - } - AI_ASE_HANDLE_SECTION("3", "*CONTROL_POS_TRACK"); - } -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV3PosAnimationBlock(ASE::Animation &anim) { - AI_ASE_PARSER_INIT(); - unsigned int iIndex; - while (true) { - if ('*' == *filePtr) { - ++filePtr; - - bool b = false; - - // For the moment we're just reading the three floats - - // we ignore the additional information for bezier's and TCBs - - // simple scaling keyframe - if (TokenMatch(filePtr, "CONTROL_POS_SAMPLE", 18)) { - b = true; - anim.mPositionType = ASE::Animation::TRACK; - } - - // Bezier scaling keyframe - if (TokenMatch(filePtr, "CONTROL_BEZIER_POS_KEY", 22)) { - b = true; - anim.mPositionType = ASE::Animation::BEZIER; - } - // TCB scaling keyframe - if (TokenMatch(filePtr, "CONTROL_TCB_POS_KEY", 19)) { - b = true; - anim.mPositionType = ASE::Animation::TCB; - } - if (b) { - anim.akeyPositions.push_back(aiVectorKey()); - aiVectorKey &key = anim.akeyPositions.back(); - ParseLV4MeshFloatTriple(&key.mValue.x, iIndex); - key.mTime = (double)iIndex; - } - } - AI_ASE_HANDLE_SECTION("3", "*CONTROL_POS_TRACK"); - } -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV3RotAnimationBlock(ASE::Animation &anim) { - AI_ASE_PARSER_INIT(); - unsigned int iIndex; - while (true) { - if ('*' == *filePtr) { - ++filePtr; - - bool b = false; - - // For the moment we're just reading the floats - - // we ignore the additional information for bezier's and TCBs - - // simple scaling keyframe - if (TokenMatch(filePtr, "CONTROL_ROT_SAMPLE", 18)) { - b = true; - anim.mRotationType = ASE::Animation::TRACK; - } - - // Bezier scaling keyframe - if (TokenMatch(filePtr, "CONTROL_BEZIER_ROT_KEY", 22)) { - b = true; - anim.mRotationType = ASE::Animation::BEZIER; - } - // TCB scaling keyframe - if (TokenMatch(filePtr, "CONTROL_TCB_ROT_KEY", 19)) { - b = true; - anim.mRotationType = ASE::Animation::TCB; - } - if (b) { - anim.akeyRotations.push_back(aiQuatKey()); - aiQuatKey &key = anim.akeyRotations.back(); - aiVector3D v; - ai_real f; - ParseLV4MeshFloatTriple(&v.x, iIndex); - ParseLV4MeshFloat(f); - key.mTime = (double)iIndex; - key.mValue = aiQuaternion(v, f); - } - } - AI_ASE_HANDLE_SECTION("3", "*CONTROL_ROT_TRACK"); - } -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV2NodeTransformBlock(ASE::BaseNode &mesh) { - AI_ASE_PARSER_INIT(); - int mode = 0; - while (true) { - if ('*' == *filePtr) { - ++filePtr; - // name of the node - if (TokenMatch(filePtr, "NODE_NAME", 9)) { - std::string temp; - if (!ParseString(temp, "*NODE_NAME")) - SkipToNextToken(); - - std::string::size_type s; - if (temp == mesh.mName) { - mode = 1; - } else if (std::string::npos != (s = temp.find(".Target")) && - mesh.mName == temp.substr(0, s)) { - // This should be either a target light or a target camera - if ((mesh.mType == BaseNode::Light && ((ASE::Light &)mesh).mLightType == ASE::Light::TARGET) || - (mesh.mType == BaseNode::Camera && ((ASE::Camera &)mesh).mCameraType == ASE::Camera::TARGET)) { - mode = 2; - } else { - ASSIMP_LOG_ERROR("ASE: Ignoring target transform, " - "this is no spot light or target camera"); - } - } else { - ASSIMP_LOG_ERROR("ASE: Unknown node transformation: ", temp); - // mode = 0 - } - continue; - } - if (mode) { - // fourth row of the transformation matrix - and also the - // only information here that is interesting for targets - if (TokenMatch(filePtr, "TM_ROW3", 7)) { - ParseLV4MeshFloatTriple((mode == 1 ? mesh.mTransform[3] : &mesh.mTargetPosition.x)); - continue; - } - if (mode == 1) { - // first row of the transformation matrix - if (TokenMatch(filePtr, "TM_ROW0", 7)) { - ParseLV4MeshFloatTriple(mesh.mTransform[0]); - continue; - } - // second row of the transformation matrix - if (TokenMatch(filePtr, "TM_ROW1", 7)) { - ParseLV4MeshFloatTriple(mesh.mTransform[1]); - continue; - } - // third row of the transformation matrix - if (TokenMatch(filePtr, "TM_ROW2", 7)) { - ParseLV4MeshFloatTriple(mesh.mTransform[2]); - continue; - } - // inherited position axes - if (TokenMatch(filePtr, "INHERIT_POS", 11)) { - unsigned int aiVal[3]; - ParseLV4MeshLongTriple(aiVal); - - for (unsigned int i = 0; i < 3; ++i) - mesh.inherit.abInheritPosition[i] = aiVal[i] != 0; - continue; - } - // inherited rotation axes - if (TokenMatch(filePtr, "INHERIT_ROT", 11)) { - unsigned int aiVal[3]; - ParseLV4MeshLongTriple(aiVal); - - for (unsigned int i = 0; i < 3; ++i) - mesh.inherit.abInheritRotation[i] = aiVal[i] != 0; - continue; - } - // inherited scaling axes - if (TokenMatch(filePtr, "INHERIT_SCL", 11)) { - unsigned int aiVal[3]; - ParseLV4MeshLongTriple(aiVal); - - for (unsigned int i = 0; i < 3; ++i) - mesh.inherit.abInheritScaling[i] = aiVal[i] != 0; - continue; - } - } - } - } - AI_ASE_HANDLE_SECTION("2", "*NODE_TM"); - } - return; -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV2MeshBlock(ASE::Mesh &mesh) { - AI_ASE_PARSER_INIT(); - - unsigned int iNumVertices = 0; - unsigned int iNumFaces = 0; - unsigned int iNumTVertices = 0; - unsigned int iNumTFaces = 0; - unsigned int iNumCVertices = 0; - unsigned int iNumCFaces = 0; - while (true) { - if ('*' == *filePtr) { - ++filePtr; - // Number of vertices in the mesh - if (TokenMatch(filePtr, "MESH_NUMVERTEX", 14)) { - ParseLV4MeshLong(iNumVertices); - continue; - } - // Number of texture coordinates in the mesh - if (TokenMatch(filePtr, "MESH_NUMTVERTEX", 15)) { - ParseLV4MeshLong(iNumTVertices); - continue; - } - // Number of vertex colors in the mesh - if (TokenMatch(filePtr, "MESH_NUMCVERTEX", 15)) { - ParseLV4MeshLong(iNumCVertices); - continue; - } - // Number of regular faces in the mesh - if (TokenMatch(filePtr, "MESH_NUMFACES", 13)) { - ParseLV4MeshLong(iNumFaces); - continue; - } - // Number of UVWed faces in the mesh - if (TokenMatch(filePtr, "MESH_NUMTVFACES", 15)) { - ParseLV4MeshLong(iNumTFaces); - continue; - } - // Number of colored faces in the mesh - if (TokenMatch(filePtr, "MESH_NUMCVFACES", 15)) { - ParseLV4MeshLong(iNumCFaces); - continue; - } - // mesh vertex list block - if (TokenMatch(filePtr, "MESH_VERTEX_LIST", 16)) { - ParseLV3MeshVertexListBlock(iNumVertices, mesh); - continue; - } - // mesh face list block - if (TokenMatch(filePtr, "MESH_FACE_LIST", 14)) { - ParseLV3MeshFaceListBlock(iNumFaces, mesh); - continue; - } - // mesh texture vertex list block - if (TokenMatch(filePtr, "MESH_TVERTLIST", 14)) { - ParseLV3MeshTListBlock(iNumTVertices, mesh); - continue; - } - // mesh texture face block - if (TokenMatch(filePtr, "MESH_TFACELIST", 14)) { - ParseLV3MeshTFaceListBlock(iNumTFaces, mesh); - continue; - } - // mesh color vertex list block - if (TokenMatch(filePtr, "MESH_CVERTLIST", 14)) { - ParseLV3MeshCListBlock(iNumCVertices, mesh); - continue; - } - // mesh color face block - if (TokenMatch(filePtr, "MESH_CFACELIST", 14)) { - ParseLV3MeshCFaceListBlock(iNumCFaces, mesh); - continue; - } - // mesh normals - if (TokenMatch(filePtr, "MESH_NORMALS", 12)) { - ParseLV3MeshNormalListBlock(mesh); - continue; - } - // another mesh UV channel ... - if (TokenMatch(filePtr, "MESH_MAPPINGCHANNEL", 19)) { - unsigned int iIndex(0); - ParseLV4MeshLong(iIndex); - if (0 == iIndex) { - LogWarning("Mapping channel has an invalid index. Skipping UV channel"); - // skip it ... - SkipSection(); - } else { - if (iIndex < 2) { - LogWarning("Mapping channel has an invalid index. Skipping UV channel"); - // skip it ... - SkipSection(); - } - if (iIndex > AI_MAX_NUMBER_OF_TEXTURECOORDS) { - LogWarning("Too many UV channels specified. Skipping channel .."); - // skip it ... - SkipSection(); - } else { - // parse the mapping channel - ParseLV3MappingChannel(iIndex - 1, mesh); - } - continue; - } - } - // mesh animation keyframe. Not supported - if (TokenMatch(filePtr, "MESH_ANIMATION", 14)) { - - LogWarning("Found *MESH_ANIMATION element in ASE/ASK file. " - "Keyframe animation is not supported by Assimp, this element " - "will be ignored"); - //SkipSection(); - continue; - } - if (TokenMatch(filePtr, "MESH_WEIGHTS", 12)) { - ParseLV3MeshWeightsBlock(mesh); - continue; - } - } - AI_ASE_HANDLE_SECTION("2", "*MESH"); - } - return; -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV3MeshWeightsBlock(ASE::Mesh &mesh) { - AI_ASE_PARSER_INIT(); - - unsigned int iNumVertices = 0, iNumBones = 0; - while (true) { - if ('*' == *filePtr) { - ++filePtr; - - // Number of bone vertices ... - if (TokenMatch(filePtr, "MESH_NUMVERTEX", 14)) { - ParseLV4MeshLong(iNumVertices); - continue; - } - // Number of bones - if (TokenMatch(filePtr, "MESH_NUMBONE", 12)) { - ParseLV4MeshLong(iNumBones); - continue; - } - // parse the list of bones - if (TokenMatch(filePtr, "MESH_BONE_LIST", 14)) { - ParseLV4MeshBones(iNumBones, mesh); - continue; - } - // parse the list of bones vertices - if (TokenMatch(filePtr, "MESH_BONE_VERTEX_LIST", 21)) { - ParseLV4MeshBonesVertices(iNumVertices, mesh); - continue; - } - } - AI_ASE_HANDLE_SECTION("3", "*MESH_WEIGHTS"); - } - return; -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV4MeshBones(unsigned int iNumBones, ASE::Mesh &mesh) { - AI_ASE_PARSER_INIT(); - mesh.mBones.resize(iNumBones, Bone("UNNAMED")); - while (true) { - if ('*' == *filePtr) { - ++filePtr; - - // Mesh bone with name ... - if (TokenMatch(filePtr, "MESH_BONE_NAME", 14)) { - // parse an index ... - if (SkipSpaces(&filePtr)) { - unsigned int iIndex = strtoul10(filePtr, &filePtr); - if (iIndex >= iNumBones) { - LogWarning("Bone index is out of bounds"); - continue; - } - if (!ParseString(mesh.mBones[iIndex].mName, "*MESH_BONE_NAME")) - SkipToNextToken(); - continue; - } - } - } - AI_ASE_HANDLE_SECTION("3", "*MESH_BONE_LIST"); - } -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV4MeshBonesVertices(unsigned int iNumVertices, ASE::Mesh &mesh) { - AI_ASE_PARSER_INIT(); - mesh.mBoneVertices.resize(iNumVertices); - while (true) { - if ('*' == *filePtr) { - ++filePtr; - - // Mesh bone vertex - if (TokenMatch(filePtr, "MESH_BONE_VERTEX", 16)) { - // read the vertex index - unsigned int iIndex = strtoul10(filePtr, &filePtr); - if (iIndex >= mesh.mPositions.size()) { - iIndex = (unsigned int)mesh.mPositions.size() - 1; - LogWarning("Bone vertex index is out of bounds. Using the largest valid " - "bone vertex index instead"); - } - - // --- ignored - ai_real afVert[3]; - ParseLV4MeshFloatTriple(afVert); - - std::pair<int, float> pairOut; - while (true) { - // first parse the bone index ... - if (!SkipSpaces(&filePtr)) break; - pairOut.first = strtoul10(filePtr, &filePtr); - - // then parse the vertex weight - if (!SkipSpaces(&filePtr)) break; - filePtr = fast_atoreal_move<float>(filePtr, pairOut.second); - - // -1 marks unused entries - if (-1 != pairOut.first) { - mesh.mBoneVertices[iIndex].mBoneWeights.push_back(pairOut); - } - } - continue; - } - } - AI_ASE_HANDLE_SECTION("4", "*MESH_BONE_VERTEX"); - } - return; -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV3MeshVertexListBlock( - unsigned int iNumVertices, ASE::Mesh &mesh) { - AI_ASE_PARSER_INIT(); - - // allocate enough storage in the array - mesh.mPositions.resize(iNumVertices); - while (true) { - if ('*' == *filePtr) { - ++filePtr; - - // Vertex entry - if (TokenMatch(filePtr, "MESH_VERTEX", 11)) { - - aiVector3D vTemp; - unsigned int iIndex; - ParseLV4MeshFloatTriple(&vTemp.x, iIndex); - - if (iIndex >= iNumVertices) { - LogWarning("Invalid vertex index. It will be ignored"); - } else - mesh.mPositions[iIndex] = vTemp; - continue; - } - } - AI_ASE_HANDLE_SECTION("3", "*MESH_VERTEX_LIST"); - } - return; -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV3MeshFaceListBlock(unsigned int iNumFaces, ASE::Mesh &mesh) { - AI_ASE_PARSER_INIT(); - - // allocate enough storage in the face array - mesh.mFaces.resize(iNumFaces); - while (true) { - if ('*' == *filePtr) { - ++filePtr; - - // Face entry - if (TokenMatch(filePtr, "MESH_FACE", 9)) { - - ASE::Face mFace; - ParseLV4MeshFace(mFace); - - if (mFace.iFace >= iNumFaces) { - LogWarning("Face has an invalid index. It will be ignored"); - } else - mesh.mFaces[mFace.iFace] = mFace; - continue; - } - } - AI_ASE_HANDLE_SECTION("3", "*MESH_FACE_LIST"); - } - return; -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV3MeshTListBlock(unsigned int iNumVertices, - ASE::Mesh &mesh, unsigned int iChannel) { - AI_ASE_PARSER_INIT(); - - // allocate enough storage in the array - mesh.amTexCoords[iChannel].resize(iNumVertices); - while (true) { - if ('*' == *filePtr) { - ++filePtr; - - // Vertex entry - if (TokenMatch(filePtr, "MESH_TVERT", 10)) { - aiVector3D vTemp; - unsigned int iIndex; - ParseLV4MeshFloatTriple(&vTemp.x, iIndex); - - if (iIndex >= iNumVertices) { - LogWarning("Tvertex has an invalid index. It will be ignored"); - } else - mesh.amTexCoords[iChannel][iIndex] = vTemp; - - if (0.0f != vTemp.z) { - // we need 3 coordinate channels - mesh.mNumUVComponents[iChannel] = 3; - } - continue; - } - } - AI_ASE_HANDLE_SECTION("3", "*MESH_TVERT_LIST"); - } - return; -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV3MeshTFaceListBlock(unsigned int iNumFaces, - ASE::Mesh &mesh, unsigned int iChannel) { - AI_ASE_PARSER_INIT(); - while (true) { - if ('*' == *filePtr) { - ++filePtr; - - // Face entry - if (TokenMatch(filePtr, "MESH_TFACE", 10)) { - unsigned int aiValues[3]; - unsigned int iIndex = 0; - - ParseLV4MeshLongTriple(aiValues, iIndex); - if (iIndex >= iNumFaces || iIndex >= mesh.mFaces.size()) { - LogWarning("UV-Face has an invalid index. It will be ignored"); - } else { - // copy UV indices - mesh.mFaces[iIndex].amUVIndices[iChannel][0] = aiValues[0]; - mesh.mFaces[iIndex].amUVIndices[iChannel][1] = aiValues[1]; - mesh.mFaces[iIndex].amUVIndices[iChannel][2] = aiValues[2]; - } - continue; - } - } - AI_ASE_HANDLE_SECTION("3", "*MESH_TFACE_LIST"); - } - return; -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV3MappingChannel(unsigned int iChannel, ASE::Mesh &mesh) { - AI_ASE_PARSER_INIT(); - - unsigned int iNumTVertices = 0; - unsigned int iNumTFaces = 0; - while (true) { - if ('*' == *filePtr) { - ++filePtr; - - // Number of texture coordinates in the mesh - if (TokenMatch(filePtr, "MESH_NUMTVERTEX", 15)) { - ParseLV4MeshLong(iNumTVertices); - continue; - } - // Number of UVWed faces in the mesh - if (TokenMatch(filePtr, "MESH_NUMTVFACES", 15)) { - ParseLV4MeshLong(iNumTFaces); - continue; - } - // mesh texture vertex list block - if (TokenMatch(filePtr, "MESH_TVERTLIST", 14)) { - ParseLV3MeshTListBlock(iNumTVertices, mesh, iChannel); - continue; - } - // mesh texture face block - if (TokenMatch(filePtr, "MESH_TFACELIST", 14)) { - ParseLV3MeshTFaceListBlock(iNumTFaces, mesh, iChannel); - continue; - } - } - AI_ASE_HANDLE_SECTION("3", "*MESH_MAPPING_CHANNEL"); - } - return; -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV3MeshCListBlock(unsigned int iNumVertices, ASE::Mesh &mesh) { - AI_ASE_PARSER_INIT(); - - // allocate enough storage in the array - mesh.mVertexColors.resize(iNumVertices); - while (true) { - if ('*' == *filePtr) { - ++filePtr; - - // Vertex entry - if (TokenMatch(filePtr, "MESH_VERTCOL", 12)) { - aiColor4D vTemp; - vTemp.a = 1.0f; - unsigned int iIndex; - ParseLV4MeshFloatTriple(&vTemp.r, iIndex); - - if (iIndex >= iNumVertices) { - LogWarning("Vertex color has an invalid index. It will be ignored"); - } else - mesh.mVertexColors[iIndex] = vTemp; - continue; - } - } - AI_ASE_HANDLE_SECTION("3", "*MESH_CVERTEX_LIST"); - } - return; -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV3MeshCFaceListBlock(unsigned int iNumFaces, ASE::Mesh &mesh) { - AI_ASE_PARSER_INIT(); - while (true) { - if ('*' == *filePtr) { - ++filePtr; - - // Face entry - if (TokenMatch(filePtr, "MESH_CFACE", 10)) { - unsigned int aiValues[3]; - unsigned int iIndex = 0; - - ParseLV4MeshLongTriple(aiValues, iIndex); - if (iIndex >= iNumFaces || iIndex >= mesh.mFaces.size()) { - LogWarning("UV-Face has an invalid index. It will be ignored"); - } else { - // copy color indices - mesh.mFaces[iIndex].mColorIndices[0] = aiValues[0]; - mesh.mFaces[iIndex].mColorIndices[1] = aiValues[1]; - mesh.mFaces[iIndex].mColorIndices[2] = aiValues[2]; - } - continue; - } - } - AI_ASE_HANDLE_SECTION("3", "*MESH_CFACE_LIST"); - } - return; -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV3MeshNormalListBlock(ASE::Mesh &sMesh) { - AI_ASE_PARSER_INIT(); - - // Allocate enough storage for the normals - sMesh.mNormals.resize(sMesh.mFaces.size() * 3, aiVector3D(0.f, 0.f, 0.f)); - unsigned int index, faceIdx = UINT_MAX; - - // FIXME: rewrite this and find out how to interpret the normals - // correctly. This is crap. - - // Smooth the vertex and face normals together. The result - // will be edgy then, but otherwise everything would be soft ... - while (true) { - if ('*' == *filePtr) { - ++filePtr; - if (faceIdx != UINT_MAX && TokenMatch(filePtr, "MESH_VERTEXNORMAL", 17)) { - aiVector3D vNormal; - ParseLV4MeshFloatTriple(&vNormal.x, index); - if (faceIdx >= sMesh.mFaces.size()) - continue; - - // Make sure we assign it to the correct face - const ASE::Face &face = sMesh.mFaces[faceIdx]; - if (index == face.mIndices[0]) - index = 0; - else if (index == face.mIndices[1]) - index = 1; - else if (index == face.mIndices[2]) - index = 2; - else { - ASSIMP_LOG_ERROR("ASE: Invalid vertex index in MESH_VERTEXNORMAL section"); - continue; - } - // We'll renormalize later - sMesh.mNormals[faceIdx * 3 + index] += vNormal; - continue; - } - if (TokenMatch(filePtr, "MESH_FACENORMAL", 15)) { - aiVector3D vNormal; - ParseLV4MeshFloatTriple(&vNormal.x, faceIdx); - - if (faceIdx >= sMesh.mFaces.size()) { - ASSIMP_LOG_ERROR("ASE: Invalid vertex index in MESH_FACENORMAL section"); - continue; - } - - // We'll renormalize later - sMesh.mNormals[faceIdx * 3] += vNormal; - sMesh.mNormals[faceIdx * 3 + 1] += vNormal; - sMesh.mNormals[faceIdx * 3 + 2] += vNormal; - continue; - } - } - AI_ASE_HANDLE_SECTION("3", "*MESH_NORMALS"); - } - return; -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV4MeshFace(ASE::Face &out) { - // skip spaces and tabs - if (!SkipSpaces(&filePtr)) { - LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL [#1]"); - SkipToNextToken(); - return; - } - - // parse the face index - out.iFace = strtoul10(filePtr, &filePtr); - - // next character should be ':' - if (!SkipSpaces(&filePtr)) { - // FIX: there are some ASE files which haven't got : here .... - LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL. \':\' expected [#2]"); - SkipToNextToken(); - return; - } - // FIX: There are some ASE files which haven't got ':' here - if (':' == *filePtr) ++filePtr; - - // Parse all mesh indices - for (unsigned int i = 0; i < 3; ++i) { - unsigned int iIndex = 0; - if (!SkipSpaces(&filePtr)) { - LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL"); - SkipToNextToken(); - return; - } - switch (*filePtr) { - case 'A': - case 'a': - break; - case 'B': - case 'b': - iIndex = 1; - break; - case 'C': - case 'c': - iIndex = 2; - break; - default: - LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL. " - "A,B or C expected [#3]"); - SkipToNextToken(); - return; - }; - ++filePtr; - - // next character should be ':' - if (!SkipSpaces(&filePtr) || ':' != *filePtr) { - LogWarning("Unable to parse *MESH_FACE Element: " - "Unexpected EOL. \':\' expected [#2]"); - SkipToNextToken(); - return; - } - - ++filePtr; - if (!SkipSpaces(&filePtr)) { - LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL. " - "Vertex index ecpected [#4]"); - SkipToNextToken(); - return; - } - out.mIndices[iIndex] = strtoul10(filePtr, &filePtr); - } - - // now we need to skip the AB, BC, CA blocks. - while (true) { - if ('*' == *filePtr) break; - if (IsLineEnd(*filePtr)) { - //iLineNumber++; - return; - } - filePtr++; - } - - // parse the smoothing group of the face - if (TokenMatch(filePtr, "*MESH_SMOOTHING", 15)) { - if (!SkipSpaces(&filePtr)) { - LogWarning("Unable to parse *MESH_SMOOTHING Element: " - "Unexpected EOL. Smoothing group(s) expected [#5]"); - SkipToNextToken(); - return; - } - - // Parse smoothing groups until we don't anymore see commas - // FIX: There needn't always be a value, sad but true - while (true) { - if (*filePtr < '9' && *filePtr >= '0') { - out.iSmoothGroup |= (1 << strtoul10(filePtr, &filePtr)); - } - SkipSpaces(&filePtr); - if (',' != *filePtr) { - break; - } - ++filePtr; - SkipSpaces(&filePtr); - } - } - - // *MESH_MTLID is optional, too - while (true) { - if ('*' == *filePtr) { - break; - } - if (IsLineEnd(*filePtr)) { - return; - } - filePtr++; - } - - if (TokenMatch(filePtr, "*MESH_MTLID", 11)) { - if (!SkipSpaces(&filePtr)) { - LogWarning("Unable to parse *MESH_MTLID Element: Unexpected EOL. " - "Material index expected [#6]"); - SkipToNextToken(); - return; - } - out.iMaterial = strtoul10(filePtr, &filePtr); - } - return; -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV4MeshLongTriple(unsigned int *apOut) { - ai_assert(nullptr != apOut); - - for (unsigned int i = 0; i < 3; ++i) - ParseLV4MeshLong(apOut[i]); -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV4MeshLongTriple(unsigned int *apOut, unsigned int &rIndexOut) { - ai_assert(nullptr != apOut); - - // parse the index - ParseLV4MeshLong(rIndexOut); - - // parse the three others - ParseLV4MeshLongTriple(apOut); -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV4MeshFloatTriple(ai_real *apOut, unsigned int &rIndexOut) { - ai_assert(nullptr != apOut); - - // parse the index - ParseLV4MeshLong(rIndexOut); - - // parse the three others - ParseLV4MeshFloatTriple(apOut); -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV4MeshFloatTriple(ai_real *apOut) { - ai_assert(nullptr != apOut); - - for (unsigned int i = 0; i < 3; ++i) { - ParseLV4MeshFloat(apOut[i]); - } -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV4MeshFloat(ai_real &fOut) { - // skip spaces and tabs - if (!SkipSpaces(&filePtr)) { - // LOG - LogWarning("Unable to parse float: unexpected EOL [#1]"); - fOut = 0.0; - ++iLineNumber; - return; - } - // parse the first float - filePtr = fast_atoreal_move<ai_real>(filePtr, fOut); -} -// ------------------------------------------------------------------------------------------------ -void Parser::ParseLV4MeshLong(unsigned int &iOut) { - // Skip spaces and tabs - if (!SkipSpaces(&filePtr)) { - // LOG - LogWarning("Unable to parse long: unexpected EOL [#1]"); - iOut = 0; - ++iLineNumber; - return; - } - // parse the value - iOut = strtoul10(filePtr, &filePtr); -} - -#endif // ASSIMP_BUILD_NO_3DS_IMPORTER - -#endif // !! ASSIMP_BUILD_NO_BASE_IMPORTER diff --git a/libs/assimp/code/AssetLib/ASE/ASEParser.h b/libs/assimp/code/AssetLib/ASE/ASEParser.h deleted file mode 100644 index 5c24fff..0000000 --- a/libs/assimp/code/AssetLib/ASE/ASEParser.h +++ /dev/null @@ -1,676 +0,0 @@ -/* -Open Asset Import Library (assimp) ----------------------------------------------------------------------- - -Copyright (c) 2006-2022, 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 Defines the helper data structures for importing ASE files */ -#ifndef AI_ASEFILEHELPER_H_INC -#define AI_ASEFILEHELPER_H_INC - -// public ASSIMP headers -#include <assimp/anim.h> -#include <assimp/mesh.h> -#include <assimp/types.h> - -#ifndef ASSIMP_BUILD_NO_3DS_IMPORTER - -// for some helper routines like IsSpace() -#include <assimp/ParsingUtils.h> -#include <assimp/qnan.h> - -// ASE is quite similar to 3ds. We can reuse some structures -#include "AssetLib/3DS/3DSLoader.h" - -namespace Assimp { -namespace ASE { - -using namespace D3DS; - -// --------------------------------------------------------------------------- -/** Helper structure representing an ASE material */ -struct Material : public D3DS::Material { - //! Default constructor has been deleted - Material() = delete; - - //! Constructor with explicit name - explicit Material(const std::string &name) : - D3DS::Material(name), - pcInstance(nullptr), - bNeed(false) { - // empty - } - - Material(const Material &other) = default; - - Material &operator=(const Material &other) { - if (this == &other) { - return *this; - } - - avSubMaterials = other.avSubMaterials; - pcInstance = other.pcInstance; - bNeed = other.bNeed; - - return *this; - } - - //! Move constructor. This is explicitly written because MSVC doesn't support defaulting it - Material(Material &&other) AI_NO_EXCEPT - : D3DS::Material(std::move(other)), - avSubMaterials(std::move(other.avSubMaterials)), - pcInstance(other.pcInstance), - bNeed(other.bNeed) { - other.pcInstance = nullptr; - } - - Material &operator=(Material &&other) AI_NO_EXCEPT { - if (this == &other) { - return *this; - } - - //D3DS::Material::operator=(std::move(other)); - - avSubMaterials = std::move(other.avSubMaterials); - pcInstance = other.pcInstance; - bNeed = other.bNeed; - - other.pcInstance = nullptr; - - return *this; - } - - ~Material() {} - - //! Contains all sub materials of this material - std::vector<Material> avSubMaterials; - - //! aiMaterial object - aiMaterial *pcInstance; - - //! Can we remove this material? - bool bNeed; -}; - -// --------------------------------------------------------------------------- -/** Helper structure to represent an ASE file face */ -struct Face : public FaceWithSmoothingGroup { - //! Default constructor. Initializes everything with 0 - Face() AI_NO_EXCEPT - : iMaterial(DEFAULT_MATINDEX), - iFace(0) { - // empty - } - - //! special value to indicate that no material index has - //! been assigned to a face. The default material index - //! will replace this value later. - static const unsigned int DEFAULT_MATINDEX = 0xFFFFFFFF; - - //! Indices into each list of texture coordinates - unsigned int amUVIndices[AI_MAX_NUMBER_OF_TEXTURECOORDS][3]; - - //! Index into the list of vertex colors - unsigned int mColorIndices[3]; - - //! (Sub)Material index to be assigned to this face - unsigned int iMaterial; - - //! Index of the face. It is not specified whether it is - //! a requirement of the file format that all faces are - //! written in sequential order, so we have to expect this case - unsigned int iFace; -}; - -// --------------------------------------------------------------------------- -/** Helper structure to represent an ASE file bone */ -struct Bone { - //! Constructor - Bone() = delete; - - //! Construction from an existing name - explicit Bone(const std::string &name) : - mName(name) { - // empty - } - - //! Name of the bone - std::string mName; -}; - -// --------------------------------------------------------------------------- -/** Helper structure to represent an ASE file bone vertex */ -struct BoneVertex { - //! Bone and corresponding vertex weight. - //! -1 for unrequired bones .... - std::vector<std::pair<int, float>> mBoneWeights; -}; - -// --------------------------------------------------------------------------- -/** Helper structure to represent an ASE file animation */ -struct Animation { - enum Type { - TRACK = 0x0, - BEZIER = 0x1, - TCB = 0x2 - } mRotationType, - mScalingType, mPositionType; - - Animation() AI_NO_EXCEPT - : mRotationType(TRACK), - mScalingType(TRACK), - mPositionType(TRACK) { - // empty - } - - //! List of track rotation keyframes - std::vector<aiQuatKey> akeyRotations; - - //! List of track position keyframes - std::vector<aiVectorKey> akeyPositions; - - //! List of track scaling keyframes - std::vector<aiVectorKey> akeyScaling; -}; - -// --------------------------------------------------------------------------- -/** Helper structure to represent the inheritance information of an ASE node */ -struct InheritanceInfo { - //! Default constructor - InheritanceInfo() AI_NO_EXCEPT { - for (size_t i = 0; i < 3; ++i) { - abInheritPosition[i] = abInheritRotation[i] = abInheritScaling[i] = true; - } - } - - //! Inherit the parent's position?, axis order is x,y,z - bool abInheritPosition[3]; - - //! Inherit the parent's rotation?, axis order is x,y,z - bool abInheritRotation[3]; - - //! Inherit the parent's scaling?, axis order is x,y,z - bool abInheritScaling[3]; -}; - -// --------------------------------------------------------------------------- -/** Represents an ASE file node. Base class for mesh, light and cameras */ -struct BaseNode { - enum Type { - Light, - Camera, - Mesh, - Dummy - } mType; - - //! Construction from an existing name - BaseNode(Type _mType, const std::string &name) : - mType(_mType), mName(name), mProcessed(false) { - // Set mTargetPosition to qnan - const ai_real qnan = get_qnan(); - mTargetPosition.x = qnan; - } - - //! Name of the mesh - std::string mName; - - //! Name of the parent of the node - //! "" if there is no parent ... - std::string mParent; - - //! Transformation matrix of the node - aiMatrix4x4 mTransform; - - //! Target position (target lights and cameras) - aiVector3D mTargetPosition; - - //! Specifies which axes transformations a node inherits - //! from its parent ... - InheritanceInfo inherit; - - //! Animation channels for the node - Animation mAnim; - - //! Needed for lights and cameras: target animation channel - //! Should contain position keys only. - Animation mTargetAnim; - - bool mProcessed; -}; - -// --------------------------------------------------------------------------- -/** Helper structure to represent an ASE file mesh */ -struct Mesh : public MeshWithSmoothingGroups<ASE::Face>, public BaseNode { - //! Default constructor has been deleted - Mesh() = delete; - - //! Construction from an existing name - explicit Mesh(const std::string &name) : - BaseNode(BaseNode::Mesh, name), mVertexColors(), mBoneVertices(), mBones(), iMaterialIndex(Face::DEFAULT_MATINDEX), bSkip(false) { - for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) { - this->mNumUVComponents[c] = 2; - } - } - - //! List of all texture coordinate sets - std::vector<aiVector3D> amTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS]; - - //! List of all vertex color sets. - std::vector<aiColor4D> mVertexColors; - - //! List of all bone vertices - std::vector<BoneVertex> mBoneVertices; - - //! List of all bones - std::vector<Bone> mBones; - - //! Material index of the mesh - unsigned int iMaterialIndex; - - //! Number of vertex components for each UVW set - unsigned int mNumUVComponents[AI_MAX_NUMBER_OF_TEXTURECOORDS]; - - //! used internally - bool bSkip; -}; - -// --------------------------------------------------------------------------- -/** Helper structure to represent an ASE light source */ -struct Light : public BaseNode { - enum LightType { - OMNI, - TARGET, - FREE, - DIRECTIONAL - }; - - //! Default constructor has been deleted - Light() = delete; - - //! Construction from an existing name - explicit Light(const std::string &name) : - BaseNode(BaseNode::Light, name), mLightType(OMNI), mColor(1.f, 1.f, 1.f), mIntensity(1.f) // light is white by default - , - mAngle(45.f), - mFalloff(0.f) { - } - - LightType mLightType; - aiColor3D mColor; - ai_real mIntensity; - ai_real mAngle; // in degrees - ai_real mFalloff; -}; - -// --------------------------------------------------------------------------- -/** Helper structure to represent an ASE camera */ -struct Camera : public BaseNode { - enum CameraType { - FREE, - TARGET - }; - - //! Default constructor has been deleted - Camera() = delete; - - //! Construction from an existing name - explicit Camera(const std::string &name) : - BaseNode(BaseNode::Camera, name), mFOV(0.75f) // in radians - , - mNear(0.1f), - mFar(1000.f) // could be zero - , - mCameraType(FREE) { - } - - ai_real mFOV, mNear, mFar; - CameraType mCameraType; -}; - -// --------------------------------------------------------------------------- -/** Helper structure to represent an ASE helper object (dummy) */ -struct Dummy : public BaseNode { - //! Constructor - Dummy() AI_NO_EXCEPT - : BaseNode(BaseNode::Dummy, "DUMMY") { - // empty - } -}; - -// Parameters to Parser::Parse() -#define AI_ASE_NEW_FILE_FORMAT 200 -#define AI_ASE_OLD_FILE_FORMAT 110 - -// Internally we're a little bit more tolerant -#define AI_ASE_IS_NEW_FILE_FORMAT() (iFileFormat >= 200) -#define AI_ASE_IS_OLD_FILE_FORMAT() (iFileFormat < 200) - -// ------------------------------------------------------------------------------- -/** \brief Class to parse ASE files - */ -class Parser { -private: - Parser() AI_NO_EXCEPT { - // empty - } - -public: - // ------------------------------------------------------------------- - //! Construct a parser from a given input file which is - //! guaranteed to be terminated with zero. - //! @param szFile Input file - //! @param fileFormatDefault Assumed file format version. If the - //! file format is specified in the file the new value replaces - //! the default value. - Parser(const char *szFile, unsigned int fileFormatDefault); - - // ------------------------------------------------------------------- - //! Parses the file into the parsers internal representation - void Parse(); - -private: - // ------------------------------------------------------------------- - //! Parse the *SCENE block in a file - void ParseLV1SceneBlock(); - - // ------------------------------------------------------------------- - //! Parse the *MESH_SOFTSKINVERTS block in a file - void ParseLV1SoftSkinBlock(); - - // ------------------------------------------------------------------- - //! Parse the *MATERIAL_LIST block in a file - void ParseLV1MaterialListBlock(); - - // ------------------------------------------------------------------- - //! Parse a *<xxx>OBJECT block in a file - //! \param mesh Node to be filled - void ParseLV1ObjectBlock(BaseNode &mesh); - - // ------------------------------------------------------------------- - //! Parse a *MATERIAL blocks in a material list - //! \param mat Material structure to be filled - void ParseLV2MaterialBlock(Material &mat); - - // ------------------------------------------------------------------- - //! Parse a *NODE_TM block in a file - //! \param mesh Node (!) object to be filled - void ParseLV2NodeTransformBlock(BaseNode &mesh); - - // ------------------------------------------------------------------- - //! Parse a *TM_ANIMATION block in a file - //! \param mesh Mesh object to be filled - void ParseLV2AnimationBlock(BaseNode &mesh); - void ParseLV3PosAnimationBlock(ASE::Animation &anim); - void ParseLV3ScaleAnimationBlock(ASE::Animation &anim); - void ParseLV3RotAnimationBlock(ASE::Animation &anim); - - // ------------------------------------------------------------------- - //! Parse a *MESH block in a file - //! \param mesh Mesh object to be filled - void ParseLV2MeshBlock(Mesh &mesh); - - // ------------------------------------------------------------------- - //! Parse a *LIGHT_SETTINGS block in a file - //! \param light Light object to be filled - void ParseLV2LightSettingsBlock(Light &light); - - // ------------------------------------------------------------------- - //! Parse a *CAMERA_SETTINGS block in a file - //! \param cam Camera object to be filled - void ParseLV2CameraSettingsBlock(Camera &cam); - - // ------------------------------------------------------------------- - //! Parse the *MAP_XXXXXX blocks in a material - //! \param map Texture structure to be filled - void ParseLV3MapBlock(Texture &map); - - // ------------------------------------------------------------------- - //! Parse a *MESH_VERTEX_LIST block in a file - //! \param iNumVertices Value of *MESH_NUMVERTEX, if present. - //! Otherwise zero. This is used to check the consistency of the file. - //! A warning is sent to the logger if the validations fails. - //! \param mesh Mesh object to be filled - void ParseLV3MeshVertexListBlock( - unsigned int iNumVertices, Mesh &mesh); - - // ------------------------------------------------------------------- - //! Parse a *MESH_FACE_LIST block in a file - //! \param iNumFaces Value of *MESH_NUMFACES, if present. - //! Otherwise zero. This is used to check the consistency of the file. - //! A warning is sent to the logger if the validations fails. - //! \param mesh Mesh object to be filled - void ParseLV3MeshFaceListBlock( - unsigned int iNumFaces, Mesh &mesh); - - // ------------------------------------------------------------------- - //! Parse a *MESH_TVERT_LIST block in a file - //! \param iNumVertices Value of *MESH_NUMTVERTEX, if present. - //! Otherwise zero. This is used to check the consistency of the file. - //! A warning is sent to the logger if the validations fails. - //! \param mesh Mesh object to be filled - //! \param iChannel Output UVW channel - void ParseLV3MeshTListBlock( - unsigned int iNumVertices, Mesh &mesh, unsigned int iChannel = 0); - - // ------------------------------------------------------------------- - //! Parse a *MESH_TFACELIST block in a file - //! \param iNumFaces Value of *MESH_NUMTVFACES, if present. - //! Otherwise zero. This is used to check the consistency of the file. - //! A warning is sent to the logger if the validations fails. - //! \param mesh Mesh object to be filled - //! \param iChannel Output UVW channel - void ParseLV3MeshTFaceListBlock( - unsigned int iNumFaces, Mesh &mesh, unsigned int iChannel = 0); - - // ------------------------------------------------------------------- - //! Parse an additional mapping channel - //! (specified via *MESH_MAPPINGCHANNEL) - //! \param iChannel Channel index to be filled - //! \param mesh Mesh object to be filled - void ParseLV3MappingChannel( - unsigned int iChannel, Mesh &mesh); - - // ------------------------------------------------------------------- - //! Parse a *MESH_CVERTLIST block in a file - //! \param iNumVertices Value of *MESH_NUMCVERTEX, if present. - //! Otherwise zero. This is used to check the consistency of the file. - //! A warning is sent to the logger if the validations fails. - //! \param mesh Mesh object to be filled - void ParseLV3MeshCListBlock( - unsigned int iNumVertices, Mesh &mesh); - - // ------------------------------------------------------------------- - //! Parse a *MESH_CFACELIST block in a file - //! \param iNumFaces Value of *MESH_NUMCVFACES, if present. - //! Otherwise zero. This is used to check the consistency of the file. - //! A warning is sent to the logger if the validations fails. - //! \param mesh Mesh object to be filled - void ParseLV3MeshCFaceListBlock( - unsigned int iNumFaces, Mesh &mesh); - - // ------------------------------------------------------------------- - //! Parse a *MESH_NORMALS block in a file - //! \param mesh Mesh object to be filled - void ParseLV3MeshNormalListBlock(Mesh &mesh); - - // ------------------------------------------------------------------- - //! Parse a *MESH_WEIGHTSblock in a file - //! \param mesh Mesh object to be filled - void ParseLV3MeshWeightsBlock(Mesh &mesh); - - // ------------------------------------------------------------------- - //! Parse the bone list of a file - //! \param mesh Mesh object to be filled - //! \param iNumBones Number of bones in the mesh - void ParseLV4MeshBones(unsigned int iNumBones, Mesh &mesh); - - // ------------------------------------------------------------------- - //! Parse the bone vertices list of a file - //! \param mesh Mesh object to be filled - //! \param iNumVertices Number of vertices to be parsed - void ParseLV4MeshBonesVertices(unsigned int iNumVertices, Mesh &mesh); - - // ------------------------------------------------------------------- - //! Parse a *MESH_FACE block in a file - //! \param out receive the face data - void ParseLV4MeshFace(ASE::Face &out); - - // ------------------------------------------------------------------- - //! Parse a *MESH_VERT block in a file - //! (also works for MESH_TVERT, MESH_CFACE, MESH_VERTCOL ...) - //! \param apOut Output buffer (3 floats) - //! \param rIndexOut Output index - void ParseLV4MeshFloatTriple(ai_real *apOut, unsigned int &rIndexOut); - - // ------------------------------------------------------------------- - //! Parse a *MESH_VERT block in a file - //! (also works for MESH_TVERT, MESH_CFACE, MESH_VERTCOL ...) - //! \param apOut Output buffer (3 floats) - void ParseLV4MeshFloatTriple(ai_real *apOut); - - // ------------------------------------------------------------------- - //! Parse a *MESH_TFACE block in a file - //! (also works for MESH_CFACE) - //! \param apOut Output buffer (3 ints) - //! \param rIndexOut Output index - void ParseLV4MeshLongTriple(unsigned int *apOut, unsigned int &rIndexOut); - - // ------------------------------------------------------------------- - //! Parse a *MESH_TFACE block in a file - //! (also works for MESH_CFACE) - //! \param apOut Output buffer (3 ints) - void ParseLV4MeshLongTriple(unsigned int *apOut); - - // ------------------------------------------------------------------- - //! Parse a single float element - //! \param fOut Output float - void ParseLV4MeshFloat(ai_real &fOut); - - // ------------------------------------------------------------------- - //! Parse a single int element - //! \param iOut Output integer - void ParseLV4MeshLong(unsigned int &iOut); - - // ------------------------------------------------------------------- - //! Skip everything to the next: '*' or '\0' - bool SkipToNextToken(); - - // ------------------------------------------------------------------- - //! Skip the current section until the token after the closing }. - //! This function handles embedded subsections correctly - bool SkipSection(); - - // ------------------------------------------------------------------- - //! Output a warning to the logger - //! \param szWarn Warn message - void LogWarning(const char *szWarn); - - // ------------------------------------------------------------------- - //! Output a message to the logger - //! \param szWarn Message - void LogInfo(const char *szWarn); - - // ------------------------------------------------------------------- - //! Output an error to the logger - //! \param szWarn Error message - AI_WONT_RETURN void LogError(const char *szWarn) AI_WONT_RETURN_SUFFIX; - - // ------------------------------------------------------------------- - //! Parse a string, enclosed in double quotation marks - //! \param out Output string - //! \param szName Name of the enclosing element -> used in error - //! messages. - //! \return false if an error occurred - bool ParseString(std::string &out, const char *szName); - -public: - //! Pointer to current data - const char *filePtr; - - //! background color to be passed to the viewer - //! QNAN if none was found - aiColor3D m_clrBackground; - - //! Base ambient color to be passed to all materials - //! QNAN if none was found - aiColor3D m_clrAmbient; - - //! List of all materials found in the file - std::vector<Material> m_vMaterials; - - //! List of all meshes found in the file - std::vector<Mesh> m_vMeshes; - - //! List of all dummies found in the file - std::vector<Dummy> m_vDummies; - - //! List of all lights found in the file - std::vector<Light> m_vLights; - - //! List of all cameras found in the file - std::vector<Camera> m_vCameras; - - //! Current line in the file - unsigned int iLineNumber; - - //! First frame - unsigned int iFirstFrame; - - //! Last frame - unsigned int iLastFrame; - - //! Frame speed - frames per second - unsigned int iFrameSpeed; - - //! Ticks per frame - unsigned int iTicksPerFrame; - - //! true if the last character read was an end-line character - bool bLastWasEndLine; - - //! File format version - unsigned int iFileFormat; -}; - -} // Namespace ASE -} // namespace Assimp - -#endif // ASSIMP_BUILD_NO_3DS_IMPORTER - -#endif // !! include guard |