assimp/code/IRRLoader.cpp

425 lines
12 KiB
C++
Raw Normal View History

/*
---------------------------------------------------------------------------
Open Asset Import Library (ASSIMP)
---------------------------------------------------------------------------
Copyright (c) 2006-2008, ASSIMP Development Team
All rights reserved.
Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the following
conditions are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the
following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
* Neither the name of the ASSIMP team, nor the names of its
contributors may be used to endorse or promote products
derived from this software without specific prior
written permission of the ASSIMP Development Team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
/** @file Implementation of the Irr importer class */
#include "AssimpPCH.h"
#include "IRRLoader.h"
#include "ParsingUtils.h"
#include "fast_atof.h"
#include "StandardShapes.h"
using namespace Assimp;
// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
IRRImporter::IRRImporter()
{
// nothing to do here
}
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
IRRImporter::~IRRImporter()
{
// nothing to do here
}
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool IRRImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler) const
{
/* NOTE: A simple check for the file extension is not enough
* here. Irrmesh and irr are easy, but xml is too generic
* and could be collada, too. So we need to open the file and
* search for typical tokens.
*/
std::string::size_type pos = pFile.find_last_of('.');
// no file extension - can't read
if( pos == std::string::npos)
return false;
std::string extension = pFile.substr( pos);
for (std::string::iterator i = extension.begin(); i != extension.end();++i)
*i = ::tolower(*i);
if (extension == ".irr")return true;
else if (extension == ".xml")
{
/* If CanRead() is called to check whether the loader
* supports a specific file extension in general we
* must return true here.
*/
if (!pIOHandler)return true;
const char* tokens[] = {"irr_scene"};
return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
}
return false;
}
// ------------------------------------------------------------------------------------------------
// Imports the given file into the given scene structure.
void IRRImporter::InternReadFile( const std::string& pFile,
aiScene* pScene, IOSystem* pIOHandler)
{
boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile));
// Check whether we can read from the file
if( file.get() == NULL)
throw new ImportErrorException( "Failed to open IRR file " + pFile + "");
// Construct the irrXML parser
CIrrXML_IOStreamReader st(file.get());
reader = createIrrXMLReader((IFileReadCallBack*) &st);
// The root node of the scene
Node* root = new Node(Node::DUMMY);
root->parent = NULL;
// Current node parent
Node* curParent = root;
// Scenegraph node we're currently working on
Node* curNode = NULL;
// List of output cameras
std::vector<aiCamera*> cameras;
// List of output lights
std::vector<aiLight*> lights;
// List of output meshes
std::vector<aiMesh*> meshes;
// List of output animation channels
std::vector<aiNodeAnim*> animations;
BatchLoader batch(pIOHandler);
cameras.reserve(5);
lights.reserve(5);
animations.reserve(5);
meshes.reserve(5);
bool inMaterials = false;
// Parse the XML file
while (reader->read())
{
switch (reader->getNodeType())
{
case EXN_ELEMENT:
if (!ASSIMP_stricmp(reader->getNodeName(),"node"))
{
/* What we're going to do with the node depends
* on its type:
*
* "mesh" - Load a mesh from an external file
* "cube" - Generate a cube
* "skybox" - Generate a skybox
* "light" - A light source
* "sphere" - Generate a sphere mesh
* "animatedMesh" - Load an animated mesh from an external file
* and join its animation channels with ours.
* "empty" - A dummy node
* "camera" - A camera
*
* Each of these nodes can be animated.
*/
const char* sz = reader->getAttributeValueSafe("type");
Node* nd;
if (!ASSIMP_stricmp(sz,"mesh"))
{
nd = new Node(Node::MESH);
}
else if (!ASSIMP_stricmp(sz,"cube"))
{
nd = new Node(Node::CUBE);
meshes.push_back(StandardShapes::MakeMesh(&StandardShapes::MakeHexahedron));
}
else if (!ASSIMP_stricmp(sz,"skybox"))
{
nd = new Node(Node::SKYBOX);
}
else if (!ASSIMP_stricmp(sz,"camera"))
{
nd = new Node(Node::CAMERA);
// Setup a temporary name for the camera
aiCamera* cam = new aiCamera();
cam->mName.Set( nd->name );
cameras.push_back(cam);
}
else if (!ASSIMP_stricmp(sz,"light"))
{
nd = new Node(Node::LIGHT);
// Setup a temporary name for the light
aiLight* cam = new aiLight();
cam->mName.Set( nd->name );
lights.push_back(cam);
}
else if (!ASSIMP_stricmp(sz,"sphere"))
{
nd = new Node(Node::SPHERE);
}
else if (!ASSIMP_stricmp(sz,"animatedMesh"))
{
nd = new Node(Node::ANIMMESH);
}
else if (!ASSIMP_stricmp(sz,"empty"))
{
nd = new Node(Node::DUMMY);
}
else
{
DefaultLogger::get()->warn("IRR: Found unknown node: " + std::string(sz));
/* We skip the contents of nodes we don't know.
* We parse the transformation and all animators
* and skip the rest.
*/
nd = new Node(Node::DUMMY);
}
/* Attach the newly created node to the scenegraph
*/
curNode = nd;
nd->parent = curParent;
curParent->children.push_back(nd);
}
else if (!ASSIMP_stricmp(reader->getNodeName(),"materials"))
{
inMaterials = true;
}
else if (!ASSIMP_stricmp(reader->getNodeName(),"attributes"))
{
/* We should have a valid node here
*/
if (!curNode)
{
DefaultLogger::get()->error("IRR: Encountered <attributes> element, but "
"there is no node active");
continue;
}
if (inMaterials && curNode->type == Node::ANIMMESH ||
curNode->type == Node::MESH )
{
/* This is a material description - parse it!
*/
curNode->materials.push_back(std::pair< aiMaterial*, unsigned int > () );
std::pair< aiMaterial*, unsigned int >& p = curNode->materials.back();
p.first = ParseMaterial(p.second);
continue;
}
/* Parse all elements in the attributes block
* and process them.
*/
while (reader->read())
{
if (reader->getNodeType() == EXN_ELEMENT)
{
if (!ASSIMP_stricmp(reader->getNodeName(),"vector3d"))
{
VectorProperty prop;
ReadVectorProperty(prop);
// Convert to our coordinate system
std::swap( (float&)prop.value.z, (float&)prop.value.y );
prop.value.y *= -1.f;
if (prop.name == "Position")
{
curNode->position = prop.value;
}
else if (prop.name == "Rotation")
{
curNode->rotation = prop.value;
}
else if (prop.name == "Scale")
{
curNode->scaling = prop.value;
}
else if (Node::CAMERA == curNode->type)
{
aiCamera* cam = cameras.back();
if (prop.name == "Target")
{
cam->mLookAt = prop.value;
}
else if (prop.name == "UpVector")
{
cam->mUp = prop.value;
}
}
}
else if (!ASSIMP_stricmp(reader->getNodeName(),"float"))
{
FloatProperty prop;
ReadFloatProperty(prop);
if (prop.name == "FramesPerSecond" &&
Node::ANIMMESH == curNode->type)
{
curNode->framesPerSecond = prop.value;
}
else if (Node::CAMERA == curNode->type)
{
/* This is the vertical, not the horizontal FOV.
* We need to compute the right FOV from the
* screen aspect which we don't know yet.
*/
if (prop.name == "Fovy")
{
cameras.back()->mHorizontalFOV = prop.value;
}
else if (prop.name == "Aspect")
{
cameras.back()->mAspect = prop.value;
}
else if (prop.name == "ZNear")
{
cameras.back()->mClipPlaneNear = prop.value;
}
else if (prop.name == "ZFar")
{
cameras.back()->mClipPlaneFar = prop.value;
}
}
}
else if (!ASSIMP_stricmp(reader->getNodeName(),"string"))
{
StringProperty prop;
ReadStringProperty(prop);
if (prop.value.length())
{
if (prop.name == "Name")
{
curNode->name = prop.value;
/* If we're either a camera or a light source
* we need to update the name in the aiLight/
* aiCamera structure, too.
*/
if (Node::CAMERA == curNode->type)
{
cameras.back()->mName.Set(prop.value);
}
else if (Node::LIGHT == curNode->type)
{
lights.back()->mName.Set(prop.value);
}
}
else if (prop.name == "Mesh" && Node::MESH == curNode->type ||
Node::ANIMMESH == curNode->type)
{
/* This is the file name of the mesh - either
* animated or not. We don't need any postprocessing
* steps here. However, it would be useful it we'd
* be able to use RemoveVC to remove animations
* if this isn't an animated mesh. But that's not
* possible at the moment.
*/
batch.AddLoadRequest(prop.value);
}
}
}
}
else if (reader->getNodeType() == EXN_ELEMENT_END &&
!ASSIMP_stricmp(reader->getNodeName(),"attributes"))
{
break;
}
}
}
break;
case EXN_ELEMENT_END:
if (!ASSIMP_stricmp(reader->getNodeName(),"node"))
{
if (!curNode)
{
// currently is no node set. We need to go
// back in the node hierarchy
curParent = curParent->parent;
if (!curParent)
{
curParent = root;
DefaultLogger::get()->error("IRR: Too many closing <node> elements");
}
}
else curNode = NULL;
}
else if (!ASSIMP_stricmp(reader->getNodeName(),"materials"))
{
inMaterials = false;
}
break;
default:
// GCC complains that not all enumeration values are handled
break;
}
}
/* Now iterate through all cameras and compute their final (horizontal) FOV
*/
for (std::vector<aiCamera*>::iterator it = cameras.begin(), end = cameras.end();
it != end; ++it)
{
aiCamera* cam = *it;
if (cam->mAspect) // screen aspect could be missing
{
cam->mHorizontalFOV *= cam->mAspect;
}
else DefaultLogger::get()->warn("IRR: Camera aspect is not given, can't compute horizontal FOV");
}
}