assimp/code/3DSLoader.cpp

/*
---------------------------------------------------------------------------
Open Asset Import Library (assimp)
---------------------------------------------------------------------------

Copyright (c) 2006-2016, assimp team

All rights reserved.

Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the following
conditions are met:

* Redistributions of source code must retain the above
  copyright notice, this list of conditions and the
  following disclaimer.

* Redistributions in binary form must reproduce the above
  copyright notice, this list of conditions and the
  following disclaimer in the documentation and/or other
  materials provided with the distribution.

* Neither the name of the assimp team, nor the names of its
  contributors may be used to endorse or promote products
  derived from this software without specific prior
  written permission of the assimp team.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/

/** @file  3DSLoader.cpp
 *  @brief Implementation of the 3ds importer class
 *
 *  http://www.the-labs.com/Blender/3DS-details.html
 */


#ifndef ASSIMP_BUILD_NO_3DS_IMPORTER

// internal headers
#include "3DSLoader.h"
#include "Macros.h"
#include <assimp/IOSystem.hpp>
#include <assimp/scene.h>
#include <assimp/DefaultLogger.hpp>
#include <assimp/importerdesc.h>
#include "StringComparison.h"

using namespace Assimp;

static const aiImporterDesc desc = {
    "Discreet 3DS Importer",
    "",
    "",
    "Limited animation support",
    aiImporterFlags_SupportBinaryFlavour,
    0,
    0,
    0,
    0,
    "3ds prj"
};


// ------------------------------------------------------------------------------------------------
// Begins a new parsing block
// - Reads the current chunk and validates it
// - computes its length
#define ASSIMP_3DS_BEGIN_CHUNK()                                         \
    while (true) {                                                       \
    if (stream->GetRemainingSizeToLimit() < sizeof(Discreet3DS::Chunk)){ \
        return;                                                          \
    }                                                                    \
    Discreet3DS::Chunk chunk;                                            \
    ReadChunk(&chunk);                                                   \
    int chunkSize = chunk.Size-sizeof(Discreet3DS::Chunk);               \
    if(chunkSize <= 0)                                                   \
        continue;                                                        \
    const unsigned int oldReadLimit = stream->SetReadLimit(              \
        stream->GetCurrentPos() + chunkSize);                            \


// ------------------------------------------------------------------------------------------------
// End a parsing block
// Must follow at the end of each parsing block, reset chunk end marker to previous value
#define ASSIMP_3DS_END_CHUNK()                  \
    stream->SkipToReadLimit();                  \
    stream->SetReadLimit(oldReadLimit);         \
    if (stream->GetRemainingSizeToLimit() == 0) \
        return;                                 \
    }

// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
Discreet3DSImporter::Discreet3DSImporter()
    : stream(),
    mLastNodeIndex(),
    mCurrentNode(),
    mRootNode(),
    mScene(),
    mMasterScale(),
    bHasBG(),
    bIsPrj()
{}

// ------------------------------------------------------------------------------------------------
// Destructor, private as well
Discreet3DSImporter::~Discreet3DSImporter()
{}

// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool Discreet3DSImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
{
    std::string extension = GetExtension(pFile);
    if(extension == "3ds" || extension == "prj" ) {
        return true;
    }
    if (!extension.length() || checkSig) {
        uint16_t token[3];
        token[0] = 0x4d4d;
        token[1] = 0x3dc2;
        //token[2] = 0x3daa;
        return CheckMagicToken(pIOHandler,pFile,token,2,0,2);
    }
    return false;
}

// ------------------------------------------------------------------------------------------------
// Loader registry entry
const aiImporterDesc* Discreet3DSImporter::GetInfo () const
{
    return &desc;
}

// ------------------------------------------------------------------------------------------------
// Setup configuration properties
void Discreet3DSImporter::SetupProperties(const Importer* /*pImp*/)
{
    // nothing to be done for the moment
}

// ------------------------------------------------------------------------------------------------
// Imports the given file into the given scene structure.
void Discreet3DSImporter::InternReadFile( const std::string& pFile,
    aiScene* pScene, IOSystem* pIOHandler)
{
    StreamReaderLE stream(pIOHandler->Open(pFile,"rb"));
    this->stream = &stream;

    // We should have at least one chunk
    if (stream.GetRemainingSize() < 16) {
        throw DeadlyImportError("3DS file is either empty or corrupt: " + pFile);
    }

    // Allocate our temporary 3DS representation
    mScene = new D3DS::Scene();

    // Initialize members
    mLastNodeIndex             = -1;
    mCurrentNode               = new D3DS::Node();
    mRootNode                  = mCurrentNode;
    mRootNode->mHierarchyPos   = -1;
    mRootNode->mHierarchyIndex = -1;
    mRootNode->mParent         = NULL;
    mMasterScale               = 1.0f;
    mBackgroundImage           = "";
    bHasBG                     = false;
    bIsPrj                     = false;

    // Parse the file
    ParseMainChunk();

    // Process all meshes in the file. First check whether all
    // face indices have valid values. The generate our
    // internal verbose representation. Finally compute normal
    // vectors from the smoothing groups we read from the
    // file.
    for (auto &mesh : mScene->mMeshes) {
        if (mesh.mFaces.size() > 0 && mesh.mPositions.size() == 0)  {
            delete mScene;
            throw DeadlyImportError("3DS file contains faces but no vertices: " + pFile);
        }
        CheckIndices(mesh);
        MakeUnique  (mesh);
        ComputeNormalsWithSmoothingsGroups<D3DS::Face>(mesh);
    }

    // Replace all occurrences of the default material with a
    // valid material. Generate it if no material containing
    // DEFAULT in its name has been found in the file
    ReplaceDefaultMaterial();

    // Convert the scene from our internal representation to an
    // aiScene object. This involves copying all meshes, lights
    // and cameras to the scene
    ConvertScene(pScene);

    // Generate the node graph for the scene. This is a little bit
    // tricky since we'll need to split some meshes into submeshes
    GenerateNodeGraph(pScene);

    // Now apply the master scaling factor to the scene
    ApplyMasterScale(pScene);

    // Delete our internal scene representation and the root
    // node, so the whole hierarchy will follow
    delete mRootNode;
    delete mScene;

    AI_DEBUG_INVALIDATE_PTR(mRootNode);
    AI_DEBUG_INVALIDATE_PTR(mScene);
    AI_DEBUG_INVALIDATE_PTR(this->stream);
}

