Add files ported from research/qt3d

Fill repo with some of the files from the research/qt3d project.  At
present the new project builds under MacOSX.  To-dos include getting it
building under linux, windows, harmattan and maemo/meego; updating the
documentation to reflect the new QtQuick focus; and fixing the issues
with private headers.

1 files changed, 1403 insertions, 0 deletions

diff --git a/3rdparty/assimp/code/LWOLoader.cpp b/3rdparty/assimp/code/LWOLoader.cpp
new file mode 100644
index 000000000..b19ffe698
--- /dev/null
+++ b/3rdparty/assimp/code/LWOLoader.cpp
@@ -0,0 +1,1403 @@
+/*
+---------------------------------------------------------------------------
+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<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>";
+
+    // 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<aiMesh*> apcMeshes;
+    std::vector<aiNode*> 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<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 = 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<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) {
+                        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 != "<LWODefault>" || 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<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;
+
+        // 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)
+        {
+            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<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 = 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<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)
+            {
+                register 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::AddChildren(aiNode* node, uint16_t parent, std::vector<aiNode*>& apcNodes)
+{
+    for (std::vector<aiNode*>::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<aiNode*>::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<aiNode*>& apcNodes)
+{
+    // now generate the final nodegraph - generate a root node and attach children
+    aiNode* root = pScene->mRootNode = new aiNode();
+    root->mName.Set("<LWORoot>");
+    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<aiNode*>::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<aiNode*>::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 <class T>
+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 <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 (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::stringstream 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