1434 lines
47 KiB
C++
1434 lines
47 KiB
C++
/*
|
|
---------------------------------------------------------------------------
|
|
Open Asset Import Library (assimp)
|
|
---------------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2017, assimp team
|
|
|
|
|
|
All rights reserved.
|
|
|
|
Redistribution and use of this software in source and binary forms,
|
|
with or without modification, are permitted provided that the following
|
|
conditions are met:
|
|
|
|
* Redistributions of source code must retain the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer in the documentation and/or other
|
|
materials provided with the distribution.
|
|
|
|
* Neither the name of the assimp team, nor the names of its
|
|
contributors may be used to endorse or promote products
|
|
derived from this software without specific prior
|
|
written permission of the assimp team.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
---------------------------------------------------------------------------
|
|
*/
|
|
|
|
/** @file 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(float) * 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
|