// ------------------------------------------------------------------------------------------------
// Applies a master-scaling factor to the imported scene
void Discreet3DSImporter::ApplyMasterScale(aiScene* pScene)
{
    // There are some 3DS files with a zero scaling factor
    if (!mMasterScale)mMasterScale = 1.0f;
    else mMasterScale = 1.0f / mMasterScale;

    // Construct an uniform scaling matrix and multiply with it
    pScene->mRootNode->mTransformation *= aiMatrix4x4(
        mMasterScale,0.0f, 0.0f, 0.0f,
        0.0f, mMasterScale,0.0f, 0.0f,
        0.0f, 0.0f, mMasterScale,0.0f,
        0.0f, 0.0f, 0.0f, 1.0f);

    // Check whether a scaling track is assigned to the root node.
}

// ------------------------------------------------------------------------------------------------
// Reads a new chunk from the file
void Discreet3DSImporter::ReadChunk(Discreet3DS::Chunk* pcOut)
{
    ai_assert(pcOut != NULL);

    pcOut->Flag = stream->GetI2();
    pcOut->Size = stream->GetI4();

    if (pcOut->Size - sizeof(Discreet3DS::Chunk) > stream->GetRemainingSize())
        throw DeadlyImportError("Chunk is too large");

    if (pcOut->Size - sizeof(Discreet3DS::Chunk) > stream->GetRemainingSizeToLimit())
        DefaultLogger::get()->error("3DS: Chunk overflow");
}

// ------------------------------------------------------------------------------------------------
// Skip a chunk
void Discreet3DSImporter::SkipChunk()
{
    Discreet3DS::Chunk psChunk;
    ReadChunk(&psChunk);

    stream->IncPtr(psChunk.Size-sizeof(Discreet3DS::Chunk));
    return;
}

// ------------------------------------------------------------------------------------------------
// Process the primary chunk of the file
void Discreet3DSImporter::ParseMainChunk()
{
    ASSIMP_3DS_BEGIN_CHUNK();

    // get chunk type
    switch (chunk.Flag)
    {

    case Discreet3DS::CHUNK_PRJ:
        bIsPrj = true;
    case Discreet3DS::CHUNK_MAIN:
        ParseEditorChunk();
        break;
    };

    ASSIMP_3DS_END_CHUNK();
    // recursively continue processing this hierarchy level
    return ParseMainChunk();
}

// ------------------------------------------------------------------------------------------------
void Discreet3DSImporter::ParseEditorChunk()
{
    ASSIMP_3DS_BEGIN_CHUNK();

    // get chunk type
    switch (chunk.Flag)
    {
    case Discreet3DS::CHUNK_OBJMESH:

        ParseObjectChunk();
        break;

    // NOTE: In several documentations in the internet this
    // chunk appears at different locations
    case Discreet3DS::CHUNK_KEYFRAMER:

        ParseKeyframeChunk();
        break;

    case Discreet3DS::CHUNK_VERSION:
        {
        // print the version number
        char buff[10];
        ASSIMP_itoa10(buff,stream->GetI2());
        DefaultLogger::get()->info(std::string("3DS file format version: ") + buff);
        }
        break;
    };
    ASSIMP_3DS_END_CHUNK();
}

// ------------------------------------------------------------------------------------------------
void Discreet3DSImporter::ParseObjectChunk()
{
    ASSIMP_3DS_BEGIN_CHUNK();

    // get chunk type
    switch (chunk.Flag)
    {
    case Discreet3DS::CHUNK_OBJBLOCK:
        {
        unsigned int cnt = 0;
        const char* sz = (const char*)stream->GetPtr();

        // Get the name of the geometry object
        while (stream->GetI1())++cnt;
        ParseChunk(sz,cnt);
        }
        break;

    case Discreet3DS::CHUNK_MAT_MATERIAL:

        // Add a new material to the list
        mScene->mMaterials.push_back(D3DS::Material());
        ParseMaterialChunk();
        break;

    case Discreet3DS::CHUNK_AMBCOLOR:

        // This is the ambient base color of the scene.
        // We add it to the ambient color of all materials
        ParseColorChunk(&mClrAmbient,true);
        if (is_qnan(mClrAmbient.r))
        {
            // We failed to read the ambient base color.
            DefaultLogger::get()->error("3DS: Failed to read ambient base color");
            mClrAmbient.r = mClrAmbient.g = mClrAmbient.b = 0.0f;
        }
        break;

    case Discreet3DS::CHUNK_BIT_MAP:
        {
        // Specifies the background image. The string should already be
        // properly 0 terminated but we need to be sure
        unsigned int cnt = 0;
        const char* sz = (const char*)stream->GetPtr();
        while (stream->GetI1())++cnt;
        mBackgroundImage = std::string(sz,cnt);
        }
        break;

    case Discreet3DS::CHUNK_BIT_MAP_EXISTS:
        bHasBG = true;
        break;

    case Discreet3DS::CHUNK_MASTER_SCALE:
        // Scene master scaling factor
        mMasterScale = stream->GetF4();
        break;
    };
    ASSIMP_3DS_END_CHUNK();
}

