v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
assimp/code/Collada/ColladaParser.cpp

3492 lines
130 KiB
C++
Raw Blame History

/*
---------------------------------------------------------------------------
Open Asset Import Library (assimp)
---------------------------------------------------------------------------
Copyright (c) 2006-2019, 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 ColladaParser.cpp
* @brief Implementation of the Collada parser helper
*/
#ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER
#include <sstream>
#include <stdarg.h>
#include "ColladaParser.h"
#include <assimp/commonMetaData.h>
#include <assimp/fast_atof.h>
#include <assimp/ParsingUtils.h>
#include <assimp/StringUtils.h>
#include <assimp/DefaultLogger.hpp>
#include <assimp/IOSystem.hpp>
#include <assimp/light.h>
#include <assimp/TinyFormatter.h>
#include <assimp/ZipArchiveIOSystem.h>
#include <memory>
using namespace Assimp;
using namespace Assimp::Collada;
using namespace Assimp::Formatter;
// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
ColladaParser::ColladaParser(IOSystem* pIOHandler, const std::string& pFile)
: mFileName(pFile)
, mReader(nullptr)
, mDataLibrary()
, mAccessorLibrary()
, mMeshLibrary()
, mNodeLibrary()
, mImageLibrary()
, mEffectLibrary()
, mMaterialLibrary()
, mLightLibrary()
, mCameraLibrary()
, mControllerLibrary()
, mRootNode(nullptr)
, mAnims()
, mUnitSize(1.0f)
, mUpDirection(UP_Y)
, mFormat(FV_1_5_n) // We assume the newest file format by default
{
// validate io-handler instance
if (nullptr == pIOHandler) {
throw DeadlyImportError("IOSystem is NULL.");
}
std::unique_ptr<IOStream> daefile;
std::unique_ptr<ZipArchiveIOSystem> zip_archive;
// Determine type
std::string extension = BaseImporter::GetExtension(pFile);
if (extension != "dae") {
zip_archive.reset(new ZipArchiveIOSystem(pIOHandler, pFile));
}
if (zip_archive && zip_archive->isOpen()) {
std::string dae_filename = ReadZaeManifest(*zip_archive);
if (dae_filename.empty()) {
ThrowException(std::string("Invalid ZAE"));
}
daefile.reset(zip_archive->Open(dae_filename.c_str()));
if (daefile == nullptr) {
ThrowException(std::string("Invalid ZAE manifest: '") + std::string(dae_filename) + std::string("' is missing"));
}
}
else {
// attempt to open the file directly
daefile.reset(pIOHandler->Open(pFile));
if (daefile.get() == nullptr) {
throw DeadlyImportError("Failed to open file '" + pFile + "'.");
}
}
// generate a XML reader for it
std::unique_ptr<CIrrXML_IOStreamReader> mIOWrapper(new CIrrXML_IOStreamReader(daefile.get()));
mReader = irr::io::createIrrXMLReader(mIOWrapper.get());
if (!mReader) {
ThrowException("Unable to read file, malformed XML");
}
// start reading
ReadContents();
// read embedded textures
if (zip_archive && zip_archive->isOpen()) {
ReadEmbeddedTextures(*zip_archive);
}
}
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
ColladaParser::~ColladaParser()
{
delete mReader;
for (NodeLibrary::iterator it = mNodeLibrary.begin(); it != mNodeLibrary.end(); ++it)
delete it->second;
for (MeshLibrary::iterator it = mMeshLibrary.begin(); it != mMeshLibrary.end(); ++it)
delete it->second;
}
// ------------------------------------------------------------------------------------------------
// Read a ZAE manifest and return the filename to attempt to open
std::string ColladaParser::ReadZaeManifest(ZipArchiveIOSystem &zip_archive) {
// Open the manifest
std::unique_ptr<IOStream> manifestfile(zip_archive.Open("manifest.xml"));
if (manifestfile == nullptr)
{
// No manifest, hope there is only one .DAE inside
std::vector<std::string> file_list;
zip_archive.getFileListExtension(file_list, "dae");
if (file_list.empty())
return std::string();
return file_list.front();
}
std::unique_ptr<CIrrXML_IOStreamReader> mIOWrapper(new CIrrXML_IOStreamReader(manifestfile.get()));
std::unique_ptr<irr::io::IrrXMLReader> manifest_reader(irr::io::createIrrXMLReader(mIOWrapper.get()));
while (manifest_reader->read())
{
// find the manifest "dae_root" element
if (manifest_reader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (::strcmp(manifest_reader->getNodeName(), "dae_root") == 0)
{
if (!manifest_reader->read())
return std::string();
if (manifest_reader->getNodeType() != irr::io::EXN_TEXT && manifest_reader->getNodeType() != irr::io::EXN_CDATA)
return std::string();
const char* filepath = manifest_reader->getNodeData();
if (filepath == nullptr)
return std::string();
aiString ai_str(filepath);
UriDecodePath(ai_str);
return std::string(ai_str.C_Str());
}
}
}
return std::string();
}
// ------------------------------------------------------------------------------------------------
// Convert a path read from a collada file to the usual representation
void ColladaParser::UriDecodePath(aiString& ss)
{
// TODO: collada spec, p 22. Handle URI correctly.
// For the moment we're just stripping the file:// away to make it work.
// Windows doesn't seem to be able to find stuff like
// 'file://..\LWO\LWO2\MappingModes\earthSpherical.jpg'
if (0 == strncmp(ss.data, "file://", 7))
{
ss.length -= 7;
memmove(ss.data, ss.data + 7, ss.length);
ss.data[ss.length] = '\0';
}
// Maxon Cinema Collada Export writes "file:///C:\andsoon" with three slashes...
// I need to filter it without destroying linux paths starting with "/somewhere"
#if defined( _MSC_VER )
if (ss.data[0] == '/' && isalpha((unsigned char)ss.data[1]) && ss.data[2] == ':') {
#else
if (ss.data[0] == '/' && isalpha(ss.data[1]) && ss.data[2] == ':') {
#endif
--ss.length;
::memmove(ss.data, ss.data + 1, ss.length);
ss.data[ss.length] = 0;
}
// find and convert all %xy special chars
char* out = ss.data;
for (const char* it = ss.data; it != ss.data + ss.length; /**/)
{
if (*it == '%' && (it + 3) < ss.data + ss.length)
{
// separate the number to avoid dragging in chars from behind into the parsing
char mychar[3] = { it[1], it[2], 0 };
size_t nbr = strtoul16(mychar);
it += 3;
*out++ = (char)(nbr & 0xFF);
}
else
{
*out++ = *it++;
}
}
// adjust length and terminator of the shortened string
*out = 0;
ai_assert(out > ss.data);
ss.length = static_cast<ai_uint32>(out - ss.data);
}
// ------------------------------------------------------------------------------------------------
// Read bool from text contents of current element
bool ColladaParser::ReadBoolFromTextContent()
{
const char* cur = GetTextContent();
if ( nullptr == cur) {
return false;
}
return (!ASSIMP_strincmp(cur, "true", 4) || '0' != *cur);
}
// ------------------------------------------------------------------------------------------------
// Read float from text contents of current element
ai_real ColladaParser::ReadFloatFromTextContent()
{
const char* cur = GetTextContent();
if ( nullptr == cur ) {
return 0.0;
}
return fast_atof(cur);
}
// ------------------------------------------------------------------------------------------------
// Reads the contents of the file
void ColladaParser::ReadContents()
{
while (mReader->read())
{
// handle the root element "COLLADA"
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("COLLADA"))
{
// check for 'version' attribute
const int attrib = TestAttribute("version");
if (attrib != -1) {
const char* version = mReader->getAttributeValue(attrib);
// Store declared format version string
aiString v;
v.Set(version);
mAssetMetaData.emplace(AI_METADATA_SOURCE_FORMAT_VERSION, v );
if (!::strncmp(version, "1.5", 3)) {
mFormat = FV_1_5_n;
ASSIMP_LOG_DEBUG("Collada schema version is 1.5.n");
}
else if (!::strncmp(version, "1.4", 3)) {
mFormat = FV_1_4_n;
ASSIMP_LOG_DEBUG("Collada schema version is 1.4.n");
}
else if (!::strncmp(version, "1.3", 3)) {
mFormat = FV_1_3_n;
ASSIMP_LOG_DEBUG("Collada schema version is 1.3.n");
}
}
ReadStructure();
}
else
{
ASSIMP_LOG_DEBUG_F("Ignoring global element <", mReader->getNodeName(), ">.");
SkipElement();
}
}
else
{
// skip everything else silently
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads the structure of the file
void ColladaParser::ReadStructure()
{
while (mReader->read())
{
// beginning of elements
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("asset"))
ReadAssetInfo();
else if (IsElement("library_animations"))
ReadAnimationLibrary();
else if (IsElement("library_animation_clips"))
ReadAnimationClipLibrary();
else if (IsElement("library_controllers"))
ReadControllerLibrary();
else if (IsElement("library_images"))
ReadImageLibrary();
else if (IsElement("library_materials"))
ReadMaterialLibrary();
else if (IsElement("library_effects"))
ReadEffectLibrary();
else if (IsElement("library_geometries"))
ReadGeometryLibrary();
else if (IsElement("library_visual_scenes"))
ReadSceneLibrary();
else if (IsElement("library_lights"))
ReadLightLibrary();
else if (IsElement("library_cameras"))
ReadCameraLibrary();
else if (IsElement("library_nodes"))
ReadSceneNode(NULL); /* some hacking to reuse this piece of code */
else if (IsElement("scene"))
ReadScene();
else
SkipElement();
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
break;
}
}
PostProcessRootAnimations();
PostProcessControllers();
}
// ------------------------------------------------------------------------------------------------
// Reads asset information such as coordinate system information and legal blah
void ColladaParser::ReadAssetInfo()
{
if (mReader->isEmptyElement())
return;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("unit"))
{
// read unit data from the element's attributes
const int attrIndex = TestAttribute("meter");
if (attrIndex == -1) {
mUnitSize = 1.f;
}
else {
mUnitSize = mReader->getAttributeValueAsFloat(attrIndex);
}
// consume the trailing stuff
if (!mReader->isEmptyElement())
SkipElement();
}
else if (IsElement("up_axis"))
{
// read content, strip whitespace, compare
const char* content = GetTextContent();
if (strncmp(content, "X_UP", 4) == 0)
mUpDirection = UP_X;
else if (strncmp(content, "Z_UP", 4) == 0)
mUpDirection = UP_Z;
else
mUpDirection = UP_Y;
// check element end
TestClosing("up_axis");
}
else if (IsElement("contributor"))
{
ReadContributorInfo();
}
else
{
ReadMetaDataItem(mAssetMetaData);
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "asset") != 0)
ThrowException("Expected end of <asset> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads the contributor info
void ColladaParser::ReadContributorInfo()
{
if (mReader->isEmptyElement())
return;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
ReadMetaDataItem(mAssetMetaData);
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "contributor") != 0)
ThrowException("Expected end of <contributor> element.");
break;
}
}
}
static bool FindCommonKey(const std::string &collada_key, const MetaKeyPairVector &key_renaming, size_t &found_index) {
for (size_t i = 0; i < key_renaming.size(); ++i) {
if (key_renaming[i].first == collada_key) {
found_index = i;
return true;
}
}
found_index = std::numeric_limits<size_t>::max();
return false;
}
// ------------------------------------------------------------------------------------------------
// Reads a single string metadata item
void ColladaParser::ReadMetaDataItem(StringMetaData &metadata) {
const Collada::MetaKeyPairVector &key_renaming = GetColladaAssimpMetaKeysCamelCase();
// Metadata such as created, keywords, subject etc
const char *key_char = mReader->getNodeName();
if (key_char != nullptr) {
const std::string key_str(key_char);
const char *value_char = TestTextContent();
if (value_char != nullptr) {
aiString aistr;
aistr.Set(value_char);
std::string camel_key_str(key_str);
ToCamelCase(camel_key_str);
size_t found_index;
if (FindCommonKey(camel_key_str, key_renaming, found_index)) {
metadata.emplace(key_renaming[found_index].second, aistr);
} else {
metadata.emplace(camel_key_str, aistr);
}
}
TestClosing(key_str.c_str());
}
else
SkipElement();
}
// ------------------------------------------------------------------------------------------------
// Reads the animation clips
void ColladaParser::ReadAnimationClipLibrary()
{
if (mReader->isEmptyElement())
return;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("animation_clip"))
{
// optional name given as an attribute
std::string animName;
int indexName = TestAttribute("name");
int indexID = TestAttribute("id");
if (indexName >= 0)
animName = mReader->getAttributeValue(indexName);
else if (indexID >= 0)
animName = mReader->getAttributeValue(indexID);
else
animName = std::string("animation_") + to_string(mAnimationClipLibrary.size());
std::pair<std::string, std::vector<std::string> > clip;
clip.first = animName;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("instance_animation"))
{
int indexUrl = TestAttribute("url");
if (indexUrl >= 0)
{
const char* url = mReader->getAttributeValue(indexUrl);
if (url[0] != '#')
ThrowException("Unknown reference format");
url++;
clip.second.push_back(url);
}
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "animation_clip") != 0)
ThrowException("Expected end of <animation_clip> element.");
break;
}
}
if (clip.second.size() > 0)
{
mAnimationClipLibrary.push_back(clip);
}
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "library_animation_clips") != 0)
ThrowException("Expected end of <library_animation_clips> element.");
break;
}
}
}
void ColladaParser::PostProcessControllers()
{
std::string meshId;
for (ControllerLibrary::iterator it = mControllerLibrary.begin(); it != mControllerLibrary.end(); ++it) {
meshId = it->second.mMeshId;
ControllerLibrary::iterator findItr = mControllerLibrary.find(meshId);
while (findItr != mControllerLibrary.end()) {
meshId = findItr->second.mMeshId;
findItr = mControllerLibrary.find(meshId);
}
it->second.mMeshId = meshId;
}
}
// ------------------------------------------------------------------------------------------------
// Re-build animations from animation clip library, if present, otherwise combine single-channel animations
void ColladaParser::PostProcessRootAnimations()
{
if (mAnimationClipLibrary.size() > 0)
{
Animation temp;
for (AnimationClipLibrary::iterator it = mAnimationClipLibrary.begin(); it != mAnimationClipLibrary.end(); ++it)
{
std::string clipName = it->first;
Animation *clip = new Animation();
clip->mName = clipName;
temp.mSubAnims.push_back(clip);
for (std::vector<std::string>::iterator a = it->second.begin(); a != it->second.end(); ++a)
{
std::string animationID = *a;
AnimationLibrary::iterator animation = mAnimationLibrary.find(animationID);
if (animation != mAnimationLibrary.end())
{
Animation *pSourceAnimation = animation->second;
pSourceAnimation->CollectChannelsRecursively(clip->mChannels);
}
}
}
mAnims = temp;
// Ensure no double deletes.
temp.mSubAnims.clear();
}
else
{
mAnims.CombineSingleChannelAnimations();
}
}
// ------------------------------------------------------------------------------------------------
// Reads the animation library
void ColladaParser::ReadAnimationLibrary()
{
if (mReader->isEmptyElement())
return;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("animation"))
{
// delegate the reading. Depending on the inner elements it will be a container or a anim channel
ReadAnimation(&mAnims);
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "library_animations") != 0)
ThrowException("Expected end of <library_animations> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads an animation into the given parent structure
void ColladaParser::ReadAnimation(Collada::Animation* pParent)
{
if (mReader->isEmptyElement())
return;
// an <animation> element may be a container for grouping sub-elements or an animation channel
// this is the channel collection by ID, in case it has channels
typedef std::map<std::string, AnimationChannel> ChannelMap;
ChannelMap channels;
// this is the anim container in case we're a container
Animation* anim = NULL;
// optional name given as an attribute
std::string animName;
std::string animID;
int indexName = TestAttribute("name");
int indexID = TestAttribute("id");
if (indexID >= 0)
animID = mReader->getAttributeValue(indexID);
if (indexName >= 0)
animName = mReader->getAttributeValue(indexName);
else if (indexID >= 0)
animName = animID;
else
animName = "animation";
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
// we have subanimations
if (IsElement("animation"))
{
// create container from our element
if (!anim)
{
anim = new Animation;
anim->mName = animName;
pParent->mSubAnims.push_back(anim);
}
// recurse into the subelement
ReadAnimation(anim);
}
else if (IsElement("source"))
{
// possible animation data - we'll never know. Better store it
ReadSource();
}
else if (IsElement("sampler"))
{
// read the ID to assign the corresponding collada channel afterwards.
int indexID = GetAttribute("id");
std::string id = mReader->getAttributeValue(indexID);
ChannelMap::iterator newChannel = channels.insert(std::make_pair(id, AnimationChannel())).first;
// have it read into a channel
ReadAnimationSampler(newChannel->second);
}
else if (IsElement("channel"))
{
// the binding element whose whole purpose is to provide the target to animate
// Thanks, Collada! A directly posted information would have been too simple, I guess.
// Better add another indirection to that! Can't have enough of those.
int indexTarget = GetAttribute("target");
int indexSource = GetAttribute("source");
const char* sourceId = mReader->getAttributeValue(indexSource);
if (sourceId[0] == '#')
sourceId++;
ChannelMap::iterator cit = channels.find(sourceId);
if (cit != channels.end())
cit->second.mTarget = mReader->getAttributeValue(indexTarget);
if (!mReader->isEmptyElement())
SkipElement();
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "animation") != 0)
ThrowException("Expected end of <animation> element.");
break;
}
}
// it turned out to have channels - add them
if (!channels.empty())
{
// FIXME: Is this essentially doing the same as "single-anim-node" codepath in
// ColladaLoader::StoreAnimations? For now, this has been deferred to after
// all animations and all clips have been read. Due to handling of
// <library_animation_clips> this cannot be done here, as the channel owner
// is lost, and some exporters make up animations by referring to multiple
// single-channel animations from an <instance_animation>.
/*
// special filtering for stupid exporters packing each channel into a separate animation
if( channels.size() == 1)
{
pParent->mChannels.push_back( channels.begin()->second);
} else
*/
{
// else create the animation, if not done yet, and store the channels
if (!anim)
{
anim = new Animation;
anim->mName = animName;
pParent->mSubAnims.push_back(anim);
}
for (ChannelMap::const_iterator it = channels.begin(); it != channels.end(); ++it)
anim->mChannels.push_back(it->second);
if (indexID >= 0)
{
mAnimationLibrary[animID] = anim;
}
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads an animation sampler into the given anim channel
void ColladaParser::ReadAnimationSampler(Collada::AnimationChannel& pChannel)
{
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("input"))
{
int indexSemantic = GetAttribute("semantic");
const char* semantic = mReader->getAttributeValue(indexSemantic);
int indexSource = GetAttribute("source");
const char* source = mReader->getAttributeValue(indexSource);
if (source[0] != '#')
ThrowException("Unsupported URL format");
source++;
if (strcmp(semantic, "INPUT") == 0)
pChannel.mSourceTimes = source;
else if (strcmp(semantic, "OUTPUT") == 0)
pChannel.mSourceValues = source;
else if (strcmp(semantic, "IN_TANGENT") == 0)
pChannel.mInTanValues = source;
else if (strcmp(semantic, "OUT_TANGENT") == 0)
pChannel.mOutTanValues = source;
else if (strcmp(semantic, "INTERPOLATION") == 0)
pChannel.mInterpolationValues = source;
if (!mReader->isEmptyElement())
SkipElement();
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "sampler") != 0)
ThrowException("Expected end of <sampler> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads the skeleton controller library
void ColladaParser::ReadControllerLibrary()
{
if (mReader->isEmptyElement())
return;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("controller"))
{
// read ID. Ask the spec if it's necessary or optional... you might be surprised.
int attrID = GetAttribute("id");
std::string id = mReader->getAttributeValue(attrID);
// create an entry and store it in the library under its ID
mControllerLibrary[id] = Controller();
// read on from there
ReadController(mControllerLibrary[id]);
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "library_controllers") != 0)
ThrowException("Expected end of <library_controllers> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads a controller into the given mesh structure
void ColladaParser::ReadController(Collada::Controller& pController)
{
// initial values
pController.mType = Skin;
pController.mMethod = Normalized;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
// two types of controllers: "skin" and "morph". Only the first one is relevant, we skip the other
if (IsElement("morph"))
{
pController.mType = Morph;
int baseIndex = GetAttribute("source");
pController.mMeshId = mReader->getAttributeValue(baseIndex) + 1;
int methodIndex = GetAttribute("method");
if (methodIndex > 0) {
const char *method = mReader->getAttributeValue(methodIndex);
if (strcmp(method, "RELATIVE") == 0)
pController.mMethod = Relative;
}
}
else if (IsElement("skin"))
{
// read the mesh it refers to. According to the spec this could also be another
// controller, but I refuse to implement every single idea they've come up with
int sourceIndex = GetAttribute("source");
pController.mMeshId = mReader->getAttributeValue(sourceIndex) + 1;
}
else if (IsElement("bind_shape_matrix"))
{
// content is 16 floats to define a matrix... it seems to be important for some models
const char* content = GetTextContent();
// read the 16 floats
for (unsigned int a = 0; a < 16; a++)
{
// read a number
content = fast_atoreal_move<ai_real>(content, pController.mBindShapeMatrix[a]);
// skip whitespace after it
SkipSpacesAndLineEnd(&content);
}
TestClosing("bind_shape_matrix");
}
else if (IsElement("source"))
{
// data array - we have specialists to handle this
ReadSource();
}
else if (IsElement("joints"))
{
ReadControllerJoints(pController);
}
else if (IsElement("vertex_weights"))
{
ReadControllerWeights(pController);
}
else if (IsElement("targets"))
{
while (mReader->read()) {
if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
if (IsElement("input")) {
int semanticsIndex = GetAttribute("semantic");
int sourceIndex = GetAttribute("source");
const char *semantics = mReader->getAttributeValue(semanticsIndex);
const char *source = mReader->getAttributeValue(sourceIndex);
if (strcmp(semantics, "MORPH_TARGET") == 0) {
pController.mMorphTarget = source + 1;
}
else if (strcmp(semantics, "MORPH_WEIGHT") == 0)
{
pController.mMorphWeight = source + 1;
}
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
if (strcmp(mReader->getNodeName(), "targets") == 0)
break;
else
ThrowException("Expected end of <targets> element.");
}
}
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "controller") == 0)
break;
else if (strcmp(mReader->getNodeName(), "skin") != 0 && strcmp(mReader->getNodeName(), "morph") != 0)
ThrowException("Expected end of <controller> element.");
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads the joint definitions for the given controller
void ColladaParser::ReadControllerJoints(Collada::Controller& pController)
{
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
// Input channels for joint data. Two possible semantics: "JOINT" and "INV_BIND_MATRIX"
if (IsElement("input"))
{
int indexSemantic = GetAttribute("semantic");
const char* attrSemantic = mReader->getAttributeValue(indexSemantic);
int indexSource = GetAttribute("source");
const char* attrSource = mReader->getAttributeValue(indexSource);
// local URLS always start with a '#'. We don't support global URLs
if (attrSource[0] != '#')
ThrowException(format() << "Unsupported URL format in \"" << attrSource << "\" in source attribute of <joints> data <input> element");
attrSource++;
// parse source URL to corresponding source
if (strcmp(attrSemantic, "JOINT") == 0)
pController.mJointNameSource = attrSource;
else if (strcmp(attrSemantic, "INV_BIND_MATRIX") == 0)
pController.mJointOffsetMatrixSource = attrSource;
else
ThrowException(format() << "Unknown semantic \"" << attrSemantic << "\" in <joints> data <input> element");
// skip inner data, if present
if (!mReader->isEmptyElement())
SkipElement();
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "joints") != 0)
ThrowException("Expected end of <joints> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads the joint weights for the given controller
void ColladaParser::ReadControllerWeights(Collada::Controller& pController)
{
// read vertex count from attributes and resize the array accordingly
int indexCount = GetAttribute("count");
size_t vertexCount = (size_t)mReader->getAttributeValueAsInt(indexCount);
pController.mWeightCounts.resize(vertexCount);
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
// Input channels for weight data. Two possible semantics: "JOINT" and "WEIGHT"
if (IsElement("input") && vertexCount > 0)
{
InputChannel channel;
int indexSemantic = GetAttribute("semantic");
const char* attrSemantic = mReader->getAttributeValue(indexSemantic);
int indexSource = GetAttribute("source");
const char* attrSource = mReader->getAttributeValue(indexSource);
int indexOffset = TestAttribute("offset");
if (indexOffset >= 0)
channel.mOffset = mReader->getAttributeValueAsInt(indexOffset);
// local URLS always start with a '#'. We don't support global URLs
if (attrSource[0] != '#')
ThrowException(format() << "Unsupported URL format in \"" << attrSource << "\" in source attribute of <vertex_weights> data <input> element");
channel.mAccessor = attrSource + 1;
// parse source URL to corresponding source
if (strcmp(attrSemantic, "JOINT") == 0)
pController.mWeightInputJoints = channel;
else if (strcmp(attrSemantic, "WEIGHT") == 0)
pController.mWeightInputWeights = channel;
else
ThrowException(format() << "Unknown semantic \"" << attrSemantic << "\" in <vertex_weights> data <input> element");
// skip inner data, if present
if (!mReader->isEmptyElement())
SkipElement();
}
else if (IsElement("vcount") && vertexCount > 0)
{
// read weight count per vertex
const char* text = GetTextContent();
size_t numWeights = 0;
for (std::vector<size_t>::iterator it = pController.mWeightCounts.begin(); it != pController.mWeightCounts.end(); ++it)
{
if (*text == 0)
ThrowException("Out of data while reading <vcount>");
*it = strtoul10(text, &text);
numWeights += *it;
SkipSpacesAndLineEnd(&text);
}
TestClosing("vcount");
// reserve weight count
pController.mWeights.resize(numWeights);
}
else if (IsElement("v") && vertexCount > 0)
{
// read JointIndex - WeightIndex pairs
const char* text = GetTextContent();
for (std::vector< std::pair<size_t, size_t> >::iterator it = pController.mWeights.begin(); it != pController.mWeights.end(); ++it)
{
if (*text == 0)
ThrowException("Out of data while reading <vertex_weights>");
it->first = strtoul10(text, &text);
SkipSpacesAndLineEnd(&text);
if (*text == 0)
ThrowException("Out of data while reading <vertex_weights>");
it->second = strtoul10(text, &text);
SkipSpacesAndLineEnd(&text);
}
TestClosing("v");
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "vertex_weights") != 0)
ThrowException("Expected end of <vertex_weights> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads the image library contents
void ColladaParser::ReadImageLibrary()
{
if (mReader->isEmptyElement())
return;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
if (IsElement("image"))
{
// read ID. Another entry which is "optional" by design but obligatory in reality
int attrID = GetAttribute("id");
std::string id = mReader->getAttributeValue(attrID);
// create an entry and store it in the library under its ID
mImageLibrary[id] = Image();
// read on from there
ReadImage(mImageLibrary[id]);
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
if (strcmp(mReader->getNodeName(), "library_images") != 0)
ThrowException("Expected end of <library_images> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads an image entry into the given image
void ColladaParser::ReadImage(Collada::Image& pImage)
{
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
// Need to run different code paths here, depending on the Collada XSD version
if (IsElement("image")) {
SkipElement();
}
else if (IsElement("init_from"))
{
if (mFormat == FV_1_4_n)
{
// FIX: C4D exporter writes empty <init_from/> tags
if (!mReader->isEmptyElement()) {
// element content is filename - hopefully
const char* sz = TestTextContent();
if (sz)
{
aiString filepath(sz);
UriDecodePath(filepath);
pImage.mFileName = filepath.C_Str();
}
TestClosing("init_from");
}
if (!pImage.mFileName.length()) {
pImage.mFileName = "unknown_texture";
}
}
else if (mFormat == FV_1_5_n)
{
// make sure we skip over mip and array initializations, which
// we don't support, but which could confuse the loader if
// they're not skipped.
int attrib = TestAttribute("array_index");
if (attrib != -1 && mReader->getAttributeValueAsInt(attrib) > 0) {
ASSIMP_LOG_WARN("Collada: Ignoring texture array index");
continue;
}
attrib = TestAttribute("mip_index");
if (attrib != -1 && mReader->getAttributeValueAsInt(attrib) > 0) {
ASSIMP_LOG_WARN("Collada: Ignoring MIP map layer");
continue;
}
// TODO: correctly jump over cube and volume maps?
}
}
else if (mFormat == FV_1_5_n)
{
if (IsElement("ref"))
{
// element content is filename - hopefully
const char* sz = TestTextContent();
if (sz)
{
aiString filepath(sz);
UriDecodePath(filepath);
pImage.mFileName = filepath.C_Str();
}
TestClosing("ref");
}
else if (IsElement("hex") && !pImage.mFileName.length())
{
// embedded image. get format
const int attrib = TestAttribute("format");
if (-1 == attrib)
ASSIMP_LOG_WARN("Collada: Unknown image file format");
else pImage.mEmbeddedFormat = mReader->getAttributeValue(attrib);
const char* data = GetTextContent();
// hexadecimal-encoded binary octets. First of all, find the
// required buffer size to reserve enough storage.
const char* cur = data;
while (!IsSpaceOrNewLine(*cur)) cur++;
const unsigned int size = (unsigned int)(cur - data) * 2;
pImage.mImageData.resize(size);
for (unsigned int i = 0; i < size; ++i)
pImage.mImageData[i] = HexOctetToDecimal(data + (i << 1));
TestClosing("hex");
}
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
if (strcmp(mReader->getNodeName(), "image") == 0)
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads the material library
void ColladaParser::ReadMaterialLibrary()
{
if (mReader->isEmptyElement())
return;
std::map<std::string, int> names;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("material"))
{
// read ID. By now you probably know my opinion about this "specification"
int attrID = GetAttribute("id");
std::string id = mReader->getAttributeValue(attrID);
std::string name;
int attrName = TestAttribute("name");
if (attrName >= 0)
name = mReader->getAttributeValue(attrName);
// create an entry and store it in the library under its ID
mMaterialLibrary[id] = Material();
if (!name.empty())
{
std::map<std::string, int>::iterator it = names.find(name);
if (it != names.end())
{
std::ostringstream strStream;
strStream << ++it->second;
name.append(" " + strStream.str());
}
else
{
names[name] = 0;
}
mMaterialLibrary[id].mName = name;
}
ReadMaterial(mMaterialLibrary[id]);
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "library_materials") != 0)
ThrowException("Expected end of <library_materials> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads the light library
void ColladaParser::ReadLightLibrary()
{
if (mReader->isEmptyElement())
return;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
if (IsElement("light"))
{
// read ID. By now you probably know my opinion about this "specification"
int attrID = GetAttribute("id");
std::string id = mReader->getAttributeValue(attrID);
// create an entry and store it in the library under its ID
ReadLight(mLightLibrary[id] = Light());
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
if (strcmp(mReader->getNodeName(), "library_lights") != 0)
ThrowException("Expected end of <library_lights> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads the camera library
void ColladaParser::ReadCameraLibrary()
{
if (mReader->isEmptyElement())
return;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
if (IsElement("camera"))
{
// read ID. By now you probably know my opinion about this "specification"
int attrID = GetAttribute("id");
std::string id = mReader->getAttributeValue(attrID);
// create an entry and store it in the library under its ID
Camera& cam = mCameraLibrary[id];
attrID = TestAttribute("name");
if (attrID != -1)
cam.mName = mReader->getAttributeValue(attrID);
ReadCamera(cam);
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
if (strcmp(mReader->getNodeName(), "library_cameras") != 0)
ThrowException("Expected end of <library_cameras> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads a material entry into the given material
void ColladaParser::ReadMaterial(Collada::Material& pMaterial)
{
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
if (IsElement("material")) {
SkipElement();
}
else if (IsElement("instance_effect"))
{
// referred effect by URL
int attrUrl = GetAttribute("url");
const char* url = mReader->getAttributeValue(attrUrl);
if (url[0] != '#')
ThrowException("Unknown reference format");
pMaterial.mEffect = url + 1;
SkipElement();
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
if (strcmp(mReader->getNodeName(), "material") != 0)
ThrowException("Expected end of <material> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads a light entry into the given light
void ColladaParser::ReadLight(Collada::Light& pLight)
{
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
if (IsElement("light")) {
SkipElement();
}
else if (IsElement("spot")) {
pLight.mType = aiLightSource_SPOT;
}
else if (IsElement("ambient")) {
pLight.mType = aiLightSource_AMBIENT;
}
else if (IsElement("directional")) {
pLight.mType = aiLightSource_DIRECTIONAL;
}
else if (IsElement("point")) {
pLight.mType = aiLightSource_POINT;
}
else if (IsElement("color")) {
// text content contains 3 floats
const char* content = GetTextContent();
content = fast_atoreal_move<ai_real>(content, (ai_real&)pLight.mColor.r);
SkipSpacesAndLineEnd(&content);
content = fast_atoreal_move<ai_real>(content, (ai_real&)pLight.mColor.g);
SkipSpacesAndLineEnd(&content);
content = fast_atoreal_move<ai_real>(content, (ai_real&)pLight.mColor.b);
SkipSpacesAndLineEnd(&content);
TestClosing("color");
}
else if (IsElement("constant_attenuation")) {
pLight.mAttConstant = ReadFloatFromTextContent();
TestClosing("constant_attenuation");
}
else if (IsElement("linear_attenuation")) {
pLight.mAttLinear = ReadFloatFromTextContent();
TestClosing("linear_attenuation");
}
else if (IsElement("quadratic_attenuation")) {
pLight.mAttQuadratic = ReadFloatFromTextContent();
TestClosing("quadratic_attenuation");
}
else if (IsElement("falloff_angle")) {
pLight.mFalloffAngle = ReadFloatFromTextContent();
TestClosing("falloff_angle");
}
else if (IsElement("falloff_exponent")) {
pLight.mFalloffExponent = ReadFloatFromTextContent();
TestClosing("falloff_exponent");
}
// FCOLLADA extensions
// -------------------------------------------------------
else if (IsElement("outer_cone")) {
pLight.mOuterAngle = ReadFloatFromTextContent();
TestClosing("outer_cone");
}
// ... and this one is even deprecated
else if (IsElement("penumbra_angle")) {
pLight.mPenumbraAngle = ReadFloatFromTextContent();
TestClosing("penumbra_angle");
}
else if (IsElement("intensity")) {
pLight.mIntensity = ReadFloatFromTextContent();
TestClosing("intensity");
}
else if (IsElement("falloff")) {
pLight.mOuterAngle = ReadFloatFromTextContent();
TestClosing("falloff");
}
else if (IsElement("hotspot_beam")) {
pLight.mFalloffAngle = ReadFloatFromTextContent();
TestClosing("hotspot_beam");
}
// OpenCOLLADA extensions
// -------------------------------------------------------
else if (IsElement("decay_falloff")) {
pLight.mOuterAngle = ReadFloatFromTextContent();
TestClosing("decay_falloff");
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
if (strcmp(mReader->getNodeName(), "light") == 0)
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads a camera entry into the given light
void ColladaParser::ReadCamera(Collada::Camera& pCamera)
{
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
if (IsElement("camera")) {
SkipElement();
}
else if (IsElement("orthographic")) {
pCamera.mOrtho = true;
}
else if (IsElement("xfov") || IsElement("xmag")) {
pCamera.mHorFov = ReadFloatFromTextContent();
TestClosing((pCamera.mOrtho ? "xmag" : "xfov"));
}
else if (IsElement("yfov") || IsElement("ymag")) {
pCamera.mVerFov = ReadFloatFromTextContent();
TestClosing((pCamera.mOrtho ? "ymag" : "yfov"));
}
else if (IsElement("aspect_ratio")) {
pCamera.mAspect = ReadFloatFromTextContent();
TestClosing("aspect_ratio");
}
else if (IsElement("znear")) {
pCamera.mZNear = ReadFloatFromTextContent();
TestClosing("znear");
}
else if (IsElement("zfar")) {
pCamera.mZFar = ReadFloatFromTextContent();
TestClosing("zfar");
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
if (strcmp(mReader->getNodeName(), "camera") == 0)
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads the effect library
void ColladaParser::ReadEffectLibrary()
{
if (mReader->isEmptyElement()) {
return;
}
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
if (IsElement("effect"))
{
// read ID. Do I have to repeat my ranting about "optional" attributes?
int attrID = GetAttribute("id");
std::string id = mReader->getAttributeValue(attrID);
// create an entry and store it in the library under its ID
mEffectLibrary[id] = Effect();
// read on from there
ReadEffect(mEffectLibrary[id]);
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
if (strcmp(mReader->getNodeName(), "library_effects") != 0)
ThrowException("Expected end of <library_effects> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads an effect entry into the given effect
void ColladaParser::ReadEffect(Collada::Effect& pEffect)
{
// for the moment we don't support any other type of effect.
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("profile_COMMON"))
ReadEffectProfileCommon(pEffect);
else
SkipElement();
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "effect") != 0)
ThrowException("Expected end of <effect> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads an COMMON effect profile
void ColladaParser::ReadEffectProfileCommon(Collada::Effect& pEffect)
{
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("newparam")) {
// save ID
int attrSID = GetAttribute("sid");
std::string sid = mReader->getAttributeValue(attrSID);
pEffect.mParams[sid] = EffectParam();
ReadEffectParam(pEffect.mParams[sid]);
}
else if (IsElement("technique") || IsElement("extra"))
{
// just syntactic sugar
}
else if (mFormat == FV_1_4_n && IsElement("image"))
{
// read ID. Another entry which is "optional" by design but obligatory in reality
int attrID = GetAttribute("id");
std::string id = mReader->getAttributeValue(attrID);
// create an entry and store it in the library under its ID
mImageLibrary[id] = Image();
// read on from there
ReadImage(mImageLibrary[id]);
}
/* Shading modes */
else if (IsElement("phong"))
pEffect.mShadeType = Shade_Phong;
else if (IsElement("constant"))
pEffect.mShadeType = Shade_Constant;
else if (IsElement("lambert"))
pEffect.mShadeType = Shade_Lambert;
else if (IsElement("blinn"))
pEffect.mShadeType = Shade_Blinn;
/* Color + texture properties */
else if (IsElement("emission"))
ReadEffectColor(pEffect.mEmissive, pEffect.mTexEmissive);
else if (IsElement("ambient"))
ReadEffectColor(pEffect.mAmbient, pEffect.mTexAmbient);
else if (IsElement("diffuse"))
ReadEffectColor(pEffect.mDiffuse, pEffect.mTexDiffuse);
else if (IsElement("specular"))
ReadEffectColor(pEffect.mSpecular, pEffect.mTexSpecular);
else if (IsElement("reflective")) {
ReadEffectColor(pEffect.mReflective, pEffect.mTexReflective);
}
else if (IsElement("transparent")) {
pEffect.mHasTransparency = true;
const char* opaque = mReader->getAttributeValueSafe("opaque");
if (::strcmp(opaque, "RGB_ZERO") == 0 || ::strcmp(opaque, "RGB_ONE") == 0) {
pEffect.mRGBTransparency = true;
}
// In RGB_ZERO mode, the transparency is interpreted in reverse, go figure...
if (::strcmp(opaque, "RGB_ZERO") == 0 || ::strcmp(opaque, "A_ZERO") == 0) {
pEffect.mInvertTransparency = true;
}
ReadEffectColor(pEffect.mTransparent, pEffect.mTexTransparent);
}
else if (IsElement("shininess"))
ReadEffectFloat(pEffect.mShininess);
else if (IsElement("reflectivity"))
ReadEffectFloat(pEffect.mReflectivity);
/* Single scalar properties */
else if (IsElement("transparency"))
ReadEffectFloat(pEffect.mTransparency);
else if (IsElement("index_of_refraction"))
ReadEffectFloat(pEffect.mRefractIndex);
// GOOGLEEARTH/OKINO extensions
// -------------------------------------------------------
else if (IsElement("double_sided"))
pEffect.mDoubleSided = ReadBoolFromTextContent();
// FCOLLADA extensions
// -------------------------------------------------------
else if (IsElement("bump")) {
aiColor4D dummy;
ReadEffectColor(dummy, pEffect.mTexBump);
}
// MAX3D extensions
// -------------------------------------------------------
else if (IsElement("wireframe")) {
pEffect.mWireframe = ReadBoolFromTextContent();
TestClosing("wireframe");
}
else if (IsElement("faceted")) {
pEffect.mFaceted = ReadBoolFromTextContent();
TestClosing("faceted");
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
if (strcmp(mReader->getNodeName(), "profile_COMMON") == 0)
{
break;
}
}
}
}
// ------------------------------------------------------------------------------------------------
// Read texture wrapping + UV transform settings from a profile==Maya chunk
void ColladaParser::ReadSamplerProperties(Sampler& out)
{
if (mReader->isEmptyElement()) {
return;
}
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
// MAYA extensions
// -------------------------------------------------------
if (IsElement("wrapU")) {
out.mWrapU = ReadBoolFromTextContent();
TestClosing("wrapU");
}
else if (IsElement("wrapV")) {
out.mWrapV = ReadBoolFromTextContent();
TestClosing("wrapV");
}
else if (IsElement("mirrorU")) {
out.mMirrorU = ReadBoolFromTextContent();
TestClosing("mirrorU");
}
else if (IsElement("mirrorV")) {
out.mMirrorV = ReadBoolFromTextContent();
TestClosing("mirrorV");
}
else if (IsElement("repeatU")) {
out.mTransform.mScaling.x = ReadFloatFromTextContent();
TestClosing("repeatU");
}
else if (IsElement("repeatV")) {
out.mTransform.mScaling.y = ReadFloatFromTextContent();
TestClosing("repeatV");
}
else if (IsElement("offsetU")) {
out.mTransform.mTranslation.x = ReadFloatFromTextContent();
TestClosing("offsetU");
}
else if (IsElement("offsetV")) {
out.mTransform.mTranslation.y = ReadFloatFromTextContent();
TestClosing("offsetV");
}
else if (IsElement("rotateUV")) {
out.mTransform.mRotation = ReadFloatFromTextContent();
TestClosing("rotateUV");
}
else if (IsElement("blend_mode")) {
const char* sz = GetTextContent();
// http://www.feelingsoftware.com/content/view/55/72/lang,en/
// NONE, OVER, IN, OUT, ADD, SUBTRACT, MULTIPLY, DIFFERENCE, LIGHTEN, DARKEN, SATURATE, DESATURATE and ILLUMINATE
if (0 == ASSIMP_strincmp(sz, "ADD", 3))
out.mOp = aiTextureOp_Add;
else if (0 == ASSIMP_strincmp(sz, "SUBTRACT", 8))
out.mOp = aiTextureOp_Subtract;
else if (0 == ASSIMP_strincmp(sz, "MULTIPLY", 8))
out.mOp = aiTextureOp_Multiply;
else {
ASSIMP_LOG_WARN("Collada: Unsupported MAYA texture blend mode");
}
TestClosing("blend_mode");
}
// OKINO extensions
// -------------------------------------------------------
else if (IsElement("weighting")) {
out.mWeighting = ReadFloatFromTextContent();
TestClosing("weighting");
}
else if (IsElement("mix_with_previous_layer")) {
out.mMixWithPrevious = ReadFloatFromTextContent();
TestClosing("mix_with_previous_layer");
}
// MAX3D extensions
// -------------------------------------------------------
else if (IsElement("amount")) {
out.mWeighting = ReadFloatFromTextContent();
TestClosing("amount");
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
if (strcmp(mReader->getNodeName(), "technique") == 0)
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads an effect entry containing a color or a texture defining that color
void ColladaParser::ReadEffectColor(aiColor4D& pColor, Sampler& pSampler)
{
if (mReader->isEmptyElement())
return;
// Save current element name
const std::string curElem = mReader->getNodeName();
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
if (IsElement("color"))
{
// text content contains 4 floats
const char* content = GetTextContent();
content = fast_atoreal_move<ai_real>(content, (ai_real&)pColor.r);
SkipSpacesAndLineEnd(&content);
content = fast_atoreal_move<ai_real>(content, (ai_real&)pColor.g);
SkipSpacesAndLineEnd(&content);
content = fast_atoreal_move<ai_real>(content, (ai_real&)pColor.b);
SkipSpacesAndLineEnd(&content);
content = fast_atoreal_move<ai_real>(content, (ai_real&)pColor.a);
SkipSpacesAndLineEnd(&content);
TestClosing("color");
}
else if (IsElement("texture"))
{
// get name of source texture/sampler
int attrTex = GetAttribute("texture");
pSampler.mName = mReader->getAttributeValue(attrTex);
// get name of UV source channel. Specification demands it to be there, but some exporters
// don't write it. It will be the default UV channel in case it's missing.
attrTex = TestAttribute("texcoord");
if (attrTex >= 0)
pSampler.mUVChannel = mReader->getAttributeValue(attrTex);
//SkipElement();
// as we've read texture, the color needs to be 1,1,1,1
pColor = aiColor4D(1.f, 1.f, 1.f, 1.f);
}
else if (IsElement("technique"))
{
const int _profile = GetAttribute("profile");
const char* profile = mReader->getAttributeValue(_profile);
// Some extensions are quite useful ... ReadSamplerProperties processes
// several extensions in MAYA, OKINO and MAX3D profiles.
if (!::strcmp(profile, "MAYA") || !::strcmp(profile, "MAX3D") || !::strcmp(profile, "OKINO"))
{
// get more information on this sampler
ReadSamplerProperties(pSampler);
}
else SkipElement();
}
else if (!IsElement("extra"))
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
if (mReader->getNodeName() == curElem)
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads an effect entry containing a float
void ColladaParser::ReadEffectFloat(ai_real& pFloat)
{
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
if (IsElement("float"))
{
// text content contains a single floats
const char* content = GetTextContent();
content = fast_atoreal_move<ai_real>(content, pFloat);
SkipSpacesAndLineEnd(&content);
TestClosing("float");
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads an effect parameter specification of any kind
void ColladaParser::ReadEffectParam(Collada::EffectParam& pParam)
{
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
if (IsElement("surface"))
{
// image ID given inside <init_from> tags
TestOpening("init_from");
const char* content = GetTextContent();
pParam.mType = Param_Surface;
pParam.mReference = content;
TestClosing("init_from");
// don't care for remaining stuff
SkipElement("surface");
}
else if (IsElement("sampler2D") && (FV_1_4_n == mFormat || FV_1_3_n == mFormat))
{
// surface ID is given inside <source> tags
TestOpening("source");
const char* content = GetTextContent();
pParam.mType = Param_Sampler;
pParam.mReference = content;
TestClosing("source");
// don't care for remaining stuff
SkipElement("sampler2D");
}
else if (IsElement("sampler2D"))
{
// surface ID is given inside <instance_image> tags
TestOpening("instance_image");
int attrURL = GetAttribute("url");
const char* url = mReader->getAttributeValue(attrURL);
if (url[0] != '#')
ThrowException("Unsupported URL format in instance_image");
url++;
pParam.mType = Param_Sampler;
pParam.mReference = url;
SkipElement("sampler2D");
}
else
{
// ignore unknown element
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads the geometry library contents
void ColladaParser::ReadGeometryLibrary()
{
if (mReader->isEmptyElement())
return;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("geometry"))
{
// read ID. Another entry which is "optional" by design but obligatory in reality
int indexID = GetAttribute("id");
std::string id = mReader->getAttributeValue(indexID);
// TODO: (thom) support SIDs
// ai_assert( TestAttribute( "sid") == -1);
// create a mesh and store it in the library under its ID
Mesh* mesh = new Mesh;
mMeshLibrary[id] = mesh;
// read the mesh name if it exists
const int nameIndex = TestAttribute("name");
if (nameIndex != -1)
{
mesh->mName = mReader->getAttributeValue(nameIndex);
}
// read on from there
ReadGeometry(mesh);
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "library_geometries") != 0)
ThrowException("Expected end of <library_geometries> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads a geometry from the geometry library.
void ColladaParser::ReadGeometry(Collada::Mesh* pMesh)
{
if (mReader->isEmptyElement())
return;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("mesh"))
{
// read on from there
ReadMesh(pMesh);
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "geometry") != 0)
ThrowException("Expected end of <geometry> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads a mesh from the geometry library
void ColladaParser::ReadMesh(Mesh* pMesh)
{
if (mReader->isEmptyElement())
return;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("source"))
{
// we have professionals dealing with this
ReadSource();
}
else if (IsElement("vertices"))
{
// read per-vertex mesh data
ReadVertexData(pMesh);
}
else if (IsElement("triangles") || IsElement("lines") || IsElement("linestrips")
|| IsElement("polygons") || IsElement("polylist") || IsElement("trifans") || IsElement("tristrips"))
{
// read per-index mesh data and faces setup
ReadIndexData(pMesh);
}
else
{
// ignore the restf
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "technique_common") == 0)
{
// end of another meaningless element - read over it
}
else if (strcmp(mReader->getNodeName(), "mesh") == 0)
{
// end of <mesh> element - we're done here
break;
}
else
{
// everything else should be punished
ThrowException("Expected end of <mesh> element.");
}
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads a source element
void ColladaParser::ReadSource()
{
int indexID = GetAttribute("id");
std::string sourceID = mReader->getAttributeValue(indexID);
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("float_array") || IsElement("IDREF_array") || IsElement("Name_array"))
{
ReadDataArray();
}
else if (IsElement("technique_common"))
{
// I don't care for your profiles
}
else if (IsElement("accessor"))
{
ReadAccessor(sourceID);
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "source") == 0)
{
// end of <source> - we're done
break;
}
else if (strcmp(mReader->getNodeName(), "technique_common") == 0)
{
// end of another meaningless element - read over it
}
else
{
// everything else should be punished
ThrowException("Expected end of <source> element.");
}
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads a data array holding a number of floats, and stores it in the global library
void ColladaParser::ReadDataArray()
{
std::string elmName = mReader->getNodeName();
bool isStringArray = (elmName == "IDREF_array" || elmName == "Name_array");
bool isEmptyElement = mReader->isEmptyElement();
// read attributes
int indexID = GetAttribute("id");
std::string id = mReader->getAttributeValue(indexID);
int indexCount = GetAttribute("count");
unsigned int count = (unsigned int)mReader->getAttributeValueAsInt(indexCount);
const char* content = TestTextContent();
// read values and store inside an array in the data library
mDataLibrary[id] = Data();
Data& data = mDataLibrary[id];
data.mIsStringArray = isStringArray;
// some exporters write empty data arrays, but we need to conserve them anyways because others might reference them
if (content)
{
if (isStringArray)
{
data.mStrings.reserve(count);
std::string s;
for (unsigned int a = 0; a < count; a++)
{
if (*content == 0)
ThrowException("Expected more values while reading IDREF_array contents.");
s.clear();
while (!IsSpaceOrNewLine(*content))
s += *content++;
data.mStrings.push_back(s);
SkipSpacesAndLineEnd(&content);
}
}
else
{
data.mValues.reserve(count);
for (unsigned int a = 0; a < count; a++)
{
if (*content == 0)
ThrowException("Expected more values while reading float_array contents.");
ai_real value;
// read a number
content = fast_atoreal_move<ai_real>(content, value);
data.mValues.push_back(value);
// skip whitespace after it
SkipSpacesAndLineEnd(&content);
}
}
}
// test for closing tag
if (!isEmptyElement)
TestClosing(elmName.c_str());
}
// ------------------------------------------------------------------------------------------------
// Reads an accessor and stores it in the global library
void ColladaParser::ReadAccessor(const std::string& pID)
{
// read accessor attributes
int attrSource = GetAttribute("source");
const char* source = mReader->getAttributeValue(attrSource);
if (source[0] != '#')
ThrowException(format() << "Unknown reference format in url \"" << source << "\" in source attribute of <accessor> element.");
int attrCount = GetAttribute("count");
unsigned int count = (unsigned int)mReader->getAttributeValueAsInt(attrCount);
int attrOffset = TestAttribute("offset");
unsigned int offset = 0;
if (attrOffset > -1)
offset = (unsigned int)mReader->getAttributeValueAsInt(attrOffset);
int attrStride = TestAttribute("stride");
unsigned int stride = 1;
if (attrStride > -1)
stride = (unsigned int)mReader->getAttributeValueAsInt(attrStride);
// store in the library under the given ID
mAccessorLibrary[pID] = Accessor();
Accessor& acc = mAccessorLibrary[pID];
acc.mCount = count;
acc.mOffset = offset;
acc.mStride = stride;
acc.mSource = source + 1; // ignore the leading '#'
acc.mSize = 0; // gets incremented with every param
// and read the components
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("param"))
{
// read data param
int attrName = TestAttribute("name");
std::string name;
if (attrName > -1)
{
name = mReader->getAttributeValue(attrName);
// analyse for common type components and store it's sub-offset in the corresponding field
/* Cartesian coordinates */
if (name == "X") acc.mSubOffset[0] = acc.mParams.size();
else if (name == "Y") acc.mSubOffset[1] = acc.mParams.size();
else if (name == "Z") acc.mSubOffset[2] = acc.mParams.size();
/* RGBA colors */
else if (name == "R") acc.mSubOffset[0] = acc.mParams.size();
else if (name == "G") acc.mSubOffset[1] = acc.mParams.size();
else if (name == "B") acc.mSubOffset[2] = acc.mParams.size();
else if (name == "A") acc.mSubOffset[3] = acc.mParams.size();
/* UVWQ (STPQ) texture coordinates */
else if (name == "S") acc.mSubOffset[0] = acc.mParams.size();
else if (name == "T") acc.mSubOffset[1] = acc.mParams.size();
else if (name == "P") acc.mSubOffset[2] = acc.mParams.size();
// else if( name == "Q") acc.mSubOffset[3] = acc.mParams.size();
/* 4D uv coordinates are not supported in Assimp */
/* Generic extra data, interpreted as UV data, too*/
else if (name == "U") acc.mSubOffset[0] = acc.mParams.size();
else if (name == "V") acc.mSubOffset[1] = acc.mParams.size();
//else
// DefaultLogger::get()->warn( format() << "Unknown accessor parameter \"" << name << "\". Ignoring data channel." );
}
// read data type
int attrType = TestAttribute("type");
if (attrType > -1)
{
// for the moment we only distinguish between a 4x4 matrix and anything else.
// TODO: (thom) I don't have a spec here at work. Check if there are other multi-value types
// which should be tested for here.
std::string type = mReader->getAttributeValue(attrType);
if (type == "float4x4")
acc.mSize += 16;
else
acc.mSize += 1;
}
acc.mParams.push_back(name);
// skip remaining stuff of this element, if any
SkipElement();
}
else
{
ThrowException(format() << "Unexpected sub element <" << mReader->getNodeName() << "> in tag <accessor>");
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "accessor") != 0)
ThrowException("Expected end of <accessor> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads input declarations of per-vertex mesh data into the given mesh
void ColladaParser::ReadVertexData(Mesh* pMesh)
{
// extract the ID of the <vertices> element. Not that we care, but to catch strange referencing schemes we should warn about
int attrID = GetAttribute("id");
pMesh->mVertexID = mReader->getAttributeValue(attrID);
// a number of <input> elements
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("input"))
{
ReadInputChannel(pMesh->mPerVertexData);
}
else
{
ThrowException(format() << "Unexpected sub element <" << mReader->getNodeName() << "> in tag <vertices>");
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "vertices") != 0)
ThrowException("Expected end of <vertices> element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads input declarations of per-index mesh data into the given mesh
void ColladaParser::ReadIndexData(Mesh* pMesh)
{
std::vector<size_t> vcount;
std::vector<InputChannel> perIndexData;
// read primitive count from the attribute
int attrCount = GetAttribute("count");
size_t numPrimitives = (size_t)mReader->getAttributeValueAsInt(attrCount);
// some mesh types (e.g. tristrips) don't specify primitive count upfront,
// so we need to sum up the actual number of primitives while we read the <p>-tags
size_t actualPrimitives = 0;
// material subgroup
int attrMaterial = TestAttribute("material");
SubMesh subgroup;
if (attrMaterial > -1)
subgroup.mMaterial = mReader->getAttributeValue(attrMaterial);
// distinguish between polys and triangles
std::string elementName = mReader->getNodeName();
PrimitiveType primType = Prim_Invalid;
if (IsElement("lines"))
primType = Prim_Lines;
else if (IsElement("linestrips"))
primType = Prim_LineStrip;
else if (IsElement("polygons"))
primType = Prim_Polygon;
else if (IsElement("polylist"))
primType = Prim_Polylist;
else if (IsElement("triangles"))
primType = Prim_Triangles;
else if (IsElement("trifans"))
primType = Prim_TriFans;
else if (IsElement("tristrips"))
primType = Prim_TriStrips;
ai_assert(primType != Prim_Invalid);
// also a number of <input> elements, but in addition a <p> primitive collection and probably index counts for all primitives
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("input"))
{
ReadInputChannel(perIndexData);
}
else if (IsElement("vcount"))
{
if (!mReader->isEmptyElement())
{
if (numPrimitives) // It is possible to define a mesh without any primitives
{
// case <polylist> - specifies the number of indices for each polygon
const char* content = GetTextContent();
vcount.reserve(numPrimitives);
for (unsigned int a = 0; a < numPrimitives; a++)
{
if (*content == 0)
ThrowException("Expected more values while reading <vcount> contents.");
// read a number
vcount.push_back((size_t)strtoul10(content, &content));
// skip whitespace after it
SkipSpacesAndLineEnd(&content);
}
}
TestClosing("vcount");
}
}
else if (IsElement("p"))
{
if (!mReader->isEmptyElement())
{
// now here the actual fun starts - these are the indices to construct the mesh data from
actualPrimitives += ReadPrimitives(pMesh, perIndexData, numPrimitives, vcount, primType);
}
}
else if (IsElement("extra"))
{
SkipElement("extra");
}
else if (IsElement("ph")) {
SkipElement("ph");
}
else {
ThrowException(format() << "Unexpected sub element <" << mReader->getNodeName() << "> in tag <" << elementName << ">");
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (mReader->getNodeName() != elementName)
ThrowException(format() << "Expected end of <" << elementName << "> element.");
break;
}
}
#ifdef ASSIMP_BUILD_DEBUG
if (primType != Prim_TriFans && primType != Prim_TriStrips && primType != Prim_LineStrip &&
primType != Prim_Lines) { // this is ONLY to workaround a bug in SketchUp 15.3.331 where it writes the wrong 'count' when it writes out the 'lines'.
ai_assert(actualPrimitives == numPrimitives);
}
#endif
// only when we're done reading all <p> tags (and thus know the final vertex count) can we commit the submesh
subgroup.mNumFaces = actualPrimitives;
pMesh->mSubMeshes.push_back(subgroup);
}
// ------------------------------------------------------------------------------------------------
// Reads a single input channel element and stores it in the given array, if valid
void ColladaParser::ReadInputChannel(std::vector<InputChannel>& poChannels)
{
InputChannel channel;
// read semantic
int attrSemantic = GetAttribute("semantic");
std::string semantic = mReader->getAttributeValue(attrSemantic);
channel.mType = GetTypeForSemantic(semantic);
// read source
int attrSource = GetAttribute("source");
const char* source = mReader->getAttributeValue(attrSource);
if (source[0] != '#')
ThrowException(format() << "Unknown reference format in url \"" << source << "\" in source attribute of <input> element.");
channel.mAccessor = source + 1; // skipping the leading #, hopefully the remaining text is the accessor ID only
// read index offset, if per-index <input>
int attrOffset = TestAttribute("offset");
if (attrOffset > -1)
channel.mOffset = mReader->getAttributeValueAsInt(attrOffset);
// read set if texture coordinates
if (channel.mType == IT_Texcoord || channel.mType == IT_Color) {
int attrSet = TestAttribute("set");
if (attrSet > -1) {
attrSet = mReader->getAttributeValueAsInt(attrSet);
if (attrSet < 0)
ThrowException(format() << "Invalid index \"" << (attrSet) << "\" in set attribute of <input> element");
channel.mIndex = attrSet;
}
}
// store, if valid type
if (channel.mType != IT_Invalid)
poChannels.push_back(channel);
// skip remaining stuff of this element, if any
SkipElement();
}
// ------------------------------------------------------------------------------------------------
// Reads a <p> primitive index list and assembles the mesh data into the given mesh
size_t ColladaParser::ReadPrimitives(Mesh* pMesh, std::vector<InputChannel>& pPerIndexChannels,
size_t pNumPrimitives, const std::vector<size_t>& pVCount, PrimitiveType pPrimType)
{
// determine number of indices coming per vertex
// find the offset index for all per-vertex channels
size_t numOffsets = 1;
size_t perVertexOffset = SIZE_MAX; // invalid value
for (const InputChannel& channel : pPerIndexChannels)
{
numOffsets = std::max(numOffsets, channel.mOffset + 1);
if (channel.mType == IT_Vertex)
perVertexOffset = channel.mOffset;
}
// determine the expected number of indices
size_t expectedPointCount = 0;
switch (pPrimType)
{
case Prim_Polylist:
{
for (size_t i : pVCount)
expectedPointCount += i;
break;
}
case Prim_Lines:
expectedPointCount = 2 * pNumPrimitives;
break;
case Prim_Triangles:
expectedPointCount = 3 * pNumPrimitives;
break;
default:
// other primitive types don't state the index count upfront... we need to guess
break;
}
// and read all indices into a temporary array
std::vector<size_t> indices;
if (expectedPointCount > 0)
indices.reserve(expectedPointCount * numOffsets);
if (pNumPrimitives > 0) // It is possible to not contain any indices
{
const char* content = GetTextContent();
while (*content != 0)
{
// read a value.
// Hack: (thom) Some exporters put negative indices sometimes. We just try to carry on anyways.
int value = std::max(0, strtol10(content, &content));
indices.push_back(size_t(value));
// skip whitespace after it
SkipSpacesAndLineEnd(&content);
}
}
// complain if the index count doesn't fit
if (expectedPointCount > 0 && indices.size() != expectedPointCount * numOffsets) {
if (pPrimType == Prim_Lines) {
// HACK: We just fix this number since SketchUp 15.3.331 writes the wrong 'count' for 'lines'
ReportWarning("Expected different index count in <p> element, %zu instead of %zu.", indices.size(), expectedPointCount * numOffsets);
pNumPrimitives = (indices.size() / numOffsets) / 2;
}
else
ThrowException("Expected different index count in <p> element.");
}
else if (expectedPointCount == 0 && (indices.size() % numOffsets) != 0)
ThrowException("Expected different index count in <p> element.");
// find the data for all sources
for (std::vector<InputChannel>::iterator it = pMesh->mPerVertexData.begin(); it != pMesh->mPerVertexData.end(); ++it)
{
InputChannel& input = *it;
if (input.mResolved)
continue;
// find accessor
input.mResolved = &ResolveLibraryReference(mAccessorLibrary, input.mAccessor);
// resolve accessor's data pointer as well, if necessary
const Accessor* acc = input.mResolved;
if (!acc->mData)
acc->mData = &ResolveLibraryReference(mDataLibrary, acc->mSource);
}
// and the same for the per-index channels
for (std::vector<InputChannel>::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it)
{
InputChannel& input = *it;
if (input.mResolved)
continue;
// ignore vertex pointer, it doesn't refer to an accessor
if (input.mType == IT_Vertex)
{
// warn if the vertex channel does not refer to the <vertices> element in the same mesh
if (input.mAccessor != pMesh->mVertexID)
ThrowException("Unsupported vertex referencing scheme.");
continue;
}
// find accessor
input.mResolved = &ResolveLibraryReference(mAccessorLibrary, input.mAccessor);
// resolve accessor's data pointer as well, if necessary
const Accessor* acc = input.mResolved;
if (!acc->mData)
acc->mData = &ResolveLibraryReference(mDataLibrary, acc->mSource);
}
// For continued primitives, the given count does not come all in one <p>, but only one primitive per <p>
size_t numPrimitives = pNumPrimitives;
if (pPrimType == Prim_TriFans || pPrimType == Prim_Polygon)
numPrimitives = 1;
// For continued primitives, the given count is actually the number of <p>'s inside the parent tag
if (pPrimType == Prim_TriStrips) {
size_t numberOfVertices = indices.size() / numOffsets;
numPrimitives = numberOfVertices - 2;
}
if (pPrimType == Prim_LineStrip) {
size_t numberOfVertices = indices.size() / numOffsets;
numPrimitives = numberOfVertices - 1;
}
pMesh->mFaceSize.reserve(numPrimitives);
pMesh->mFacePosIndices.reserve(indices.size() / numOffsets);
size_t polylistStartVertex = 0;
for (size_t currentPrimitive = 0; currentPrimitive < numPrimitives; currentPrimitive++)
{
// determine number of points for this primitive
size_t numPoints = 0;
switch (pPrimType)
{
case Prim_Lines:
numPoints = 2;
for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
break;
case Prim_LineStrip:
numPoints = 2;
for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
CopyVertex(currentVertex, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
break;
case Prim_Triangles:
numPoints = 3;
for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
break;
case Prim_TriStrips:
numPoints = 3;
ReadPrimTriStrips(numOffsets, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
break;
case Prim_Polylist:
numPoints = pVCount[currentPrimitive];
for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
CopyVertex(polylistStartVertex + currentVertex, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, 0, indices);
polylistStartVertex += numPoints;
break;
case Prim_TriFans:
case Prim_Polygon:
numPoints = indices.size() / numOffsets;
for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
break;
default:
// LineStrip is not supported due to expected index unmangling
ThrowException("Unsupported primitive type.");
break;
}
// store the face size to later reconstruct the face from
pMesh->mFaceSize.push_back(numPoints);
}
// if I ever get my hands on that guy who invented this steaming pile of indirection...
TestClosing("p");
return numPrimitives;
}
///@note This function willn't work correctly if both PerIndex and PerVertex channels have same channels.
///For example if TEXCOORD present in both <vertices> and <polylist> tags this function will create wrong uv coordinates.
///It's not clear from COLLADA documentation is this allowed or not. For now only exporter fixed to avoid such behavior
void ColladaParser::CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset, Mesh* pMesh, std::vector<InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices) {
// calculate the base offset of the vertex whose attributes we ant to copy
size_t baseOffset = currentPrimitive * numOffsets * numPoints + currentVertex * numOffsets;
// don't overrun the boundaries of the index list
ai_assert((baseOffset + numOffsets - 1) < indices.size());
// extract per-vertex channels using the global per-vertex offset
for (std::vector<InputChannel>::iterator it = pMesh->mPerVertexData.begin(); it != pMesh->mPerVertexData.end(); ++it)
ExtractDataObjectFromChannel(*it, indices[baseOffset + perVertexOffset], pMesh);
// and extract per-index channels using there specified offset
for (std::vector<InputChannel>::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it)
ExtractDataObjectFromChannel(*it, indices[baseOffset + it->mOffset], pMesh);
// store the vertex-data index for later assignment of bone vertex weights
pMesh->mFacePosIndices.push_back(indices[baseOffset + perVertexOffset]);
}
void ColladaParser::ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Mesh* pMesh, std::vector<InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices) {
if (currentPrimitive % 2 != 0) {
//odd tristrip triangles need their indices mangled, to preserve winding direction
CopyVertex(1, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
CopyVertex(0, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
CopyVertex(2, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
}
else {//for non tristrips or even tristrip triangles
CopyVertex(0, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
CopyVertex(1, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
CopyVertex(2, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
}
}
// ------------------------------------------------------------------------------------------------
// Extracts a single object from an input channel and stores it in the appropriate mesh data array
void ColladaParser::ExtractDataObjectFromChannel(const InputChannel& pInput, size_t pLocalIndex, Mesh* pMesh)
{
// ignore vertex referrer - we handle them that separate
if (pInput.mType == IT_Vertex)
return;
const Accessor& acc = *pInput.mResolved;
if (pLocalIndex >= acc.mCount)
ThrowException(format() << "Invalid data index (" << pLocalIndex << "/" << acc.mCount << ") in primitive specification");
// get a pointer to the start of the data object referred to by the accessor and the local index
const ai_real* dataObject = &(acc.mData->mValues[0]) + acc.mOffset + pLocalIndex * acc.mStride;
// assemble according to the accessors component sub-offset list. We don't care, yet,
// what kind of object exactly we're extracting here
ai_real obj[4];
for (size_t c = 0; c < 4; ++c)
obj[c] = dataObject[acc.mSubOffset[c]];
// now we reinterpret it according to the type we're reading here
switch (pInput.mType)
{
case IT_Position: // ignore all position streams except 0 - there can be only one position
if (pInput.mIndex == 0)
pMesh->mPositions.push_back(aiVector3D(obj[0], obj[1], obj[2]));
else
ASSIMP_LOG_ERROR("Collada: just one vertex position stream supported");
break;
case IT_Normal:
// pad to current vertex count if necessary
if (pMesh->mNormals.size() < pMesh->mPositions.size() - 1)
pMesh->mNormals.insert(pMesh->mNormals.end(), pMesh->mPositions.size() - pMesh->mNormals.size() - 1, aiVector3D(0, 1, 0));
// ignore all normal streams except 0 - there can be only one normal
if (pInput.mIndex == 0)
pMesh->mNormals.push_back(aiVector3D(obj[0], obj[1], obj[2]));
else
ASSIMP_LOG_ERROR("Collada: just one vertex normal stream supported");
break;
case IT_Tangent:
// pad to current vertex count if necessary
if (pMesh->mTangents.size() < pMesh->mPositions.size() - 1)
pMesh->mTangents.insert(pMesh->mTangents.end(), pMesh->mPositions.size() - pMesh->mTangents.size() - 1, aiVector3D(1, 0, 0));
// ignore all tangent streams except 0 - there can be only one tangent
if (pInput.mIndex == 0)
pMesh->mTangents.push_back(aiVector3D(obj[0], obj[1], obj[2]));
else
ASSIMP_LOG_ERROR("Collada: just one vertex tangent stream supported");
break;
case IT_Bitangent:
// pad to current vertex count if necessary
if (pMesh->mBitangents.size() < pMesh->mPositions.size() - 1)
pMesh->mBitangents.insert(pMesh->mBitangents.end(), pMesh->mPositions.size() - pMesh->mBitangents.size() - 1, aiVector3D(0, 0, 1));
// ignore all bitangent streams except 0 - there can be only one bitangent
if (pInput.mIndex == 0)
pMesh->mBitangents.push_back(aiVector3D(obj[0], obj[1], obj[2]));
else
ASSIMP_LOG_ERROR("Collada: just one vertex bitangent stream supported");
break;
case IT_Texcoord:
// up to 4 texture coord sets are fine, ignore the others
if (pInput.mIndex < AI_MAX_NUMBER_OF_TEXTURECOORDS)
{
// pad to current vertex count if necessary
if (pMesh->mTexCoords[pInput.mIndex].size() < pMesh->mPositions.size() - 1)
pMesh->mTexCoords[pInput.mIndex].insert(pMesh->mTexCoords[pInput.mIndex].end(),
pMesh->mPositions.size() - pMesh->mTexCoords[pInput.mIndex].size() - 1, aiVector3D(0, 0, 0));
pMesh->mTexCoords[pInput.mIndex].push_back(aiVector3D(obj[0], obj[1], obj[2]));
if (0 != acc.mSubOffset[2] || 0 != acc.mSubOffset[3]) /* hack ... consider cleaner solution */
pMesh->mNumUVComponents[pInput.mIndex] = 3;
}
else
{
ASSIMP_LOG_ERROR("Collada: too many texture coordinate sets. Skipping.");
}
break;
case IT_Color:
// up to 4 color sets are fine, ignore the others
if (pInput.mIndex < AI_MAX_NUMBER_OF_COLOR_SETS)
{
// pad to current vertex count if necessary
if (pMesh->mColors[pInput.mIndex].size() < pMesh->mPositions.size() - 1)
pMesh->mColors[pInput.mIndex].insert(pMesh->mColors[pInput.mIndex].end(),
pMesh->mPositions.size() - pMesh->mColors[pInput.mIndex].size() - 1, aiColor4D(0, 0, 0, 1));
aiColor4D result(0, 0, 0, 1);
for (size_t i = 0; i < pInput.mResolved->mSize; ++i)
{
result[static_cast<unsigned int>(i)] = obj[pInput.mResolved->mSubOffset[i]];
}
pMesh->mColors[pInput.mIndex].push_back(result);
}
else
{
ASSIMP_LOG_ERROR("Collada: too many vertex color sets. Skipping.");
}
break;
default:
// IT_Invalid and IT_Vertex
ai_assert(false && "shouldn't ever get here");
}
}
// ------------------------------------------------------------------------------------------------
// Reads the library of node hierarchies and scene parts
void ColladaParser::ReadSceneLibrary()
{
if (mReader->isEmptyElement())
return;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
// a visual scene - generate root node under its ID and let ReadNode() do the recursive work
if (IsElement("visual_scene"))
{
// read ID. Is optional according to the spec, but how on earth should a scene_instance refer to it then?
int indexID = GetAttribute("id");
const char* attrID = mReader->getAttributeValue(indexID);
// read name if given.
int indexName = TestAttribute("name");
const char* attrName = "unnamed";
if (indexName > -1)
attrName = mReader->getAttributeValue(indexName);
// create a node and store it in the library under its ID
Node* node = new Node;
node->mID = attrID;
node->mName = attrName;
mNodeLibrary[node->mID] = node;
ReadSceneNode(node);
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "library_visual_scenes") == 0)
//ThrowException( "Expected end of \"library_visual_scenes\" element.");
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads a scene node's contents including children and stores it in the given node
void ColladaParser::ReadSceneNode(Node* pNode)
{
// quit immediately on <bla/> elements
if (mReader->isEmptyElement())
return;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("node"))
{
Node* child = new Node;
int attrID = TestAttribute("id");
if (attrID > -1)
child->mID = mReader->getAttributeValue(attrID);
int attrSID = TestAttribute("sid");
if (attrSID > -1)
child->mSID = mReader->getAttributeValue(attrSID);
int attrName = TestAttribute("name");
if (attrName > -1)
child->mName = mReader->getAttributeValue(attrName);
// TODO: (thom) support SIDs
// ai_assert( TestAttribute( "sid") == -1);
if (pNode)
{
pNode->mChildren.push_back(child);
child->mParent = pNode;
}
else
{
// no parent node given, probably called from <library_nodes> element.
// create new node in node library
mNodeLibrary[child->mID] = child;
}
// read on recursively from there
ReadSceneNode(child);
continue;
}
// For any further stuff we need a valid node to work on
else if (!pNode)
continue;
if (IsElement("lookat"))
ReadNodeTransformation(pNode, TF_LOOKAT);
else if (IsElement("matrix"))
ReadNodeTransformation(pNode, TF_MATRIX);
else if (IsElement("rotate"))
ReadNodeTransformation(pNode, TF_ROTATE);
else if (IsElement("scale"))
ReadNodeTransformation(pNode, TF_SCALE);
else if (IsElement("skew"))
ReadNodeTransformation(pNode, TF_SKEW);
else if (IsElement("translate"))
ReadNodeTransformation(pNode, TF_TRANSLATE);
else if (IsElement("render") && pNode->mParent == NULL && 0 == pNode->mPrimaryCamera.length())
{
// ... scene evaluation or, in other words, postprocessing pipeline,
// or, again in other words, a turing-complete description how to
// render a Collada scene. The only thing that is interesting for
// us is the primary camera.
int attrId = TestAttribute("camera_node");
if (-1 != attrId)
{
const char* s = mReader->getAttributeValue(attrId);
if (s[0] != '#')
ASSIMP_LOG_ERROR("Collada: Unresolved reference format of camera");
else
pNode->mPrimaryCamera = s + 1;
}
}
else if (IsElement("instance_node"))
{
// find the node in the library
int attrID = TestAttribute("url");
if (attrID != -1)
{
const char* s = mReader->getAttributeValue(attrID);
if (s[0] != '#')
ASSIMP_LOG_ERROR("Collada: Unresolved reference format of node");
else
{
pNode->mNodeInstances.push_back(NodeInstance());
pNode->mNodeInstances.back().mNode = s + 1;
}
}
}
else if (IsElement("instance_geometry") || IsElement("instance_controller"))
{
// Reference to a mesh or controller, with possible material associations
ReadNodeGeometry(pNode);
}
else if (IsElement("instance_light"))
{
// Reference to a light, name given in 'url' attribute
int attrID = TestAttribute("url");
if (-1 == attrID)
ASSIMP_LOG_WARN("Collada: Expected url attribute in <instance_light> element");
else
{
const char* url = mReader->getAttributeValue(attrID);
if (url[0] != '#')
ThrowException("Unknown reference format in <instance_light> element");
pNode->mLights.push_back(LightInstance());
pNode->mLights.back().mLight = url + 1;
}
}
else if (IsElement("instance_camera"))
{
// Reference to a camera, name given in 'url' attribute
int attrID = TestAttribute("url");
if (-1 == attrID)
ASSIMP_LOG_WARN("Collada: Expected url attribute in <instance_camera> element");
else
{
const char* url = mReader->getAttributeValue(attrID);
if (url[0] != '#')
ThrowException("Unknown reference format in <instance_camera> element");
pNode->mCameras.push_back(CameraInstance());
pNode->mCameras.back().mCamera = url + 1;
}
}
else
{
// skip everything else for the moment
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads a node transformation entry of the given type and adds it to the given node's transformation list.
void ColladaParser::ReadNodeTransformation(Node* pNode, TransformType pType)
{
if (mReader->isEmptyElement())
return;
std::string tagName = mReader->getNodeName();
Transform tf;
tf.mType = pType;
// read SID
int indexSID = TestAttribute("sid");
if (indexSID >= 0)
tf.mID = mReader->getAttributeValue(indexSID);
// how many parameters to read per transformation type
static const unsigned int sNumParameters[] = { 9, 4, 3, 3, 7, 16 };
const char* content = GetTextContent();
// read as many parameters and store in the transformation
for (unsigned int a = 0; a < sNumParameters[pType]; a++)
{
// read a number
content = fast_atoreal_move<ai_real>(content, tf.f[a]);
// skip whitespace after it
SkipSpacesAndLineEnd(&content);
}
// place the transformation at the queue of the node
pNode->mTransforms.push_back(tf);
// and consume the closing tag
TestClosing(tagName.c_str());
}
// ------------------------------------------------------------------------------------------------
// Processes bind_vertex_input and bind elements
void ColladaParser::ReadMaterialVertexInputBinding(Collada::SemanticMappingTable& tbl)
{
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
if (IsElement("bind_vertex_input"))
{
Collada::InputSemanticMapEntry vn;
// effect semantic
int n = GetAttribute("semantic");
std::string s = mReader->getAttributeValue(n);
// input semantic
n = GetAttribute("input_semantic");
vn.mType = GetTypeForSemantic(mReader->getAttributeValue(n));
// index of input set
n = TestAttribute("input_set");
if (-1 != n)
vn.mSet = mReader->getAttributeValueAsInt(n);
tbl.mMap[s] = vn;
}
else if (IsElement("bind")) {
ASSIMP_LOG_WARN("Collada: Found unsupported <bind> element");
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
if (strcmp(mReader->getNodeName(), "instance_material") == 0)
break;
}
}
}
void ColladaParser::ReadEmbeddedTextures(ZipArchiveIOSystem& zip_archive)
{
// Attempt to load any undefined Collada::Image in ImageLibrary
for (ImageLibrary::iterator it = mImageLibrary.begin(); it != mImageLibrary.end(); ++it) {
Collada::Image &image = (*it).second;
if (image.mImageData.empty()) {
std::unique_ptr<IOStream> image_file(zip_archive.Open(image.mFileName.c_str()));
if (image_file) {
image.mImageData.resize(image_file->FileSize());
image_file->Read(image.mImageData.data(), image_file->FileSize(), 1);
image.mEmbeddedFormat = BaseImporter::GetExtension(image.mFileName);
if (image.mEmbeddedFormat == "jpeg") {
image.mEmbeddedFormat = "jpg";
}
}
}
}
}
// ------------------------------------------------------------------------------------------------
// Reads a mesh reference in a node and adds it to the node's mesh list
void ColladaParser::ReadNodeGeometry(Node* pNode)
{
// referred mesh is given as an attribute of the <instance_geometry> element
int attrUrl = GetAttribute("url");
const char* url = mReader->getAttributeValue(attrUrl);
if (url[0] != '#')
ThrowException("Unknown reference format");
Collada::MeshInstance instance;
instance.mMeshOrController = url + 1; // skipping the leading #
if (!mReader->isEmptyElement())
{
// read material associations. Ignore additional elements in between
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("instance_material"))
{
// read ID of the geometry subgroup and the target material
int attrGroup = GetAttribute("symbol");
std::string group = mReader->getAttributeValue(attrGroup);
int attrMaterial = GetAttribute("target");
const char* urlMat = mReader->getAttributeValue(attrMaterial);
Collada::SemanticMappingTable s;
if (urlMat[0] == '#')
urlMat++;
s.mMatName = urlMat;
// resolve further material details + THIS UGLY AND NASTY semantic mapping stuff
if (!mReader->isEmptyElement())
ReadMaterialVertexInputBinding(s);
// store the association
instance.mMaterials[group] = s;
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "instance_geometry") == 0
|| strcmp(mReader->getNodeName(), "instance_controller") == 0)
break;
}
}
}
// store it
pNode->mMeshes.push_back(instance);
}
// ------------------------------------------------------------------------------------------------
// Reads the collada scene
void ColladaParser::ReadScene()
{
if (mReader->isEmptyElement())
return;
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
if (IsElement("instance_visual_scene"))
{
// should be the first and only occurrence
if (mRootNode)
ThrowException("Invalid scene containing multiple root nodes in <instance_visual_scene> element");
// read the url of the scene to instance. Should be of format "#some_name"
int urlIndex = GetAttribute("url");
const char* url = mReader->getAttributeValue(urlIndex);
if (url[0] != '#')
ThrowException("Unknown reference format in <instance_visual_scene> element");
// find the referred scene, skip the leading #
NodeLibrary::const_iterator sit = mNodeLibrary.find(url + 1);
if (sit == mNodeLibrary.end())
ThrowException("Unable to resolve visual_scene reference \"" + std::string(url) + "\" in <instance_visual_scene> element.");
mRootNode = sit->second;
}
else {
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
break;
}
}
}
// ------------------------------------------------------------------------------------------------
// Aborts the file reading with an exception
AI_WONT_RETURN void ColladaParser::ThrowException(const std::string& pError) const {
throw DeadlyImportError(format() << "Collada: " << mFileName << " - " << pError);
}
void ColladaParser::ReportWarning(const char* msg, ...) {
ai_assert(nullptr != msg);
va_list args;
va_start(args, msg);
char szBuffer[3000];
const int iLen = vsprintf(szBuffer, msg, args);
ai_assert(iLen > 0);
va_end(args);
ASSIMP_LOG_WARN_F("Validation warning: ", std::string(szBuffer, iLen));
}
// ------------------------------------------------------------------------------------------------
// Skips all data until the end node of the current element
void ColladaParser::SkipElement() {
// nothing to skip if it's an <element />
if (mReader->isEmptyElement()) {
return;
}
// reroute
SkipElement(mReader->getNodeName());
}
// ------------------------------------------------------------------------------------------------
// Skips all data until the end node of the given element
void ColladaParser::SkipElement(const char* pElement) {
// copy the current node's name because it'a pointer to the reader's internal buffer,
// which is going to change with the upcoming parsing
std::string element = pElement;
while (mReader->read()) {
if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
if (mReader->getNodeName() == element) {
break;
}
}
}
}
// ------------------------------------------------------------------------------------------------
// Tests for an opening element of the given name, throws an exception if not found
void ColladaParser::TestOpening(const char* pName) {
// read element start
if (!mReader->read()) {
ThrowException(format() << "Unexpected end of file while beginning of <" << pName << "> element.");
}
// whitespace in front is ok, just read again if found
if (mReader->getNodeType() == irr::io::EXN_TEXT) {
if (!mReader->read()) {
ThrowException(format() << "Unexpected end of file while reading beginning of <" << pName << "> element.");
}
}
if (mReader->getNodeType() != irr::io::EXN_ELEMENT || strcmp(mReader->getNodeName(), pName) != 0) {
ThrowException(format() << "Expected start of <" << pName << "> element.");
}
}
// ------------------------------------------------------------------------------------------------
// Tests for the closing tag of the given element, throws an exception if not found
void ColladaParser::TestClosing(const char* pName) {
// check if we have an empty (self-closing) element
if (mReader->isEmptyElement()) {
return;
}
// check if we're already on the closing tag and return right away
if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END && strcmp(mReader->getNodeName(), pName) == 0) {
return;
}
// if not, read some more
if (!mReader->read()) {
ThrowException(format() << "Unexpected end of file while reading end of <" << pName << "> element.");
}
// whitespace in front is ok, just read again if found
if (mReader->getNodeType() == irr::io::EXN_TEXT) {
if (!mReader->read()) {
ThrowException(format() << "Unexpected end of file while reading end of <" << pName << "> element.");
}
}
// but this has the be the closing tag, or we're lost
if (mReader->getNodeType() != irr::io::EXN_ELEMENT_END || strcmp(mReader->getNodeName(), pName) != 0) {
ThrowException(format() << "Expected end of <" << pName << "> element.");
}
}
// ------------------------------------------------------------------------------------------------
// Returns the index of the named attribute or -1 if not found. Does not throw, therefore useful for optional attributes
int ColladaParser::GetAttribute(const char* pAttr) const {
int index = TestAttribute(pAttr);
if (index != -1) {
return index;
}
// attribute not found -> throw an exception
ThrowException(format() << "Expected attribute \"" << pAttr << "\" for element <" << mReader->getNodeName() << ">.");
return -1;
}
// ------------------------------------------------------------------------------------------------
// Tests the present element for the presence of one attribute, returns its index or throws an exception if not found
int ColladaParser::TestAttribute(const char* pAttr) const
{
for (int a = 0; a < mReader->getAttributeCount(); a++)
if (strcmp(mReader->getAttributeName(a), pAttr) == 0)
return a;
return -1;
}
// ------------------------------------------------------------------------------------------------
// Reads the text contents of an element, throws an exception if not given. Skips leading whitespace.
const char* ColladaParser::GetTextContent()
{
const char* sz = TestTextContent();
if (!sz) {
ThrowException("Invalid contents in element \"n\".");
}
return sz;
}
// ------------------------------------------------------------------------------------------------
// Reads the text contents of an element, returns NULL if not given. Skips leading whitespace.
const char* ColladaParser::TestTextContent()
{
// present node should be the beginning of an element
if (mReader->getNodeType() != irr::io::EXN_ELEMENT || mReader->isEmptyElement())
return NULL;
// read contents of the element
if (!mReader->read())
return NULL;
if (mReader->getNodeType() != irr::io::EXN_TEXT && mReader->getNodeType() != irr::io::EXN_CDATA)
return NULL;
// skip leading whitespace
const char* text = mReader->getNodeData();
SkipSpacesAndLineEnd(&text);
return text;
}
// ------------------------------------------------------------------------------------------------
// Calculates the resulting transformation fromm all the given transform steps
aiMatrix4x4 ColladaParser::CalculateResultTransform(const std::vector<Transform>& pTransforms) const
{
aiMatrix4x4 res;
for (std::vector<Transform>::const_iterator it = pTransforms.begin(); it != pTransforms.end(); ++it)
{
const Transform& tf = *it;
switch (tf.mType)
{
case TF_LOOKAT:
{
aiVector3D pos(tf.f[0], tf.f[1], tf.f[2]);
aiVector3D dstPos(tf.f[3], tf.f[4], tf.f[5]);
aiVector3D up = aiVector3D(tf.f[6], tf.f[7], tf.f[8]).Normalize();
aiVector3D dir = aiVector3D(dstPos - pos).Normalize();
aiVector3D right = (dir ^ up).Normalize();
res *= aiMatrix4x4(
right.x, up.x, -dir.x, pos.x,
right.y, up.y, -dir.y, pos.y,
right.z, up.z, -dir.z, pos.z,
0, 0, 0, 1);
break;
}
case TF_ROTATE:
{
aiMatrix4x4 rot;
ai_real angle = tf.f[3] * ai_real(AI_MATH_PI) / ai_real(180.0);
aiVector3D axis(tf.f[0], tf.f[1], tf.f[2]);
aiMatrix4x4::Rotation(angle, axis, rot);
res *= rot;
break;
}
case TF_TRANSLATE:
{
aiMatrix4x4 trans;
aiMatrix4x4::Translation(aiVector3D(tf.f[0], tf.f[1], tf.f[2]), trans);
res *= trans;
break;
}
case TF_SCALE:
{
aiMatrix4x4 scale(tf.f[0], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[1], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[2], 0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
res *= scale;
break;
}
case TF_SKEW:
// TODO: (thom)
ai_assert(false);
break;
case TF_MATRIX:
{
aiMatrix4x4 mat(tf.f[0], tf.f[1], tf.f[2], tf.f[3], tf.f[4], tf.f[5], tf.f[6], tf.f[7],
tf.f[8], tf.f[9], tf.f[10], tf.f[11], tf.f[12], tf.f[13], tf.f[14], tf.f[15]);
res *= mat;
break;
}
default:
ai_assert(false);
break;
}
}
return res;
}
// ------------------------------------------------------------------------------------------------
// Determines the input data type for the given semantic string
Collada::InputType ColladaParser::GetTypeForSemantic(const std::string& semantic)
{
if (semantic.empty()) {
ASSIMP_LOG_WARN("Vertex input type is empty.");
return IT_Invalid;
}
if (semantic == "POSITION")
return IT_Position;
else if (semantic == "TEXCOORD")
return IT_Texcoord;
else if (semantic == "NORMAL")
return IT_Normal;
else if (semantic == "COLOR")
return IT_Color;
else if (semantic == "VERTEX")
return IT_Vertex;
else if (semantic == "BINORMAL" || semantic == "TEXBINORMAL")
return IT_Bitangent;
else if (semantic == "TANGENT" || semantic == "TEXTANGENT")
return IT_Tangent;
ASSIMP_LOG_WARN_F("Unknown vertex input type \"", semantic, "\". Ignoring.");
return IT_Invalid;
}
#endif // !! ASSIMP_BUILD_NO_DAE_IMPORTER
Reference in New Issue View Git Blame Copy Permalink