summaryrefslogtreecommitdiff
path: root/src/mesh/assimp-master/code/AssetLib/ASE
diff options
context:
space:
mode:
authorsanine <sanine.not@pm.me>2022-04-16 11:55:54 -0500
committersanine <sanine.not@pm.me>2022-04-16 11:55:54 -0500
commit8fb7916a0d0cb007a4c3a4e6a31af58765268ca3 (patch)
tree52b5524a94a5b04e17a1fd7f8aca988ab6d0c75f /src/mesh/assimp-master/code/AssetLib/ASE
parentdb81b925d776103326128bf629cbdda576a223e7 (diff)
delete src/mesh/assimp-master
Diffstat (limited to 'src/mesh/assimp-master/code/AssetLib/ASE')
-rw-r--r--src/mesh/assimp-master/code/AssetLib/ASE/ASELoader.cpp1288
-rw-r--r--src/mesh/assimp-master/code/AssetLib/ASE/ASELoader.h192
-rw-r--r--src/mesh/assimp-master/code/AssetLib/ASE/ASEParser.cpp1869
-rw-r--r--src/mesh/assimp-master/code/AssetLib/ASE/ASEParser.h676
4 files changed, 0 insertions, 4025 deletions
diff --git a/src/mesh/assimp-master/code/AssetLib/ASE/ASELoader.cpp b/src/mesh/assimp-master/code/AssetLib/ASE/ASELoader.cpp
deleted file mode 100644
index caa7089..0000000
--- a/src/mesh/assimp-master/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/src/mesh/assimp-master/code/AssetLib/ASE/ASELoader.h b/src/mesh/assimp-master/code/AssetLib/ASE/ASELoader.h
deleted file mode 100644
index cd91235..0000000
--- a/src/mesh/assimp-master/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/src/mesh/assimp-master/code/AssetLib/ASE/ASEParser.cpp b/src/mesh/assimp-master/code/AssetLib/ASE/ASEParser.cpp
deleted file mode 100644
index 14eb720..0000000
--- a/src/mesh/assimp-master/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/src/mesh/assimp-master/code/AssetLib/ASE/ASEParser.h b/src/mesh/assimp-master/code/AssetLib/ASE/ASEParser.h
deleted file mode 100644
index 5c24fff..0000000
--- a/src/mesh/assimp-master/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
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-26 11:59:06 +0000