// ------------------------------------------------------------------------------------------------
void Discreet3DSImporter::ParseChunk(const char* name, unsigned int num)
{
    ASSIMP_3DS_BEGIN_CHUNK();

    // IMPLEMENTATION NOTE;
    // Cameras or lights define their transformation in their parent node and in the
    // corresponding light or camera chunks. However, we read and process the latter
    // to to be able to return valid cameras/lights even if no scenegraph is given.

    // get chunk type
    switch (chunk.Flag)
    {
    case Discreet3DS::CHUNK_TRIMESH:
        {
        // this starts a new triangle mesh
        mScene->mMeshes.push_back(D3DS::Mesh());
        D3DS::Mesh& m = mScene->mMeshes.back();

        // Setup the name of the mesh
        m.mName = std::string(name, num);

        // Read mesh chunks
        ParseMeshChunk();
        }
        break;

    case Discreet3DS::CHUNK_LIGHT:
        {
        // This starts a new light
        aiLight* light = new aiLight();
        mScene->mLights.push_back(light);

        light->mName.Set(std::string(name, num));

        // First read the position of the light
        light->mPosition.x = stream->GetF4();
        light->mPosition.y = stream->GetF4();
        light->mPosition.z = stream->GetF4();

        light->mColorDiffuse = aiColor3D(1.f,1.f,1.f);

        // Now check for further subchunks
        if (!bIsPrj) /* fixme */
            ParseLightChunk();

        // The specular light color is identical the the diffuse light color. The ambient light color
        // is equal to the ambient base color of the whole scene.
        light->mColorSpecular = light->mColorDiffuse;
        light->mColorAmbient  = mClrAmbient;

        if (light->mType == aiLightSource_UNDEFINED)
        {
            // It must be a point light
            light->mType = aiLightSource_POINT;
        }}
        break;

    case Discreet3DS::CHUNK_CAMERA:
        {
        // This starts a new camera
        aiCamera* camera = new aiCamera();
        mScene->mCameras.push_back(camera);
        camera->mName.Set(std::string(name, num));

        // First read the position of the camera
        camera->mPosition.x = stream->GetF4();
        camera->mPosition.y = stream->GetF4();
        camera->mPosition.z = stream->GetF4();

        // Then the camera target
        camera->mLookAt.x = stream->GetF4() - camera->mPosition.x;
        camera->mLookAt.y = stream->GetF4() - camera->mPosition.y;
        camera->mLookAt.z = stream->GetF4() - camera->mPosition.z;
        ai_real len = camera->mLookAt.Length();
        if (len < 1e-5) {

            // There are some files with lookat == position. Don't know why or whether it's ok or not.
            DefaultLogger::get()->error("3DS: Unable to read proper camera look-at vector");
            camera->mLookAt = aiVector3D(0.0,1.0,0.0);

        }
        else camera->mLookAt /= len;

        // And finally - the camera rotation angle, in counter clockwise direction
        const ai_real angle =  AI_DEG_TO_RAD( stream->GetF4() );
        aiQuaternion quat(camera->mLookAt,angle);
        camera->mUp = quat.GetMatrix() * aiVector3D(0.0,1.0,0.0);

        // Read the lense angle
        camera->mHorizontalFOV = AI_DEG_TO_RAD ( stream->GetF4() );
        if (camera->mHorizontalFOV < 0.001f)  {
            camera->mHorizontalFOV = AI_DEG_TO_RAD(45.f);
        }

        // Now check for further subchunks
        if (!bIsPrj) /* fixme */ {
            ParseCameraChunk();
        }}
        break;
    };
    ASSIMP_3DS_END_CHUNK();
}

// ------------------------------------------------------------------------------------------------
void Discreet3DSImporter::ParseLightChunk()
{
    ASSIMP_3DS_BEGIN_CHUNK();
    aiLight* light = mScene->mLights.back();

    // get chunk type
    switch (chunk.Flag)
    {
    case Discreet3DS::CHUNK_DL_SPOTLIGHT:
        // Now we can be sure that the light is a spot light
        light->mType = aiLightSource_SPOT;

        // We wouldn't need to normalize here, but we do it
        light->mDirection.x = stream->GetF4() - light->mPosition.x;
        light->mDirection.y = stream->GetF4() - light->mPosition.y;
        light->mDirection.z = stream->GetF4() - light->mPosition.z;
        light->mDirection.Normalize();

        // Now the hotspot and falloff angles - in degrees
        light->mAngleInnerCone = AI_DEG_TO_RAD( stream->GetF4() );

        // FIX: the falloff angle is just an offset
        light->mAngleOuterCone = light->mAngleInnerCone+AI_DEG_TO_RAD( stream->GetF4() );
        break;

        // intensity multiplier
    case Discreet3DS::CHUNK_DL_MULTIPLIER:
        light->mColorDiffuse = light->mColorDiffuse * stream->GetF4();
        break;

        // light color
    case Discreet3DS::CHUNK_RGBF:
    case Discreet3DS::CHUNK_LINRGBF:
        light->mColorDiffuse.r *= stream->GetF4();
        light->mColorDiffuse.g *= stream->GetF4();
        light->mColorDiffuse.b *= stream->GetF4();
        break;

        // light attenuation
    case Discreet3DS::CHUNK_DL_ATTENUATE:
        light->mAttenuationLinear = stream->GetF4();
        break;
    };

    ASSIMP_3DS_END_CHUNK();
}

// ------------------------------------------------------------------------------------------------
void Discreet3DSImporter::ParseCameraChunk()
{
    ASSIMP_3DS_BEGIN_CHUNK();
    aiCamera* camera = mScene->mCameras.back();

    // get chunk type
    switch (chunk.Flag)
    {
        // near and far clip plane
    case Discreet3DS::CHUNK_CAM_RANGES:
        camera->mClipPlaneNear = stream->GetF4();
        camera->mClipPlaneFar  = stream->GetF4();
        break;
    }

    ASSIMP_3DS_END_CHUNK();
}

// ------------------------------------------------------------------------------------------------
void Discreet3DSImporter::ParseKeyframeChunk()
{
    ASSIMP_3DS_BEGIN_CHUNK();

    // get chunk type
    switch (chunk.Flag)
    {
    case Discreet3DS::CHUNK_TRACKCAMTGT:
    case Discreet3DS::CHUNK_TRACKSPOTL:
    case Discreet3DS::CHUNK_TRACKCAMERA:
    case Discreet3DS::CHUNK_TRACKINFO:
    case Discreet3DS::CHUNK_TRACKLIGHT:
    case Discreet3DS::CHUNK_TRACKLIGTGT:

        // this starts a new mesh hierarchy chunk
        ParseHierarchyChunk(chunk.Flag);
        break;
    };

    ASSIMP_3DS_END_CHUNK();
}

