/* --------------------------------------------------------------------------- Open Asset Import Library (ASSIMP) --------------------------------------------------------------------------- Copyright (c) 2006-2010, ASSIMP Development 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 Development 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 */ #include "AssimpPCH.h" #ifndef ASSIMP_BUILD_NO_LWO_IMPORTER // internal headers #include "LWOLoader.h" #include "MaterialSystem.h" #include "StringComparison.h" #include "SGSpatialSort.h" #include "ByteSwap.h" #include "ProcessHelper.h" #include "ConvertToLHProcess.h" using namespace Assimp; // ------------------------------------------------------------------------------------------------ // Constructor to be privately used by Importer LWOImporter::LWOImporter() {} // ------------------------------------------------------------------------------------------------ // 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,0xffffffff); configLayerName = pImp->GetPropertyString (AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY,""); } // ------------------------------------------------------------------------------------------------ // Imports the given file into the given scene structure. void LWOImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) { boost::scoped_ptr 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 = ""; // 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 (0xffffffff != configLayerIndex && configLayerIndex > mLayers->size()) 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 apcMeshes; std::vector apcNodes; apcNodes. reserve(mLayers->size()); apcMeshes.reserve(mLayers->size()*std::min(((unsigned int)mSurfaces->size()/2u), 1u)); unsigned int iDefaultSurface = 0xffffffff; // index of the default surface for (LayerList::iterator lit = mLayers->begin(), lend = mLayers->end();lit != lend;++lit) { LWO::Layer& layer = *lit; 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 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 = 0xffffffff; } if(0xffffffff == idx || 0xffffffff == (idx = _mMapping[idx])) { if (0xffffffff == 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 (0xffffffff == 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]; #if _DEBUG for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_TEXTURECOORDS;++mui ) vUVChannelIndices[mui] = 0xffffffff; for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_COLOR_SETS;++mui ) vVColorIndices[mui] = 0xffffffff; #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 (0xffffffff == 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 (0xffffffff == 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& smoothingGroups = layer.mPointReferrers; smoothingGroups.erase (smoothingGroups.begin(),smoothingGroups.end()); smoothingGroups.resize(mesh->mNumFaces,0); // now convert all faces unsigned int vert = 0; std::vector::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) { register 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 (0xffffffff == 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 (0xffffffff == 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 = apcMeshes.size() - meshStart; if (layer.mName != "" || num > 0) { aiNode* pcNode = new aiNode(); apcNodes.push_back(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) { MaterialHelper* pcMat = new MaterialHelper(); 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& smoothingGroups, const LWO::Surface& surface) { // Allocate output storage mesh->mNormals = new aiVector3D[mesh->mNumVertices]; // First generate per-face normals aiVector3D* out; std::vector 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; // 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::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) { register unsigned int tt = face.mIndices[i]; sSort.Add(mesh->mVertices[tt],tt,*it); } } // Sort everything - this takes O(nlogn) time sSort.Prepare(); std::vector 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 = 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) { register unsigned int idx = *beginIdx; sSort.FindPositions(mesh->mVertices[idx],*it,posEpsilon,poResult,true); std::vector::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 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) { register unsigned int idx = *beginIdx; if (vertexDone[idx]) continue; sSort.FindPositions(mesh->mVertices[idx],*it,posEpsilon,poResult,true); std::vector::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::AddChildren(aiNode* node, uint16_t parent, std::vector& apcNodes) { for (std::vector::iterator it = apcNodes.begin(); it != apcNodes.end(); ++it) { if (*it) { LWO::Layer* layer = (LWO::Layer*)(*it)->mParent; if (layer->mParent == parent && layer->mIndex != parent) ++node->mNumChildren; } } if (node->mNumChildren) { unsigned int p = 0; node->mChildren = new aiNode* [ node->mNumChildren ]; for (std::vector::iterator it = apcNodes.begin(); it != apcNodes.end(); ++it) { if (*it) { LWO::Layer* layer = (LWO::Layer*)(*it)->mParent; if (layer->mParent == parent && layer->mIndex != parent) { aiNode* nd = node->mChildren[p++] = *it; nd->mParent = node; // fixme: ignore pivot points for the moment //nd->mTransformation.a4 = layer->mPivot.x; //nd->mTransformation.b4 = layer->mPivot.y; //nd->mTransformation.c4 = layer->mPivot.z; // recursively add more children (*it) = NULL; AddChildren(nd,layer->mIndex,apcNodes); } } } } } // ------------------------------------------------------------------------------------------------ void LWOImporter::GenerateNodeGraph(std::vector& apcNodes) { // now generate the final nodegraph - generate a root node and attach children aiNode* root = pScene->mRootNode = new aiNode(); root->mName.Set(""); AddChildren(root,0,apcNodes); // check whether we added all layers with meshes assigned to the output graph. // if not, add them to the root node unsigned int extra = 0; for (std::vector::iterator it = apcNodes.begin(); it != apcNodes.end(); ++it) { if ((*it) && (*it)->mNumMeshes) ++extra; } if (extra) { const unsigned int newSize = extra + pScene->mRootNode->mNumChildren; aiNode** const apcNewNodes = new aiNode*[newSize]; if((extra = root->mNumChildren)) ::memcpy(apcNewNodes,root->mChildren,extra*sizeof(void*)); aiNode** cc = apcNewNodes+extra; for (std::vector::iterator it = apcNodes.begin(); it != apcNodes.end(); ++it) { if ((*it) && (*it)->mNumMeshes) { aiNode* nd = *cc++ = *it; nd->mParent = pScene->mRootNode; // recursively add more children (*it) = NULL; AddChildren(nd,((LWO::Layer*)nd->mParent)->mIndex,apcNodes); } } delete[] root->mChildren; root->mChildren = apcNewNodes; root->mNumChildren = newSize; } 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(),0xffffffff); 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. register 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, 0xffffffff ); } else mCurLayer->mTempPoints.resize( regularSize ); // perform endianess 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 wont 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--) { AI_LSWAP2P(cursor); uint16_t numIndices = *cursor++; 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++;; if((face.mNumIndices = (*cursor++) & 0x03FF)) /* 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 VMapEntry* FindEntry(std::vector< T >& list,const std::string& name, bool perPoly) { for (typename std::vector< T >::iterator it = list.begin(), end = list.end();it != end; ++it) { if ((*it).name == name) { if (!perPoly) { DefaultLogger::get()->warn("LWO2: Found two VMAP sections with equal names"); } return &(*it); } } list.push_back( T() ); VMapEntry* p = &list.back(); p->name = name; return p; } // ------------------------------------------------------------------------------------------------ template 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 inline void CreateNewEntry(std::vector< T >& list, unsigned int srcIdx) { for (typename std::vector< T >::iterator it = list.begin(), end = list.end();it != end;++it) { CreateNewEntry( *it, 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; base->abAssigned[idx] = true; for (i = 0; i < numRead;++i) { base->rawData[idx*base->dims+i]= data[i]; } if (0xffffffff != (i = refList[idx])) { DoRecursiveVMAPAssignment(base,numRead,i,data); } } // ------------------------------------------------------------------------------------------------ inline void AddToSingleLinkedList(ReferrerList& refList, unsigned int srcIdx, unsigned int destIdx) { if(0xffffffff == 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; float temp[4]; 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]) != 0xffffffff); if (tmp == 0xffffffff) continue; had = true; refList.resize(refList.size()+1, 0xffffffff); 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); } } } for (unsigned int l = 0; l < type;++l) temp[l] = GetF4(); DoRecursiveVMAPAssignment(base,type,idx, temp); 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* const 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 -= (unsigned int)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* const 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; IFF::ChunkHeader* const 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; 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); // Continue loading this layer or ignore it? Check the layer index property // NOTE: The first layer is the default layer, so the layer index is one-based now if (0xffffffff != configLayerIndex && configLayerIndex != mLayers->size()-1) { skip = true; } else skip = false; // layer index. that's just for internal parenting, from the scope of a LWS file // all layers are numbered in the oder in which they appear in the file layer.mIndex = GetU2(); // 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 ::sprintf(buffer,"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(); 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