| /* |
| --------------------------------------------------------------------------- |
| Open Asset Import Library (assimp) |
| --------------------------------------------------------------------------- |
| |
| Copyright (c) 2006-2017, assimp team |
| |
| |
| All rights reserved. |
| |
| Redistribution and use of this software in source and binary forms, |
| with or without modification, are permitted provided that the following |
| conditions are met: |
| |
| * Redistributions of source code must retain the above |
| copyright notice, this list of conditions and the |
| following disclaimer. |
| |
| * Redistributions in binary form must reproduce the above |
| copyright notice, this list of conditions and the |
| following disclaimer in the documentation and/or other |
| materials provided with the distribution. |
| |
| * Neither the name of the assimp team, nor the names of its |
| contributors may be used to endorse or promote products |
| derived from this software without specific prior |
| written permission of the assimp team. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| --------------------------------------------------------------------------- |
| */ |
| |
| /** @file LWOLoader.cpp |
| * @brief Implementation of the LWO importer class |
| */ |
| |
| |
| #ifndef ASSIMP_BUILD_NO_LWO_IMPORTER |
| |
| // internal headers |
| #include "LWOLoader.h" |
| #include "StringComparison.h" |
| #include "SGSpatialSort.h" |
| #include "ByteSwapper.h" |
| #include "ProcessHelper.h" |
| #include "ConvertToLHProcess.h" |
| #include <assimp/IOSystem.hpp> |
| #include <assimp/importerdesc.h> |
| #include <memory> |
| #include <sstream> |
| #include <iomanip> |
| #include <map> |
| |
| using namespace Assimp; |
| |
| static const aiImporterDesc desc = { |
| "LightWave/Modo Object Importer", |
| "", |
| "", |
| "https://www.lightwave3d.com/lightwave_sdk/", |
| aiImporterFlags_SupportTextFlavour, |
| 0, |
| 0, |
| 0, |
| 0, |
| "lwo lxo" |
| }; |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Constructor to be privately used by Importer |
| LWOImporter::LWOImporter() |
| : mIsLWO2(), |
| mIsLXOB(), |
| mLayers(), |
| mCurLayer(), |
| mTags(), |
| mMapping(), |
| mSurfaces(), |
| mFileBuffer(), |
| fileSize(), |
| pScene(), |
| configSpeedFlag(), |
| configLayerIndex(), |
| hasNamedLayer() |
| {} |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Destructor, private as well |
| LWOImporter::~LWOImporter() |
| {} |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Returns whether the class can handle the format of the given file. |
| bool LWOImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const |
| { |
| const std::string extension = GetExtension(pFile); |
| if (extension == "lwo" || extension == "lxo") { |
| return true; |
| } |
| |
| // if check for extension is not enough, check for the magic tokens |
| if (!extension.length() || checkSig) { |
| uint32_t tokens[3]; |
| tokens[0] = AI_LWO_FOURCC_LWOB; |
| tokens[1] = AI_LWO_FOURCC_LWO2; |
| tokens[2] = AI_LWO_FOURCC_LXOB; |
| return CheckMagicToken(pIOHandler,pFile,tokens,3,8); |
| } |
| return false; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Setup configuration properties |
| void LWOImporter::SetupProperties(const Importer* pImp) |
| { |
| configSpeedFlag = ( 0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED,0) ? true : false); |
| configLayerIndex = pImp->GetPropertyInteger (AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY,UINT_MAX); |
| configLayerName = pImp->GetPropertyString (AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY,""); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Get list of file extensions |
| const aiImporterDesc* LWOImporter::GetInfo () const |
| { |
| return &desc; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Imports the given file into the given scene structure. |
| void LWOImporter::InternReadFile( const std::string& pFile, |
| aiScene* pScene, |
| IOSystem* pIOHandler) |
| { |
| std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb")); |
| |
| // Check whether we can read from the file |
| if( file.get() == NULL) |
| throw DeadlyImportError( "Failed to open LWO file " + pFile + "."); |
| |
| if((this->fileSize = (unsigned int)file->FileSize()) < 12) |
| throw DeadlyImportError("LWO: The file is too small to contain the IFF header"); |
| |
| // Allocate storage and copy the contents of the file to a memory buffer |
| std::vector< uint8_t > mBuffer(fileSize); |
| file->Read( &mBuffer[0], 1, fileSize); |
| this->pScene = pScene; |
| |
| // Determine the type of the file |
| uint32_t fileType; |
| const char* sz = IFF::ReadHeader(&mBuffer[0],fileType); |
| if (sz)throw DeadlyImportError(sz); |
| |
| mFileBuffer = &mBuffer[0] + 12; |
| fileSize -= 12; |
| |
| // Initialize some members with their default values |
| hasNamedLayer = false; |
| |
| // Create temporary storage on the stack but store pointers to it in the class |
| // instance. Therefore everything will be destructed properly if an exception |
| // is thrown and we needn't take care of that. |
| LayerList _mLayers; |
| SurfaceList _mSurfaces; |
| TagList _mTags; |
| TagMappingTable _mMapping; |
| |
| mLayers = &_mLayers; |
| mTags = &_mTags; |
| mMapping = &_mMapping; |
| mSurfaces = &_mSurfaces; |
| |
| // Allocate a default layer (layer indices are 1-based from now) |
| mLayers->push_back(Layer()); |
| mCurLayer = &mLayers->back(); |
| mCurLayer->mName = "<LWODefault>"; |
| mCurLayer->mIndex = -1; |
| |
| // old lightwave file format (prior to v6) |
| if (AI_LWO_FOURCC_LWOB == fileType) { |
| DefaultLogger::get()->info("LWO file format: LWOB (<= LightWave 5.5)"); |
| |
| mIsLWO2 = false; |
| mIsLXOB = false; |
| LoadLWOBFile(); |
| } |
| // New lightwave format |
| else if (AI_LWO_FOURCC_LWO2 == fileType) { |
| mIsLXOB = false; |
| DefaultLogger::get()->info("LWO file format: LWO2 (>= LightWave 6)"); |
| } |
| // MODO file format |
| else if (AI_LWO_FOURCC_LXOB == fileType) { |
| mIsLXOB = true; |
| DefaultLogger::get()->info("LWO file format: LXOB (Modo)"); |
| } |
| // we don't know this format |
| else |
| { |
| char szBuff[5]; |
| szBuff[0] = (char)(fileType >> 24u); |
| szBuff[1] = (char)(fileType >> 16u); |
| szBuff[2] = (char)(fileType >> 8u); |
| szBuff[3] = (char)(fileType); |
| szBuff[4] = '\0'; |
| throw DeadlyImportError(std::string("Unknown LWO sub format: ") + szBuff); |
| } |
| |
| if (AI_LWO_FOURCC_LWOB != fileType) { |
| mIsLWO2 = true; |
| LoadLWO2File(); |
| |
| // The newer lightwave format allows the user to configure the |
| // loader that just one layer is used. If this is the case |
| // we need to check now whether the requested layer has been found. |
| if (UINT_MAX != configLayerIndex) { |
| unsigned int layerCount = 0; |
| for(std::list<LWO::Layer>::iterator itLayers=mLayers->begin(); itLayers!=mLayers->end(); ++itLayers) |
| if (!itLayers->skip) |
| layerCount++; |
| if (layerCount!=2) |
| throw DeadlyImportError("LWO2: The requested layer was not found"); |
| } |
| |
| if (configLayerName.length() && !hasNamedLayer) { |
| throw DeadlyImportError("LWO2: Unable to find the requested layer: " |
| + configLayerName); |
| } |
| } |
| |
| // now, as we have loaded all data, we can resolve cross-referenced tags and clips |
| ResolveTags(); |
| ResolveClips(); |
| |
| // now process all layers and build meshes and nodes |
| std::vector<aiMesh*> apcMeshes; |
| std::map<uint16_t, aiNode*> apcNodes; |
| |
| apcMeshes.reserve(mLayers->size()*std::min(((unsigned int)mSurfaces->size()/2u), 1u)); |
| |
| unsigned int iDefaultSurface = UINT_MAX; // index of the default surface |
| for (LWO::Layer &layer : *mLayers) { |
| if (layer.skip) |
| continue; |
| |
| // I don't know whether there could be dummy layers, but it would be possible |
| const unsigned int meshStart = (unsigned int)apcMeshes.size(); |
| if (!layer.mFaces.empty() && !layer.mTempPoints.empty()) { |
| |
| // now sort all faces by the surfaces assigned to them |
| std::vector<SortedRep> pSorted(mSurfaces->size()+1); |
| |
| unsigned int i = 0; |
| for (FaceList::iterator it = layer.mFaces.begin(), end = layer.mFaces.end();it != end;++it,++i) { |
| // Check whether we support this face's type |
| if ((*it).type != AI_LWO_FACE && (*it).type != AI_LWO_PTCH && |
| (*it).type != AI_LWO_BONE && (*it).type != AI_LWO_SUBD) { |
| continue; |
| } |
| |
| unsigned int idx = (*it).surfaceIndex; |
| if (idx >= mTags->size()) |
| { |
| DefaultLogger::get()->warn("LWO: Invalid face surface index"); |
| idx = UINT_MAX; |
| } |
| if(UINT_MAX == idx || UINT_MAX == (idx = _mMapping[idx])) { |
| if (UINT_MAX == iDefaultSurface) { |
| iDefaultSurface = (unsigned int)mSurfaces->size(); |
| mSurfaces->push_back(LWO::Surface()); |
| LWO::Surface& surf = mSurfaces->back(); |
| surf.mColor.r = surf.mColor.g = surf.mColor.b = 0.6f; |
| surf.mName = "LWODefaultSurface"; |
| } |
| idx = iDefaultSurface; |
| } |
| pSorted[idx].push_back(i); |
| } |
| if (UINT_MAX == iDefaultSurface) { |
| pSorted.erase(pSorted.end()-1); |
| } |
| for (unsigned int p = 0,i = 0;i < mSurfaces->size();++i) { |
| SortedRep& sorted = pSorted[i]; |
| if (sorted.empty()) |
| continue; |
| |
| // generate the mesh |
| aiMesh* mesh = new aiMesh(); |
| apcMeshes.push_back(mesh); |
| mesh->mNumFaces = (unsigned int)sorted.size(); |
| |
| // count the number of vertices |
| SortedRep::const_iterator it = sorted.begin(), end = sorted.end(); |
| for (;it != end;++it) { |
| mesh->mNumVertices += layer.mFaces[*it].mNumIndices; |
| } |
| |
| aiVector3D *nrm = NULL, * pv = mesh->mVertices = new aiVector3D[mesh->mNumVertices]; |
| aiFace* pf = mesh->mFaces = new aiFace[mesh->mNumFaces]; |
| mesh->mMaterialIndex = i; |
| |
| // find out which vertex color channels and which texture coordinate |
| // channels are really required by the material attached to this mesh |
| unsigned int vUVChannelIndices[AI_MAX_NUMBER_OF_TEXTURECOORDS]; |
| unsigned int vVColorIndices[AI_MAX_NUMBER_OF_COLOR_SETS]; |
| |
| #ifdef ASSIMP_BUILD_DEBUG |
| for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_TEXTURECOORDS;++mui ) { |
| vUVChannelIndices[mui] = UINT_MAX; |
| } |
| for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_COLOR_SETS;++mui ) { |
| vVColorIndices[mui] = UINT_MAX; |
| } |
| #endif |
| |
| FindUVChannels(_mSurfaces[i],sorted,layer,vUVChannelIndices); |
| FindVCChannels(_mSurfaces[i],sorted,layer,vVColorIndices); |
| |
| // allocate storage for UV and CV channels |
| aiVector3D* pvUV[AI_MAX_NUMBER_OF_TEXTURECOORDS]; |
| for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_TEXTURECOORDS;++mui ) { |
| if (UINT_MAX == vUVChannelIndices[mui]) { |
| break; |
| } |
| |
| pvUV[mui] = mesh->mTextureCoords[mui] = new aiVector3D[mesh->mNumVertices]; |
| |
| // LightWave doesn't support more than 2 UV components (?) |
| mesh->mNumUVComponents[0] = 2; |
| } |
| |
| if (layer.mNormals.name.length()) |
| nrm = mesh->mNormals = new aiVector3D[mesh->mNumVertices]; |
| |
| aiColor4D* pvVC[AI_MAX_NUMBER_OF_COLOR_SETS]; |
| for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_COLOR_SETS;++mui) { |
| if (UINT_MAX == vVColorIndices[mui]) { |
| break; |
| } |
| pvVC[mui] = mesh->mColors[mui] = new aiColor4D[mesh->mNumVertices]; |
| } |
| |
| // we would not need this extra array, but the code is much cleaner if we use it |
| std::vector<unsigned int>& smoothingGroups = layer.mPointReferrers; |
| smoothingGroups.erase (smoothingGroups.begin(),smoothingGroups.end()); |
| smoothingGroups.resize(mesh->mNumFaces,0); |
| |
| // now convert all faces |
| unsigned int vert = 0; |
| std::vector<unsigned int>::iterator outIt = smoothingGroups.begin(); |
| for (it = sorted.begin(); it != end;++it,++outIt) { |
| const LWO::Face& face = layer.mFaces[*it]; |
| *outIt = face.smoothGroup; |
| |
| // copy all vertices |
| for (unsigned int q = 0; q < face.mNumIndices;++q,++vert) { |
| unsigned int idx = face.mIndices[q]; |
| *pv++ = layer.mTempPoints[idx] /*- layer.mPivot*/; |
| |
| // process UV coordinates |
| for (unsigned int w = 0; w < AI_MAX_NUMBER_OF_TEXTURECOORDS;++w) { |
| if (UINT_MAX == vUVChannelIndices[w]) { |
| break; |
| } |
| aiVector3D*& pp = pvUV[w]; |
| const aiVector2D& src = ((aiVector2D*)&layer.mUVChannels[vUVChannelIndices[w]].rawData[0])[idx]; |
| pp->x = src.x; |
| pp->y = src.y; |
| pp++; |
| } |
| |
| // process normals (MODO extension) |
| if (nrm) { |
| *nrm = ((aiVector3D*)&layer.mNormals.rawData[0])[idx]; |
| nrm->z *= -1.f; |
| ++nrm; |
| } |
| |
| // process vertex colors |
| for (unsigned int w = 0; w < AI_MAX_NUMBER_OF_COLOR_SETS;++w) { |
| if (UINT_MAX == vVColorIndices[w]) { |
| break; |
| } |
| *pvVC[w] = ((aiColor4D*)&layer.mVColorChannels[vVColorIndices[w]].rawData[0])[idx]; |
| |
| // If a RGB color map is explicitly requested delete the |
| // alpha channel - it could theoretically be != 1. |
| if(_mSurfaces[i].mVCMapType == AI_LWO_RGB) |
| pvVC[w]->a = 1.f; |
| |
| pvVC[w]++; |
| } |
| |
| #if 0 |
| // process vertex weights. We can't properly reconstruct the whole skeleton for now, |
| // but we can create dummy bones for all weight channels which we have. |
| for (unsigned int w = 0; w < layer.mWeightChannels.size();++w) |
| { |
| } |
| #endif |
| |
| face.mIndices[q] = vert; |
| } |
| pf->mIndices = face.mIndices; |
| pf->mNumIndices = face.mNumIndices; |
| unsigned int** p = (unsigned int**)&face.mIndices;*p = NULL; // HACK: make sure it won't be deleted |
| pf++; |
| } |
| |
| if (!mesh->mNormals) { |
| // Compute normal vectors for the mesh - we can't use our GenSmoothNormal- |
| // Step here since it wouldn't handle smoothing groups correctly for LWO. |
| // So we use a separate implementation. |
| ComputeNormals(mesh,smoothingGroups,_mSurfaces[i]); |
| } |
| else DefaultLogger::get()->debug("LWO2: No need to compute normals, they're already there"); |
| ++p; |
| } |
| } |
| |
| // Generate nodes to render the mesh. Store the source layer in the mParent member of the nodes |
| unsigned int num = static_cast<unsigned int>(apcMeshes.size() - meshStart); |
| if (layer.mName != "<LWODefault>" || num > 0) { |
| aiNode* pcNode = new aiNode(); |
| apcNodes[layer.mIndex] = pcNode; |
| pcNode->mName.Set(layer.mName); |
| pcNode->mParent = (aiNode*)&layer; |
| pcNode->mNumMeshes = num; |
| |
| if (pcNode->mNumMeshes) { |
| pcNode->mMeshes = new unsigned int[pcNode->mNumMeshes]; |
| for (unsigned int p = 0; p < pcNode->mNumMeshes;++p) |
| pcNode->mMeshes[p] = p + meshStart; |
| } |
| } |
| } |
| |
| if (apcNodes.empty() || apcMeshes.empty()) |
| throw DeadlyImportError("LWO: No meshes loaded"); |
| |
| // The RemoveRedundantMaterials step will clean this up later |
| pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials = (unsigned int)mSurfaces->size()]; |
| for (unsigned int mat = 0; mat < pScene->mNumMaterials;++mat) { |
| aiMaterial* pcMat = new aiMaterial(); |
| pScene->mMaterials[mat] = pcMat; |
| ConvertMaterial((*mSurfaces)[mat],pcMat); |
| } |
| |
| // copy the meshes to the output structure |
| pScene->mMeshes = new aiMesh*[ pScene->mNumMeshes = (unsigned int)apcMeshes.size() ]; |
| ::memcpy(pScene->mMeshes,&apcMeshes[0],pScene->mNumMeshes*sizeof(void*)); |
| |
| // generate the final node graph |
| GenerateNodeGraph(apcNodes); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void LWOImporter::ComputeNormals(aiMesh* mesh, const std::vector<unsigned int>& smoothingGroups, |
| const LWO::Surface& surface) |
| { |
| // Allocate output storage |
| mesh->mNormals = new aiVector3D[mesh->mNumVertices]; |
| |
| // First generate per-face normals |
| aiVector3D* out; |
| std::vector<aiVector3D> faceNormals; |
| |
| // ... in some cases that's already enough |
| if (!surface.mMaximumSmoothAngle) |
| out = mesh->mNormals; |
| else { |
| faceNormals.resize(mesh->mNumVertices); |
| out = &faceNormals[0]; |
| } |
| |
| aiFace* begin = mesh->mFaces, *const end = mesh->mFaces+mesh->mNumFaces; |
| for (; begin != end; ++begin) { |
| aiFace& face = *begin; |
| |
| if(face.mNumIndices < 3) { |
| continue; |
| } |
| |
| // LWO doc: "the normal is defined as the cross product of the first and last edges" |
| aiVector3D* pV1 = mesh->mVertices + face.mIndices[0]; |
| aiVector3D* pV2 = mesh->mVertices + face.mIndices[1]; |
| aiVector3D* pV3 = mesh->mVertices + face.mIndices[face.mNumIndices-1]; |
| |
| aiVector3D vNor = ((*pV2 - *pV1) ^(*pV3 - *pV1)).Normalize(); |
| for (unsigned int i = 0; i < face.mNumIndices;++i) |
| out[face.mIndices[i]] = vNor; |
| } |
| if (!surface.mMaximumSmoothAngle)return; |
| const float posEpsilon = ComputePositionEpsilon(mesh); |
| |
| // Now generate the spatial sort tree |
| SGSpatialSort sSort; |
| std::vector<unsigned int>::const_iterator it = smoothingGroups.begin(); |
| for( begin = mesh->mFaces; begin != end; ++begin, ++it) |
| { |
| aiFace& face = *begin; |
| for (unsigned int i = 0; i < face.mNumIndices;++i) |
| { |
| unsigned int tt = face.mIndices[i]; |
| sSort.Add(mesh->mVertices[tt],tt,*it); |
| } |
| } |
| // Sort everything - this takes O(nlogn) time |
| sSort.Prepare(); |
| std::vector<unsigned int> poResult; |
| poResult.reserve(20); |
| |
| // Generate vertex normals. We have O(logn) for the binary lookup, which we need |
| // for n elements, thus the EXPECTED complexity is O(nlogn) |
| if (surface.mMaximumSmoothAngle < 3.f && !configSpeedFlag) { |
| const float fLimit = std::cos(surface.mMaximumSmoothAngle); |
| |
| for( begin = mesh->mFaces, it = smoothingGroups.begin(); begin != end; ++begin, ++it) { |
| const aiFace& face = *begin; |
| unsigned int* beginIdx = face.mIndices, *const endIdx = face.mIndices+face.mNumIndices; |
| for (; beginIdx != endIdx; ++beginIdx) |
| { |
| unsigned int idx = *beginIdx; |
| sSort.FindPositions(mesh->mVertices[idx],*it,posEpsilon,poResult,true); |
| std::vector<unsigned int>::const_iterator a, end = poResult.end(); |
| |
| aiVector3D vNormals; |
| for (a = poResult.begin();a != end;++a) { |
| const aiVector3D& v = faceNormals[*a]; |
| if (v * faceNormals[idx] < fLimit) |
| continue; |
| vNormals += v; |
| } |
| mesh->mNormals[idx] = vNormals.Normalize(); |
| } |
| } |
| } |
| // faster code path in case there is no smooth angle |
| else { |
| std::vector<bool> vertexDone(mesh->mNumVertices,false); |
| for( begin = mesh->mFaces, it = smoothingGroups.begin(); begin != end; ++begin, ++it) { |
| const aiFace& face = *begin; |
| unsigned int* beginIdx = face.mIndices, *const endIdx = face.mIndices+face.mNumIndices; |
| for (; beginIdx != endIdx; ++beginIdx) |
| { |
| unsigned int idx = *beginIdx; |
| if (vertexDone[idx]) |
| continue; |
| sSort.FindPositions(mesh->mVertices[idx],*it,posEpsilon,poResult,true); |
| std::vector<unsigned int>::const_iterator a, end = poResult.end(); |
| |
| aiVector3D vNormals; |
| for (a = poResult.begin();a != end;++a) { |
| const aiVector3D& v = faceNormals[*a]; |
| vNormals += v; |
| } |
| vNormals.Normalize(); |
| for (a = poResult.begin();a != end;++a) { |
| mesh->mNormals[*a] = vNormals; |
| vertexDone[*a] = true; |
| } |
| } |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void LWOImporter::GenerateNodeGraph(std::map<uint16_t,aiNode*>& apcNodes) |
| { |
| // now generate the final nodegraph - generate a root node and attach children |
| aiNode* root = pScene->mRootNode = new aiNode(); |
| root->mName.Set("<LWORoot>"); |
| |
| //Set parent of all children, inserting pivots |
| //std::cout << "Set parent of all children" << std::endl; |
| std::map<uint16_t, aiNode*> mapPivot; |
| for (std::map<uint16_t,aiNode*>::iterator itapcNodes = apcNodes.begin(); itapcNodes != apcNodes.end(); ++itapcNodes) { |
| |
| //Get the parent index |
| LWO::Layer* nodeLayer = (LWO::Layer*)(itapcNodes->second->mParent); |
| uint16_t parentIndex = nodeLayer->mParent; |
| |
| //Create pivot node, store it into the pivot map, and set the parent as the pivot |
| aiNode* pivotNode = new aiNode(); |
| pivotNode->mName.Set("Pivot-"+std::string(itapcNodes->second->mName.data)); |
| mapPivot[-(itapcNodes->first+2)] = pivotNode; |
| itapcNodes->second->mParent = pivotNode; |
| |
| //Look for the parent node to attach the pivot to |
| if (apcNodes.find(parentIndex) != apcNodes.end()) { |
| pivotNode->mParent = apcNodes[parentIndex]; |
| } else { |
| //If not, attach to the root node |
| pivotNode->mParent = root; |
| } |
| |
| //Set the node and the pivot node transformation |
| itapcNodes->second->mTransformation.a4 = -nodeLayer->mPivot.x; |
| itapcNodes->second->mTransformation.b4 = -nodeLayer->mPivot.y; |
| itapcNodes->second->mTransformation.c4 = -nodeLayer->mPivot.z; |
| pivotNode->mTransformation.a4 = nodeLayer->mPivot.x; |
| pivotNode->mTransformation.b4 = nodeLayer->mPivot.y; |
| pivotNode->mTransformation.c4 = nodeLayer->mPivot.z; |
| } |
| |
| //Merge pivot map into node map |
| //std::cout << "Merge pivot map into node map" << std::endl; |
| for (std::map<uint16_t, aiNode*>::iterator itMapPivot = mapPivot.begin(); itMapPivot != mapPivot.end(); ++itMapPivot) { |
| apcNodes[itMapPivot->first] = itMapPivot->second; |
| } |
| |
| //Set children of all parents |
| apcNodes[-1] = root; |
| for (std::map<uint16_t,aiNode*>::iterator itMapParentNodes = apcNodes.begin(); itMapParentNodes != apcNodes.end(); ++itMapParentNodes) { |
| for (std::map<uint16_t,aiNode*>::iterator itMapChildNodes = apcNodes.begin(); itMapChildNodes != apcNodes.end(); ++itMapChildNodes) { |
| if ((itMapParentNodes->first != itMapChildNodes->first) && (itMapParentNodes->second == itMapChildNodes->second->mParent)) { |
| ++(itMapParentNodes->second->mNumChildren); |
| } |
| } |
| if (itMapParentNodes->second->mNumChildren) { |
| itMapParentNodes->second->mChildren = new aiNode* [ itMapParentNodes->second->mNumChildren ]; |
| uint16_t p = 0; |
| for (std::map<uint16_t,aiNode*>::iterator itMapChildNodes = apcNodes.begin(); itMapChildNodes != apcNodes.end(); ++itMapChildNodes) { |
| if ((itMapParentNodes->first != itMapChildNodes->first) && (itMapParentNodes->second == itMapChildNodes->second->mParent)) { |
| itMapParentNodes->second->mChildren[p++] = itMapChildNodes->second; |
| } |
| } |
| } |
| } |
| |
| if (!pScene->mRootNode->mNumChildren) |
| throw DeadlyImportError("LWO: Unable to build a valid node graph"); |
| |
| // Remove a single root node with no meshes assigned to it ... |
| if (1 == pScene->mRootNode->mNumChildren) { |
| aiNode* pc = pScene->mRootNode->mChildren[0]; |
| pc->mParent = pScene->mRootNode->mChildren[0] = NULL; |
| delete pScene->mRootNode; |
| pScene->mRootNode = pc; |
| } |
| |
| // convert the whole stuff to RH with CCW winding |
| MakeLeftHandedProcess maker; |
| maker.Execute(pScene); |
| |
| FlipWindingOrderProcess flipper; |
| flipper.Execute(pScene); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void LWOImporter::ResolveTags() |
| { |
| // --- this function is used for both LWO2 and LWOB |
| mMapping->resize(mTags->size(), UINT_MAX); |
| for (unsigned int a = 0; a < mTags->size();++a) { |
| |
| const std::string& c = (*mTags)[a]; |
| for (unsigned int i = 0; i < mSurfaces->size();++i) { |
| |
| const std::string& d = (*mSurfaces)[i].mName; |
| if (!ASSIMP_stricmp(c,d)) { |
| |
| (*mMapping)[a] = i; |
| break; |
| } |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void LWOImporter::ResolveClips() |
| { |
| for( unsigned int i = 0; i < mClips.size();++i) { |
| |
| Clip& clip = mClips[i]; |
| if (Clip::REF == clip.type) { |
| |
| if (clip.clipRef >= mClips.size()) { |
| DefaultLogger::get()->error("LWO2: Clip referrer index is out of range"); |
| clip.clipRef = 0; |
| } |
| |
| Clip& dest = mClips[clip.clipRef]; |
| if (Clip::REF == dest.type) { |
| DefaultLogger::get()->error("LWO2: Clip references another clip reference"); |
| clip.type = Clip::UNSUPPORTED; |
| } |
| |
| else { |
| clip.path = dest.path; |
| clip.type = dest.type; |
| } |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void LWOImporter::AdjustTexturePath(std::string& out) |
| { |
| // --- this function is used for both LWO2 and LWOB |
| if (!mIsLWO2 && ::strstr(out.c_str(), "(sequence)")) { |
| |
| // remove the (sequence) and append 000 |
| DefaultLogger::get()->info("LWOB: Sequence of animated texture found. It will be ignored"); |
| out = out.substr(0,out.length()-10) + "000"; |
| } |
| |
| // format: drive:path/file - we just need to insert a slash after the drive |
| std::string::size_type n = out.find_first_of(':'); |
| if (std::string::npos != n) { |
| out.insert(n+1,"/"); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void LWOImporter::LoadLWOTags(unsigned int size) |
| { |
| // --- this function is used for both LWO2 and LWOB |
| |
| const char* szCur = (const char*)mFileBuffer, *szLast = szCur; |
| const char* const szEnd = szLast+size; |
| while (szCur < szEnd) |
| { |
| if (!(*szCur)) |
| { |
| const size_t len = (size_t)(szCur-szLast); |
| // FIX: skip empty-sized tags |
| if (len) |
| mTags->push_back(std::string(szLast,len)); |
| szCur += (len&0x1 ? 1 : 2); |
| szLast = szCur; |
| } |
| szCur++; |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void LWOImporter::LoadLWOPoints(unsigned int length) |
| { |
| // --- this function is used for both LWO2 and LWOB but for |
| // LWO2 we need to allocate 25% more storage - it could be we'll |
| // need to duplicate some points later. |
| const size_t vertexLen = 12; |
| if ((length % vertexLen) != 0) |
| { |
| throw DeadlyImportError( "LWO2: Points chunk length is not multiple of vertexLen (12)"); |
| } |
| unsigned int regularSize = (unsigned int)mCurLayer->mTempPoints.size() + length / 12; |
| if (mIsLWO2) |
| { |
| mCurLayer->mTempPoints.reserve ( regularSize + (regularSize>>2u) ); |
| mCurLayer->mTempPoints.resize ( regularSize ); |
| |
| // initialize all point referrers with the default values |
| mCurLayer->mPointReferrers.reserve ( regularSize + (regularSize>>2u) ); |
| mCurLayer->mPointReferrers.resize ( regularSize, UINT_MAX ); |
| } |
| else mCurLayer->mTempPoints.resize( regularSize ); |
| |
| // perform endianness conversions |
| #ifndef AI_BUILD_BIG_ENDIAN |
| for (unsigned int i = 0; i < length>>2;++i) |
| ByteSwap::Swap4( mFileBuffer + (i << 2)); |
| #endif |
| ::memcpy(&mCurLayer->mTempPoints[0],mFileBuffer,length); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void LWOImporter::LoadLWO2Polygons(unsigned int length) |
| { |
| LE_NCONST uint16_t* const end = (LE_NCONST uint16_t*)(mFileBuffer+length); |
| const uint32_t type = GetU4(); |
| |
| // Determine the type of the polygons |
| switch (type) |
| { |
| // read unsupported stuff too (although we won't process it) |
| case AI_LWO_MBAL: |
| DefaultLogger::get()->warn("LWO2: Encountered unsupported primitive chunk (METABALL)"); |
| break; |
| case AI_LWO_CURV: |
| DefaultLogger::get()->warn("LWO2: Encountered unsupported primitive chunk (SPLINE)");; |
| break; |
| |
| // These are ok with no restrictions |
| case AI_LWO_PTCH: |
| case AI_LWO_FACE: |
| case AI_LWO_BONE: |
| case AI_LWO_SUBD: |
| break; |
| default: |
| |
| // hm!? wtf is this? ok ... |
| DefaultLogger::get()->error("LWO2: Ignoring unknown polygon type."); |
| break; |
| } |
| |
| // first find out how many faces and vertices we'll finally need |
| uint16_t* cursor= (uint16_t*)mFileBuffer; |
| |
| unsigned int iNumFaces = 0,iNumVertices = 0; |
| CountVertsAndFacesLWO2(iNumVertices,iNumFaces,cursor,end); |
| |
| // allocate the output array and copy face indices |
| if (iNumFaces) |
| { |
| cursor = (uint16_t*)mFileBuffer; |
| |
| mCurLayer->mFaces.resize(iNumFaces,LWO::Face(type)); |
| FaceList::iterator it = mCurLayer->mFaces.begin(); |
| CopyFaceIndicesLWO2(it,cursor,end); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void LWOImporter::CountVertsAndFacesLWO2(unsigned int& verts, unsigned int& faces, |
| uint16_t*& cursor, const uint16_t* const end, unsigned int max) |
| { |
| while (cursor < end && max--) |
| { |
| uint16_t numIndices; |
| ::memcpy(&numIndices, cursor++, 2); |
| AI_LSWAP2(numIndices); |
| numIndices &= 0x03FF; |
| |
| verts += numIndices; |
| ++faces; |
| |
| for(uint16_t i = 0; i < numIndices; i++) |
| { |
| ReadVSizedIntLWO2((uint8_t*&)cursor); |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void LWOImporter::CopyFaceIndicesLWO2(FaceList::iterator& it, |
| uint16_t*& cursor, |
| const uint16_t* const end) |
| { |
| while (cursor < end) |
| { |
| LWO::Face& face = *it++; |
| uint16_t numIndices; |
| ::memcpy(&numIndices, cursor++, 2); |
| AI_LSWAP2(numIndices); |
| face.mNumIndices = numIndices & 0x03FF; |
| |
| if(face.mNumIndices) /* byte swapping has already been done */ |
| { |
| face.mIndices = new unsigned int[face.mNumIndices]; |
| for(unsigned int i = 0; i < face.mNumIndices; i++) |
| { |
| face.mIndices[i] = ReadVSizedIntLWO2((uint8_t*&)cursor) + mCurLayer->mPointIDXOfs; |
| if(face.mIndices[i] > mCurLayer->mTempPoints.size()) |
| { |
| DefaultLogger::get()->warn("LWO2: Failure evaluating face record, index is out of range"); |
| face.mIndices[i] = (unsigned int)mCurLayer->mTempPoints.size()-1; |
| } |
| } |
| } |
| else throw DeadlyImportError("LWO2: Encountered invalid face record with zero indices"); |
| } |
| } |
| |
| |
| // ------------------------------------------------------------------------------------------------ |
| void LWOImporter::LoadLWO2PolygonTags(unsigned int length) |
| { |
| LE_NCONST uint8_t* const end = mFileBuffer+length; |
| |
| AI_LWO_VALIDATE_CHUNK_LENGTH(length,PTAG,4); |
| uint32_t type = GetU4(); |
| |
| if (type != AI_LWO_SURF && type != AI_LWO_SMGP) |
| return; |
| |
| while (mFileBuffer < end) |
| { |
| unsigned int i = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mFaceIDXOfs; |
| unsigned int j = GetU2(); |
| |
| if (i >= mCurLayer->mFaces.size()) { |
| DefaultLogger::get()->warn("LWO2: face index in PTAG is out of range"); |
| continue; |
| } |
| |
| switch (type) { |
| |
| case AI_LWO_SURF: |
| mCurLayer->mFaces[i].surfaceIndex = j; |
| break; |
| case AI_LWO_SMGP: /* is that really used? */ |
| mCurLayer->mFaces[i].smoothGroup = j; |
| break; |
| }; |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| template <class T> |
| VMapEntry* FindEntry(std::vector< T >& list,const std::string& name, bool perPoly) |
| { |
| for (auto & elem : list) { |
| if (elem.name == name) { |
| if (!perPoly) { |
| DefaultLogger::get()->warn("LWO2: Found two VMAP sections with equal names"); |
| } |
| return &elem; |
| } |
| } |
| list.push_back( T() ); |
| VMapEntry* p = &list.back(); |
| p->name = name; |
| return p; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| template <class T> |
| inline void CreateNewEntry(T& chan, unsigned int srcIdx) |
| { |
| if (!chan.name.length()) |
| return; |
| |
| chan.abAssigned[srcIdx] = true; |
| chan.abAssigned.resize(chan.abAssigned.size()+1,false); |
| |
| for (unsigned int a = 0; a < chan.dims;++a) |
| chan.rawData.push_back(chan.rawData[srcIdx*chan.dims+a]); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| template <class T> |
| inline void CreateNewEntry(std::vector< T >& list, unsigned int srcIdx) |
| { |
| for (auto &elem : list) { |
| CreateNewEntry( elem, srcIdx ); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| inline void LWOImporter::DoRecursiveVMAPAssignment(VMapEntry* base, unsigned int numRead, |
| unsigned int idx, float* data) |
| { |
| ai_assert(NULL != data); |
| LWO::ReferrerList& refList = mCurLayer->mPointReferrers; |
| unsigned int i; |
| |
| if (idx >= base->abAssigned.size()) { |
| throw DeadlyImportError("Bad index"); |
| } |
| base->abAssigned[idx] = true; |
| for (i = 0; i < numRead;++i) { |
| base->rawData[idx*base->dims+i]= data[i]; |
| } |
| |
| if (UINT_MAX != (i = refList[idx])) { |
| DoRecursiveVMAPAssignment(base,numRead,i,data); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| inline void AddToSingleLinkedList(ReferrerList& refList, unsigned int srcIdx, unsigned int destIdx) |
| { |
| if(UINT_MAX == refList[srcIdx]) { |
| refList[srcIdx] = destIdx; |
| return; |
| } |
| AddToSingleLinkedList(refList,refList[srcIdx],destIdx); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Load LWO2 vertex map |
| void LWOImporter::LoadLWO2VertexMap(unsigned int length, bool perPoly) |
| { |
| LE_NCONST uint8_t* const end = mFileBuffer+length; |
| |
| AI_LWO_VALIDATE_CHUNK_LENGTH(length,VMAP,6); |
| unsigned int type = GetU4(); |
| unsigned int dims = GetU2(); |
| |
| VMapEntry* base; |
| |
| // read the name of the vertex map |
| std::string name; |
| GetS0(name,length); |
| |
| switch (type) |
| { |
| case AI_LWO_TXUV: |
| if (dims != 2) { |
| DefaultLogger::get()->warn("LWO2: Skipping UV channel \'" |
| + name + "\' with !2 components"); |
| return; |
| } |
| base = FindEntry(mCurLayer->mUVChannels,name,perPoly); |
| break; |
| case AI_LWO_WGHT: |
| case AI_LWO_MNVW: |
| if (dims != 1) { |
| DefaultLogger::get()->warn("LWO2: Skipping Weight Channel \'" |
| + name + "\' with !1 components"); |
| return; |
| } |
| base = FindEntry((type == AI_LWO_WGHT ? mCurLayer->mWeightChannels |
| : mCurLayer->mSWeightChannels),name,perPoly); |
| break; |
| case AI_LWO_RGB: |
| case AI_LWO_RGBA: |
| if (dims != 3 && dims != 4) { |
| DefaultLogger::get()->warn("LWO2: Skipping Color Map \'" |
| + name + "\' with a dimension > 4 or < 3"); |
| return; |
| } |
| base = FindEntry(mCurLayer->mVColorChannels,name,perPoly); |
| break; |
| |
| case AI_LWO_MODO_NORM: |
| /* This is a non-standard extension chunk used by Luxology's MODO. |
| * It stores per-vertex normals. This VMAP exists just once, has |
| * 3 dimensions and is btw extremely beautiful. |
| */ |
| if (name != "vert_normals" || dims != 3 || mCurLayer->mNormals.name.length()) |
| return; |
| |
| DefaultLogger::get()->info("Processing non-standard extension: MODO VMAP.NORM.vert_normals"); |
| |
| mCurLayer->mNormals.name = name; |
| base = & mCurLayer->mNormals; |
| break; |
| |
| case AI_LWO_PICK: /* these VMAPs are just silently dropped */ |
| case AI_LWO_MORF: |
| case AI_LWO_SPOT: |
| return; |
| |
| default: |
| if (name == "APS.Level") { |
| // XXX handle this (seems to be subdivision-related). |
| } |
| DefaultLogger::get()->warn("LWO2: Skipping unknown VMAP/VMAD channel \'" + name + "\'"); |
| return; |
| }; |
| base->Allocate((unsigned int)mCurLayer->mTempPoints.size()); |
| |
| // now read all entries in the map |
| type = std::min(dims,base->dims); |
| const unsigned int diff = (dims - type)<<2u; |
| |
| LWO::FaceList& list = mCurLayer->mFaces; |
| LWO::PointList& pointList = mCurLayer->mTempPoints; |
| LWO::ReferrerList& refList = mCurLayer->mPointReferrers; |
| |
| const unsigned int numPoints = (unsigned int)pointList.size(); |
| const unsigned int numFaces = (unsigned int)list.size(); |
| |
| while (mFileBuffer < end) { |
| |
| unsigned int idx = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mPointIDXOfs; |
| if (idx >= numPoints) { |
| DefaultLogger::get()->warn("LWO2: Failure evaluating VMAP/VMAD entry \'" + name + "\', vertex index is out of range"); |
| mFileBuffer += base->dims<<2u; |
| continue; |
| } |
| if (perPoly) { |
| unsigned int polyIdx = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mFaceIDXOfs; |
| if (base->abAssigned[idx]) { |
| // we have already a VMAP entry for this vertex - thus |
| // we need to duplicate the corresponding polygon. |
| if (polyIdx >= numFaces) { |
| DefaultLogger::get()->warn("LWO2: Failure evaluating VMAD entry \'" + name + "\', polygon index is out of range"); |
| mFileBuffer += base->dims<<2u; |
| continue; |
| } |
| |
| LWO::Face& src = list[polyIdx]; |
| |
| // generate a new unique vertex for the corresponding index - but only |
| // if we can find the index in the face |
| bool had = false; |
| for (unsigned int i = 0; i < src.mNumIndices;++i) { |
| |
| unsigned int srcIdx = src.mIndices[i], tmp = idx; |
| do { |
| if (tmp == srcIdx) |
| break; |
| } |
| while ((tmp = refList[tmp]) != UINT_MAX); |
| if (tmp == UINT_MAX) { |
| continue; |
| } |
| |
| had = true; |
| refList.resize(refList.size()+1, UINT_MAX); |
| |
| idx = (unsigned int)pointList.size(); |
| src.mIndices[i] = (unsigned int)pointList.size(); |
| |
| // store the index of the new vertex in the old vertex |
| // so we get a single linked list we can traverse in |
| // only one direction |
| AddToSingleLinkedList(refList,srcIdx,src.mIndices[i]); |
| pointList.push_back(pointList[srcIdx]); |
| |
| CreateNewEntry(mCurLayer->mVColorChannels, srcIdx ); |
| CreateNewEntry(mCurLayer->mUVChannels, srcIdx ); |
| CreateNewEntry(mCurLayer->mWeightChannels, srcIdx ); |
| CreateNewEntry(mCurLayer->mSWeightChannels, srcIdx ); |
| CreateNewEntry(mCurLayer->mNormals, srcIdx ); |
| } |
| if (!had) { |
| DefaultLogger::get()->warn("LWO2: Failure evaluating VMAD entry \'" + name + "\', vertex index wasn't found in that polygon"); |
| ai_assert(had); |
| } |
| } |
| } |
| |
| std::unique_ptr<float[]> temp(new float[type]); |
| for (unsigned int l = 0; l < type;++l) |
| temp[l] = GetF4(); |
| |
| DoRecursiveVMAPAssignment(base,type,idx, temp.get()); |
| mFileBuffer += diff; |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Load LWO2 clip |
| void LWOImporter::LoadLWO2Clip(unsigned int length) |
| { |
| AI_LWO_VALIDATE_CHUNK_LENGTH(length,CLIP,10); |
| |
| mClips.push_back(LWO::Clip()); |
| LWO::Clip& clip = mClips.back(); |
| |
| // first - get the index of the clip |
| clip.idx = GetU4(); |
| |
| IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer); |
| switch (head.type) |
| { |
| case AI_LWO_STIL: |
| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,STIL,1); |
| |
| // "Normal" texture |
| GetS0(clip.path,head.length); |
| clip.type = Clip::STILL; |
| break; |
| |
| case AI_LWO_ISEQ: |
| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,ISEQ,16); |
| // Image sequence. We'll later take the first. |
| { |
| uint8_t digits = GetU1(); mFileBuffer++; |
| int16_t offset = GetU2(); mFileBuffer+=4; |
| int16_t start = GetU2(); mFileBuffer+=4; |
| |
| std::string s; |
| std::ostringstream ss; |
| GetS0(s,head.length); |
| |
| head.length -= (uint16_t)s.length()+1; |
| ss << s; |
| ss << std::setw(digits) << offset + start; |
| GetS0(s,head.length); |
| ss << s; |
| clip.path = ss.str(); |
| clip.type = Clip::SEQ; |
| } |
| break; |
| |
| case AI_LWO_STCC: |
| DefaultLogger::get()->warn("LWO2: Color shifted images are not supported"); |
| break; |
| |
| case AI_LWO_ANIM: |
| DefaultLogger::get()->warn("LWO2: Animated textures are not supported"); |
| break; |
| |
| case AI_LWO_XREF: |
| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,XREF,4); |
| |
| // Just a cross-reference to another CLIp |
| clip.type = Clip::REF; |
| clip.clipRef = GetU4(); |
| break; |
| |
| case AI_LWO_NEGA: |
| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,NEGA,2); |
| clip.negate = (0 != GetU2()); |
| break; |
| |
| default: |
| DefaultLogger::get()->warn("LWO2: Encountered unknown CLIP subchunk"); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Load envelope description |
| void LWOImporter::LoadLWO2Envelope(unsigned int length) |
| { |
| LE_NCONST uint8_t* const end = mFileBuffer + length; |
| AI_LWO_VALIDATE_CHUNK_LENGTH(length,ENVL,4); |
| |
| mEnvelopes.push_back(LWO::Envelope()); |
| LWO::Envelope& envelope = mEnvelopes.back(); |
| |
| // Get the index of the envelope |
| envelope.index = ReadVSizedIntLWO2(mFileBuffer); |
| |
| // It looks like there might be an extra U4 right after the index, |
| // at least in modo (LXOB) files: we'll ignore it if it's zero, |
| // otherwise it represents the start of a subchunk, so we backtrack. |
| if (mIsLXOB) |
| { |
| uint32_t extra = GetU4(); |
| if (extra) |
| { |
| mFileBuffer -= 4; |
| } |
| } |
| |
| // ... and read all subchunks |
| while (true) |
| { |
| if (mFileBuffer + 6 >= end)break; |
| LE_NCONST IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer); |
| |
| if (mFileBuffer + head.length > end) |
| throw DeadlyImportError("LWO2: Invalid envelope chunk length"); |
| |
| uint8_t* const next = mFileBuffer+head.length; |
| switch (head.type) |
| { |
| // Type & representation of the envelope |
| case AI_LWO_TYPE: |
| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,TYPE,2); |
| mFileBuffer++; // skip user format |
| |
| // Determine type of envelope |
| envelope.type = (LWO::EnvelopeType)*mFileBuffer; |
| ++mFileBuffer; |
| break; |
| |
| // precondition |
| case AI_LWO_PRE: |
| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,PRE,2); |
| envelope.pre = (LWO::PrePostBehaviour)GetU2(); |
| break; |
| |
| // postcondition |
| case AI_LWO_POST: |
| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,POST,2); |
| envelope.post = (LWO::PrePostBehaviour)GetU2(); |
| break; |
| |
| // keyframe |
| case AI_LWO_KEY: |
| { |
| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,KEY,8); |
| |
| envelope.keys.push_back(LWO::Key()); |
| LWO::Key& key = envelope.keys.back(); |
| |
| key.time = GetF4(); |
| key.value = GetF4(); |
| break; |
| } |
| |
| // interval interpolation |
| case AI_LWO_SPAN: |
| { |
| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,SPAN,4); |
| if (envelope.keys.size()<2) |
| DefaultLogger::get()->warn("LWO2: Unexpected SPAN chunk"); |
| else { |
| LWO::Key& key = envelope.keys.back(); |
| switch (GetU4()) |
| { |
| case AI_LWO_STEP: |
| key.inter = LWO::IT_STEP;break; |
| case AI_LWO_LINE: |
| key.inter = LWO::IT_LINE;break; |
| case AI_LWO_TCB: |
| key.inter = LWO::IT_TCB;break; |
| case AI_LWO_HERM: |
| key.inter = LWO::IT_HERM;break; |
| case AI_LWO_BEZI: |
| key.inter = LWO::IT_BEZI;break; |
| case AI_LWO_BEZ2: |
| key.inter = LWO::IT_BEZ2;break; |
| default: |
| DefaultLogger::get()->warn("LWO2: Unknown interval interpolation mode"); |
| }; |
| |
| // todo ... read params |
| } |
| break; |
| } |
| |
| default: |
| DefaultLogger::get()->warn("LWO2: Encountered unknown ENVL subchunk"); |
| } |
| // regardless how much we did actually read, go to the next chunk |
| mFileBuffer = next; |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Load file - master function |
| void LWOImporter::LoadLWO2File() |
| { |
| bool skip = false; |
| |
| LE_NCONST uint8_t* const end = mFileBuffer + fileSize; |
| while (true) |
| { |
| if (mFileBuffer + sizeof(IFF::ChunkHeader) > end)break; |
| const IFF::ChunkHeader head = IFF::LoadChunk(mFileBuffer); |
| |
| if (mFileBuffer + head.length > end) |
| { |
| throw DeadlyImportError("LWO2: Chunk length points behind the file"); |
| break; |
| } |
| uint8_t* const next = mFileBuffer+head.length; |
| unsigned int iUnnamed = 0; |
| |
| if(!head.length) { |
| mFileBuffer = next; |
| continue; |
| } |
| |
| switch (head.type) |
| { |
| // new layer |
| case AI_LWO_LAYR: |
| { |
| // add a new layer to the list .... |
| mLayers->push_back ( LWO::Layer() ); |
| LWO::Layer& layer = mLayers->back(); |
| mCurLayer = &layer; |
| |
| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,LAYR,16); |
| |
| // layer index. |
| layer.mIndex = GetU2(); |
| |
| // Continue loading this layer or ignore it? Check the layer index property |
| if (UINT_MAX != configLayerIndex && (configLayerIndex-1) != layer.mIndex) { |
| skip = true; |
| } |
| else skip = false; |
| |
| // pivot point |
| mFileBuffer += 2; /* unknown */ |
| mCurLayer->mPivot.x = GetF4(); |
| mCurLayer->mPivot.y = GetF4(); |
| mCurLayer->mPivot.z = GetF4(); |
| GetS0(layer.mName,head.length-16); |
| |
| // if the name is empty, generate a default name |
| if (layer.mName.empty()) { |
| char buffer[128]; // should be sufficiently large |
| ::ai_snprintf(buffer, 128, "Layer_%i", iUnnamed++); |
| layer.mName = buffer; |
| } |
| |
| // load this layer or ignore it? Check the layer name property |
| if (configLayerName.length() && configLayerName != layer.mName) { |
| skip = true; |
| } |
| else hasNamedLayer = true; |
| |
| // optional: parent of this layer |
| if (mFileBuffer + 2 <= next) |
| layer.mParent = GetU2(); |
| else layer.mParent = -1; |
| |
| // Set layer skip parameter |
| layer.skip = skip; |
| |
| break; |
| } |
| |
| // vertex list |
| case AI_LWO_PNTS: |
| { |
| if (skip) |
| break; |
| |
| unsigned int old = (unsigned int)mCurLayer->mTempPoints.size(); |
| LoadLWOPoints(head.length); |
| mCurLayer->mPointIDXOfs = old; |
| break; |
| } |
| // vertex tags |
| case AI_LWO_VMAD: |
| if (mCurLayer->mFaces.empty()) |
| { |
| DefaultLogger::get()->warn("LWO2: Unexpected VMAD chunk"); |
| break; |
| } |
| // --- intentionally no break here |
| case AI_LWO_VMAP: |
| { |
| if (skip) |
| break; |
| |
| if (mCurLayer->mTempPoints.empty()) |
| DefaultLogger::get()->warn("LWO2: Unexpected VMAP chunk"); |
| else LoadLWO2VertexMap(head.length,head.type == AI_LWO_VMAD); |
| break; |
| } |
| // face list |
| case AI_LWO_POLS: |
| { |
| if (skip) |
| break; |
| |
| unsigned int old = (unsigned int)mCurLayer->mFaces.size(); |
| LoadLWO2Polygons(head.length); |
| mCurLayer->mFaceIDXOfs = old; |
| break; |
| } |
| // polygon tags |
| case AI_LWO_PTAG: |
| { |
| if (skip) |
| break; |
| |
| if (mCurLayer->mFaces.empty()) |
| DefaultLogger::get()->warn("LWO2: Unexpected PTAG"); |
| else LoadLWO2PolygonTags(head.length); |
| break; |
| } |
| // list of tags |
| case AI_LWO_TAGS: |
| { |
| if (!mTags->empty()) |
| DefaultLogger::get()->warn("LWO2: SRFS chunk encountered twice"); |
| else LoadLWOTags(head.length); |
| break; |
| } |
| |
| // surface chunk |
| case AI_LWO_SURF: |
| { |
| LoadLWO2Surface(head.length); |
| break; |
| } |
| |
| // clip chunk |
| case AI_LWO_CLIP: |
| { |
| LoadLWO2Clip(head.length); |
| break; |
| } |
| |
| // envelope chunk |
| case AI_LWO_ENVL: |
| { |
| LoadLWO2Envelope(head.length); |
| break; |
| } |
| } |
| mFileBuffer = next; |
| } |
| } |
| |
| #endif // !! ASSIMP_BUILD_NO_LWO_IMPORTER |