// ------------------------------------------------------------------------------------------------
// Little helper function for ParseHierarchyChunk
void Discreet3DSImporter::InverseNodeSearch(D3DS::Node* pcNode,D3DS::Node* pcCurrent)
{
    if (!pcCurrent) {
        mRootNode->push_back(pcNode);
        return;
    }

    if (pcCurrent->mHierarchyPos == pcNode->mHierarchyPos)  {
        if(pcCurrent->mParent) {
            pcCurrent->mParent->push_back(pcNode);
        }
        else pcCurrent->push_back(pcNode);
        return;
    }
    return InverseNodeSearch(pcNode,pcCurrent->mParent);
}

// ------------------------------------------------------------------------------------------------
// Find a node with a specific name in the import hierarchy
D3DS::Node* FindNode(D3DS::Node* root, const std::string& name)
{
    if (root->mName == name)
        return root;
    for (std::vector<D3DS::Node*>::iterator it = root->mChildren.begin();it != root->mChildren.end(); ++it) {
        D3DS::Node* nd;
        if (( nd = FindNode(*it,name)))
            return nd;
    }
    return NULL;
}

// ------------------------------------------------------------------------------------------------
// Binary predicate for std::unique()
template <class T>
bool KeyUniqueCompare(const T& first, const T& second)
{
    return first.mTime == second.mTime;
}

// ------------------------------------------------------------------------------------------------
// Skip some additional import data.
void Discreet3DSImporter::SkipTCBInfo()
{
    unsigned int flags = stream->GetI2();

    if (!flags) {
        // Currently we can't do anything with these values. They occur
        // quite rare, so it wouldn't be worth the effort implementing
        // them. 3DS ist not really suitable for complex animations,
        // so full support is not required.
        DefaultLogger::get()->warn("3DS: Skipping TCB animation info");
    }

    if (flags & Discreet3DS::KEY_USE_TENS) {
        stream->IncPtr(4);
    }
    if (flags & Discreet3DS::KEY_USE_BIAS) {
        stream->IncPtr(4);
    }
    if (flags & Discreet3DS::KEY_USE_CONT) {
        stream->IncPtr(4);
    }
    if (flags & Discreet3DS::KEY_USE_EASE_FROM) {
        stream->IncPtr(4);
    }
    if (flags & Discreet3DS::KEY_USE_EASE_TO) {
        stream->IncPtr(4);
    }
}

// ------------------------------------------------------------------------------------------------
// Read hierarchy and keyframe info
void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
{
    ASSIMP_3DS_BEGIN_CHUNK();

    // get chunk type
    switch (chunk.Flag)
    {
    case Discreet3DS::CHUNK_TRACKOBJNAME:

        // This is the name of the object to which the track applies. The chunk also
        // defines the position of this object in the hierarchy.
        {

        // First of all: get the name of the object
        unsigned int cnt = 0;
        const char* sz = (const char*)stream->GetPtr();

        while (stream->GetI1())++cnt;
        std::string name = std::string(sz,cnt);

        // Now find out whether we have this node already (target animation channels
        // are stored with a separate object ID)
        D3DS::Node* pcNode = FindNode(mRootNode,name);
        int instanceNumber = 1;

        if ( pcNode)
        {
            // if the source is not a CHUNK_TRACKINFO block it won't be an object instance
            if (parent != Discreet3DS::CHUNK_TRACKINFO)
            {
                mCurrentNode = pcNode;
                break;
            }
            pcNode->mInstanceCount++;
            instanceNumber = pcNode->mInstanceCount;
        }
        pcNode = new D3DS::Node();
        pcNode->mName = name;
        pcNode->mInstanceNumber = instanceNumber;

        // There are two unknown values which we can safely ignore
        stream->IncPtr(4);

        // Now read the hierarchy position of the object
        uint16_t hierarchy = stream->GetI2() + 1;
        pcNode->mHierarchyPos   = hierarchy;
        pcNode->mHierarchyIndex = mLastNodeIndex;

        // And find a proper position in the graph for it
        if (mCurrentNode && mCurrentNode->mHierarchyPos == hierarchy)   {

            // add to the parent of the last touched node
            mCurrentNode->mParent->push_back(pcNode);
            mLastNodeIndex++;
        }
        else if(hierarchy >= mLastNodeIndex)    {

            // place it at the current position in the hierarchy
            mCurrentNode->push_back(pcNode);
            mLastNodeIndex = hierarchy;
        }
        else    {
            // need to go back to the specified position in the hierarchy.
            InverseNodeSearch(pcNode,mCurrentNode);
            mLastNodeIndex++;
        }
        // Make this node the current node
        mCurrentNode = pcNode;
        }
        break;

    case Discreet3DS::CHUNK_TRACKDUMMYOBJNAME:

        // This is the "real" name of a $$$DUMMY object
        {
            const char* sz = (const char*) stream->GetPtr();
            while (stream->GetI1());

            // If object name is DUMMY, take this one instead
            if (mCurrentNode->mName == "$$$DUMMY")  {
                //DefaultLogger::get()->warn("3DS: Skipping dummy object name for non-dummy object");
                mCurrentNode->mName = std::string(sz);
                break;
            }
        }
        break;

    case Discreet3DS::CHUNK_TRACKPIVOT:

        if ( Discreet3DS::CHUNK_TRACKINFO != parent)
        {
            DefaultLogger::get()->warn("3DS: Skipping pivot subchunk for non usual object");
            break;
        }

        // Pivot = origin of rotation and scaling
        mCurrentNode->vPivot.x = stream->GetF4();
        mCurrentNode->vPivot.y = stream->GetF4();
        mCurrentNode->vPivot.z = stream->GetF4();
        break;


        // ////////////////////////////////////////////////////////////////////
        // POSITION KEYFRAME
    case Discreet3DS::CHUNK_TRACKPOS:
        {
        stream->IncPtr(10);
        const unsigned int numFrames = stream->GetI4();
        bool sortKeys = false;

        // This could also be meant as the target position for
        // (targeted) lights and cameras
        std::vector<aiVectorKey>* l;
        if ( Discreet3DS::CHUNK_TRACKCAMTGT == parent || Discreet3DS::CHUNK_TRACKLIGTGT == parent)  {
            l = & mCurrentNode->aTargetPositionKeys;
        }
        else l = & mCurrentNode->aPositionKeys;

        l->reserve(numFrames);
        for (unsigned int i = 0; i < numFrames;++i) {
            const unsigned int fidx = stream->GetI4();

            // Setup a new position key
            aiVectorKey v;
            v.mTime = (double)fidx;

            SkipTCBInfo();
            v.mValue.x = stream->GetF4();
            v.mValue.y = stream->GetF4();
            v.mValue.z = stream->GetF4();

            // check whether we'll need to sort the keys
            if (!l->empty() && v.mTime <= l->back().mTime)
                sortKeys = true;

            // Add the new keyframe to the list
            l->push_back(v);
        }

        // Sort all keys with ascending time values and remove duplicates?
        if (sortKeys)   {
            std::stable_sort(l->begin(),l->end());
            l->erase ( std::unique (l->begin(),l->end(),&KeyUniqueCompare<aiVectorKey>), l->end() );
        }}

        break;

        // ////////////////////////////////////////////////////////////////////
        // CAMERA ROLL KEYFRAME
    case Discreet3DS::CHUNK_TRACKROLL:
        {
        // roll keys are accepted for cameras only
        if (parent != Discreet3DS::CHUNK_TRACKCAMERA)   {
            DefaultLogger::get()->warn("3DS: Ignoring roll track for non-camera object");
            break;
        }
        bool sortKeys = false;
        std::vector<aiFloatKey>* l = &mCurrentNode->aCameraRollKeys;

        stream->IncPtr(10);
        const unsigned int numFrames = stream->GetI4();
        l->reserve(numFrames);
        for (unsigned int i = 0; i < numFrames;++i) {
            const unsigned int fidx = stream->GetI4();

            // Setup a new position key
            aiFloatKey v;
            v.mTime = (double)fidx;

            // This is just a single float
            SkipTCBInfo();
            v.mValue = stream->GetF4();

            // Check whether we'll need to sort the keys
            if (!l->empty() && v.mTime <= l->back().mTime)
                sortKeys = true;

            // Add the new keyframe to the list
            l->push_back(v);
        }

        // Sort all keys with ascending time values and remove duplicates?
        if (sortKeys)   {
            std::stable_sort(l->begin(),l->end());
            l->erase ( std::unique (l->begin(),l->end(),&KeyUniqueCompare<aiFloatKey>), l->end() );
        }}
        break;


        // ////////////////////////////////////////////////////////////////////
        // CAMERA FOV KEYFRAME
    case Discreet3DS::CHUNK_TRACKFOV:
        {
            DefaultLogger::get()->error("3DS: Skipping FOV animation track. "
                "This is not supported");
        }
        break;


        // ////////////////////////////////////////////////////////////////////
        // ROTATION KEYFRAME
    case Discreet3DS::CHUNK_TRACKROTATE:
        {
        stream->IncPtr(10);
        const unsigned int numFrames = stream->GetI4();

        bool sortKeys = false;
        std::vector<aiQuatKey>* l = &mCurrentNode->aRotationKeys;
        l->reserve(numFrames);

        for (unsigned int i = 0; i < numFrames;++i) {
            const unsigned int fidx = stream->GetI4();
            SkipTCBInfo();

            aiQuatKey v;
            v.mTime = (double)fidx;

            // The rotation keyframe is given as an axis-angle pair
            const float rad = stream->GetF4();
            aiVector3D axis;
            axis.x = stream->GetF4();
            axis.y = stream->GetF4();
            axis.z = stream->GetF4();

            if (!axis.x && !axis.y && !axis.z)
                axis.y = 1.f;

            // Construct a rotation quaternion from the axis-angle pair
            v.mValue = aiQuaternion(axis,rad);

            // Check whether we'll need to sort the keys
            if (!l->empty() && v.mTime <= l->back().mTime)
                sortKeys = true;

            // add the new keyframe to the list
            l->push_back(v);
        }
        // Sort all keys with ascending time values and remove duplicates?
        if (sortKeys)   {
            std::stable_sort(l->begin(),l->end());
            l->erase ( std::unique (l->begin(),l->end(),&KeyUniqueCompare<aiQuatKey>), l->end() );
        }}
        break;

        // ////////////////////////////////////////////////////////////////////
        // SCALING KEYFRAME
    case Discreet3DS::CHUNK_TRACKSCALE:
        {
        stream->IncPtr(10);
        const unsigned int numFrames = stream->GetI2();
        stream->IncPtr(2);

        bool sortKeys = false;
        std::vector<aiVectorKey>* l = &mCurrentNode->aScalingKeys;
        l->reserve(numFrames);

        for (unsigned int i = 0; i < numFrames;++i) {
            const unsigned int fidx = stream->GetI4();
            SkipTCBInfo();

            // Setup a new key
            aiVectorKey v;
            v.mTime = (double)fidx;

            // ... and read its value
            v.mValue.x = stream->GetF4();
            v.mValue.y = stream->GetF4();
            v.mValue.z = stream->GetF4();

            // check whether we'll need to sort the keys
            if (!l->empty() && v.mTime <= l->back().mTime)
                sortKeys = true;

            // Remove zero-scalings on singular axes - they've been reported to be there erroneously in some strange files
            if (!v.mValue.x) v.mValue.x = 1.f;
            if (!v.mValue.y) v.mValue.y = 1.f;
            if (!v.mValue.z) v.mValue.z = 1.f;

            l->push_back(v);
        }
        // Sort all keys with ascending time values and remove duplicates?
        if (sortKeys)   {
            std::stable_sort(l->begin(),l->end());
            l->erase ( std::unique (l->begin(),l->end(),&KeyUniqueCompare<aiVectorKey>), l->end() );
        }}
        break;
    };

    ASSIMP_3DS_END_CHUNK();
}

// ------------------------------------------------------------------------------------------------
// Read a face chunk - it contains smoothing groups and material assignments
void Discreet3DSImporter::ParseFaceChunk()
{
    ASSIMP_3DS_BEGIN_CHUNK();

    // Get the mesh we're currently working on
    D3DS::Mesh& mMesh = mScene->mMeshes.back();

    // Get chunk type
    switch (chunk.Flag)
    {
    case Discreet3DS::CHUNK_SMOOLIST:
        {
        // This is the list of smoothing groups - a bitfield for every face.
        // Up to 32 smoothing groups assigned to a single face.
        unsigned int num = chunkSize/4, m = 0;
        if (num > mMesh.mFaces.size())  {
            throw DeadlyImportError("3DS: More smoothing groups than faces");
        }
        for (std::vector<D3DS::Face>::iterator i =  mMesh.mFaces.begin(); m != num;++i, ++m)    {
            // nth bit is set for nth smoothing group
            (*i).iSmoothGroup = stream->GetI4();
        }}
        break;

    case Discreet3DS::CHUNK_FACEMAT:
        {
        // at fist an asciiz with the material name
        const char* sz = (const char*)stream->GetPtr();
        while (stream->GetI1());

        // find the index of the material
        unsigned int idx = 0xcdcdcdcd, cnt = 0;
        for (std::vector<D3DS::Material>::const_iterator i =  mScene->mMaterials.begin();i != mScene->mMaterials.end();++i,++cnt)   {
            // use case independent comparisons. hopefully it will work.
            if ((*i).mName.length() && !ASSIMP_stricmp(sz, (*i).mName.c_str())) {
                idx = cnt;
                break;
            }
        }
        if (0xcdcdcdcd == idx)  {
            DefaultLogger::get()->error(std::string("3DS: Unknown material: ") + sz);
        }

        // Now continue and read all material indices
        cnt = (uint16_t)stream->GetI2();
        for (unsigned int i = 0; i < cnt;++i)   {
            unsigned int fidx = (uint16_t)stream->GetI2();

            // check range
            if (fidx >= mMesh.mFaceMaterials.size())    {
                DefaultLogger::get()->error("3DS: Invalid face index in face material list");
            }
            else mMesh.mFaceMaterials[fidx] = idx;
        }}
        break;
    };
    ASSIMP_3DS_END_CHUNK();
}

// ------------------------------------------------------------------------------------------------
// Read a mesh chunk. Here's the actual mesh data
void Discreet3DSImporter::ParseMeshChunk()
{
    ASSIMP_3DS_BEGIN_CHUNK();

    // Get the mesh we're currently working on
    D3DS::Mesh& mMesh = mScene->mMeshes.back();

    // get chunk type
    switch (chunk.Flag)
    {
    case Discreet3DS::CHUNK_VERTLIST:
        {
        // This is the list of all vertices in the current mesh
        int num = (int)(uint16_t)stream->GetI2();
        mMesh.mPositions.reserve(num);
        while (num-- > 0)   {
            aiVector3D v;
            v.x = stream->GetF4();
            v.y = stream->GetF4();
            v.z = stream->GetF4();
            mMesh.mPositions.push_back(v);
        }}
        break;
    case Discreet3DS::CHUNK_TRMATRIX:
        {
        // This is the RLEATIVE transformation matrix of the current mesh. Vertices are
        // pretransformed by this matrix wonder.
        mMesh.mMat.a1 = stream->GetF4();
        mMesh.mMat.b1 = stream->GetF4();
        mMesh.mMat.c1 = stream->GetF4();
        mMesh.mMat.a2 = stream->GetF4();
        mMesh.mMat.b2 = stream->GetF4();
        mMesh.mMat.c2 = stream->GetF4();
        mMesh.mMat.a3 = stream->GetF4();
        mMesh.mMat.b3 = stream->GetF4();
        mMesh.mMat.c3 = stream->GetF4();
        mMesh.mMat.a4 = stream->GetF4();
        mMesh.mMat.b4 = stream->GetF4();
        mMesh.mMat.c4 = stream->GetF4();
        }
        break;

    case Discreet3DS::CHUNK_MAPLIST:
        {
        // This is the list of all UV coords in the current mesh
        int num = (int)(uint16_t)stream->GetI2();
        mMesh.mTexCoords.reserve(num);
        while (num-- > 0)   {
            aiVector3D v;
            v.x = stream->GetF4();
            v.y = stream->GetF4();
            mMesh.mTexCoords.push_back(v);
        }}
        break;

    case Discreet3DS::CHUNK_FACELIST:
        {
        // This is the list of all faces in the current mesh
        int num = (int)(uint16_t)stream->GetI2();
        mMesh.mFaces.reserve(num);
        while (num-- > 0)   {
            // 3DS faces are ALWAYS triangles
            mMesh.mFaces.push_back(D3DS::Face());
            D3DS::Face& sFace = mMesh.mFaces.back();

            sFace.mIndices[0] = (uint16_t)stream->GetI2();
            sFace.mIndices[1] = (uint16_t)stream->GetI2();
            sFace.mIndices[2] = (uint16_t)stream->GetI2();

            stream->IncPtr(2); // skip edge visibility flag
        }

        // Resize the material array (0xcdcdcdcd marks the default material; so if a face is
        // not referenced by a material, $$DEFAULT will be assigned to it)
        mMesh.mFaceMaterials.resize(mMesh.mFaces.size(),0xcdcdcdcd);

        // Larger 3DS files could have multiple FACE chunks here
        chunkSize = stream->GetRemainingSizeToLimit();
        if ( chunkSize > (int) sizeof(Discreet3DS::Chunk ) )
            ParseFaceChunk();
        }
        break;
    };
    ASSIMP_3DS_END_CHUNK();
}

// ------------------------------------------------------------------------------------------------
// Read a 3DS material chunk
void Discreet3DSImporter::ParseMaterialChunk()
{
    ASSIMP_3DS_BEGIN_CHUNK();
    switch (chunk.Flag)
    {
    case Discreet3DS::CHUNK_MAT_MATNAME:

        {
        // The material name string is already zero-terminated, but we need to be sure ...
        const char* sz = (const char*)stream->GetPtr();
        unsigned int cnt = 0;
        while (stream->GetI1())
            ++cnt;

        if (!cnt)   {
            // This may not be, we use the default name instead
            DefaultLogger::get()->error("3DS: Empty material name");
        }
        else mScene->mMaterials.back().mName = std::string(sz,cnt);
        }
        break;

    case Discreet3DS::CHUNK_MAT_DIFFUSE:
        {
        // This is the diffuse material color
        aiColor3D* pc = &mScene->mMaterials.back().mDiffuse;
        ParseColorChunk(pc);
        if (is_qnan(pc->r)) {
            // color chunk is invalid. Simply ignore it
            DefaultLogger::get()->error("3DS: Unable to read DIFFUSE chunk");
            pc->r = pc->g = pc->b = 1.0f;
        }}
        break;

    case Discreet3DS::CHUNK_MAT_SPECULAR:
        {
        // This is the specular material color
        aiColor3D* pc = &mScene->mMaterials.back().mSpecular;
        ParseColorChunk(pc);
        if (is_qnan(pc->r)) {
            // color chunk is invalid. Simply ignore it
            DefaultLogger::get()->error("3DS: Unable to read SPECULAR chunk");
            pc->r = pc->g = pc->b = 1.0f;
        }}
        break;

    case Discreet3DS::CHUNK_MAT_AMBIENT:
        {
        // This is the ambient material color
        aiColor3D* pc = &mScene->mMaterials.back().mAmbient;
        ParseColorChunk(pc);
        if (is_qnan(pc->r)) {
            // color chunk is invalid. Simply ignore it
            DefaultLogger::get()->error("3DS: Unable to read AMBIENT chunk");
            pc->r = pc->g = pc->b = 0.0f;
        }}
        break;

    case Discreet3DS::CHUNK_MAT_SELF_ILLUM:
        {
        // This is the emissive material color
        aiColor3D* pc = &mScene->mMaterials.back().mEmissive;
        ParseColorChunk(pc);
        if (is_qnan(pc->r)) {
            // color chunk is invalid. Simply ignore it
            DefaultLogger::get()->error("3DS: Unable to read EMISSIVE chunk");
            pc->r = pc->g = pc->b = 0.0f;
        }}
        break;

    case Discreet3DS::CHUNK_MAT_TRANSPARENCY:
        {
            // This is the material's transparency
            ai_real* pcf = &mScene->mMaterials.back().mTransparency;
            *pcf = ParsePercentageChunk();

            // NOTE: transparency, not opacity
            if (is_qnan(*pcf))
                *pcf = ai_real( 1.0 );
            else 
                *pcf = ai_real( 1.0 ) - *pcf * (ai_real)0xFFFF / ai_real( 100.0 );
        }
        break;

    case Discreet3DS::CHUNK_MAT_SHADING:
        // This is the material shading mode
        mScene->mMaterials.back().mShading = (D3DS::Discreet3DS::shadetype3ds)stream->GetI2();
        break;

    case Discreet3DS::CHUNK_MAT_TWO_SIDE:
        // This is the two-sided flag
        mScene->mMaterials.back().mTwoSided = true;
        break;

    case Discreet3DS::CHUNK_MAT_SHININESS:
        { // This is the shininess of the material
        ai_real* pcf = &mScene->mMaterials.back().mSpecularExponent;
        *pcf = ParsePercentageChunk();
        if (is_qnan(*pcf))
            *pcf = 0.0;
        else *pcf *= (ai_real)0xFFFF;
        }
        break;

    case Discreet3DS::CHUNK_MAT_SHININESS_PERCENT:
        { // This is the shininess strength of the material
            ai_real* pcf = &mScene->mMaterials.back().mShininessStrength;
            *pcf = ParsePercentageChunk();
            if (is_qnan(*pcf))
                *pcf = ai_real( 0.0 );
            else 
                *pcf *= (ai_real)0xffff / ai_real( 100.0 );
        }
        break;

    case Discreet3DS::CHUNK_MAT_SELF_ILPCT:
        { // This is the self illumination strength of the material
            ai_real f = ParsePercentageChunk();
            if (is_qnan(f))
                f = ai_real( 0.0 );
            else 
                f *= (ai_real)0xFFFF / ai_real( 100.0 );
            mScene->mMaterials.back().mEmissive = aiColor3D(f,f,f);
        }
        break;

    // Parse texture chunks
    case Discreet3DS::CHUNK_MAT_TEXTURE:
        // Diffuse texture
        ParseTextureChunk(&mScene->mMaterials.back().sTexDiffuse);
        break;
    case Discreet3DS::CHUNK_MAT_BUMPMAP:
        // Height map
        ParseTextureChunk(&mScene->mMaterials.back().sTexBump);
        break;
    case Discreet3DS::CHUNK_MAT_OPACMAP:
        // Opacity texture
        ParseTextureChunk(&mScene->mMaterials.back().sTexOpacity);
        break;
    case Discreet3DS::CHUNK_MAT_MAT_SHINMAP:
        // Shininess map
        ParseTextureChunk(&mScene->mMaterials.back().sTexShininess);
        break;
    case Discreet3DS::CHUNK_MAT_SPECMAP:
        // Specular map
        ParseTextureChunk(&mScene->mMaterials.back().sTexSpecular);
        break;
    case Discreet3DS::CHUNK_MAT_SELFIMAP:
        // Self-illumination (emissive) map
        ParseTextureChunk(&mScene->mMaterials.back().sTexEmissive);
        break;
    case Discreet3DS::CHUNK_MAT_REFLMAP:
        // Reflection map
        ParseTextureChunk(&mScene->mMaterials.back().sTexReflective);
        break;
    };
    ASSIMP_3DS_END_CHUNK();
}

// ------------------------------------------------------------------------------------------------
void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture* pcOut)
{
    ASSIMP_3DS_BEGIN_CHUNK();

    // get chunk type
    switch (chunk.Flag)
    {
    case Discreet3DS::CHUNK_MAPFILE:
        {
        // The material name string is already zero-terminated, but we need to be sure ...
        const char* sz = (const char*)stream->GetPtr();
        unsigned int cnt = 0;
        while (stream->GetI1())
            ++cnt;
        pcOut->mMapName = std::string(sz,cnt);
        }
        break;


    case Discreet3DS::CHUNK_PERCENTD:
        // Manually parse the blend factor
        pcOut->mTextureBlend = ai_real( stream->GetF8() );
        break;

    case Discreet3DS::CHUNK_PERCENTF:
        // Manually parse the blend factor
        pcOut->mTextureBlend = stream->GetF4();
        break;

    case Discreet3DS::CHUNK_PERCENTW:
        // Manually parse the blend factor
        pcOut->mTextureBlend = (ai_real)((uint16_t)stream->GetI2()) / ai_real( 100.0 );
        break;

    case Discreet3DS::CHUNK_MAT_MAP_USCALE:
        // Texture coordinate scaling in the U direction
        pcOut->mScaleU = stream->GetF4();
        if (0.0f == pcOut->mScaleU)
        {
            DefaultLogger::get()->warn("Texture coordinate scaling in the x direction is zero. Assuming 1.");
            pcOut->mScaleU = 1.0f;
        }
        break;
    case Discreet3DS::CHUNK_MAT_MAP_VSCALE:
        // Texture coordinate scaling in the V direction
        pcOut->mScaleV = stream->GetF4();
        if (0.0f == pcOut->mScaleV)
        {
            DefaultLogger::get()->warn("Texture coordinate scaling in the y direction is zero. Assuming 1.");
            pcOut->mScaleV = 1.0f;
        }
        break;

    case Discreet3DS::CHUNK_MAT_MAP_UOFFSET:
        // Texture coordinate offset in the U direction
        pcOut->mOffsetU = -stream->GetF4();
        break;

    case Discreet3DS::CHUNK_MAT_MAP_VOFFSET:
        // Texture coordinate offset in the V direction
        pcOut->mOffsetV = stream->GetF4();
        break;

    case Discreet3DS::CHUNK_MAT_MAP_ANG:
        // Texture coordinate rotation, CCW in DEGREES
        pcOut->mRotation = -AI_DEG_TO_RAD( stream->GetF4() );
        break;

    case Discreet3DS::CHUNK_MAT_MAP_TILING:
        {
        const uint16_t iFlags = stream->GetI2();

        // Get the mapping mode (for both axes)
        if (iFlags & 0x2u)
            pcOut->mMapMode = aiTextureMapMode_Mirror;

        else if (iFlags & 0x10u)
            pcOut->mMapMode = aiTextureMapMode_Decal;

        // wrapping in all remaining cases
        else pcOut->mMapMode = aiTextureMapMode_Wrap;
        }
        break;
    };

    ASSIMP_3DS_END_CHUNK();
}

// ------------------------------------------------------------------------------------------------
// Read a percentage chunk
ai_real Discreet3DSImporter::ParsePercentageChunk()
{
    Discreet3DS::Chunk chunk;
    ReadChunk(&chunk);

    if (Discreet3DS::CHUNK_PERCENTF == chunk.Flag)
        return stream->GetF4();
    else if (Discreet3DS::CHUNK_PERCENTW == chunk.Flag)
        return (ai_real)((uint16_t)stream->GetI2()) / (ai_real)0xFFFF;
    return get_qnan();
}

// ------------------------------------------------------------------------------------------------
// Read a color chunk. If a percentage chunk is found instead it is read as a grayscale color
void Discreet3DSImporter::ParseColorChunk( aiColor3D* out, bool acceptPercent )
{
    ai_assert(out != NULL);

    // error return value
    const ai_real qnan = get_qnan();
    static const aiColor3D clrError = aiColor3D(qnan,qnan,qnan);

    Discreet3DS::Chunk chunk;
    ReadChunk(&chunk);
    const unsigned int diff = chunk.Size - sizeof(Discreet3DS::Chunk);

    bool bGamma = false;

    // Get the type of the chunk
    switch(chunk.Flag)
    {
    case Discreet3DS::CHUNK_LINRGBF:
        bGamma = true;

    case Discreet3DS::CHUNK_RGBF:
        if (sizeof(ai_real) * 3 > diff)   {
            *out = clrError;
            return;
        }
        out->r = stream->GetF4();
        out->g = stream->GetF4();
        out->b = stream->GetF4();
        break;

    case Discreet3DS::CHUNK_LINRGBB:
        bGamma = true;
    case Discreet3DS::CHUNK_RGBB:
        {
            if ( sizeof( char ) * 3 > diff ) {
                *out = clrError;
                return;
            }
            const ai_real invVal = ai_real( 1.0 ) / ai_real( 255.0 );
            out->r = ( ai_real ) ( uint8_t ) stream->GetI1() * invVal;
            out->g = ( ai_real ) ( uint8_t ) stream->GetI1() * invVal;
            out->b = ( ai_real ) ( uint8_t ) stream->GetI1() * invVal;
        }
        break;

    // Percentage chunks are accepted, too.
    case Discreet3DS::CHUNK_PERCENTF:
        if (acceptPercent && 4 <= diff) {
            out->g = out->b = out->r = stream->GetF4();
            break;
        }
        *out = clrError;
        return;

    case Discreet3DS::CHUNK_PERCENTW:
        if (acceptPercent && 1 <= diff) {
            out->g = out->b = out->r = (ai_real)(uint8_t)stream->GetI1() / ai_real( 255.0 );
            break;
        }
        *out = clrError;
        return;

    default:
        stream->IncPtr(diff);
        // Skip unknown chunks, hope this won't cause any problems.
        return ParseColorChunk(out,acceptPercent);
    };
    (void)bGamma;
}

#endif // !! ASSIMP_BUILD_NO_3DS_IMPORTER