vrshoot: libs/assimp/ColladaParser.cpp annotate

vrshoot

annotate libs/assimp/ColladaParser.cpp @ 0:b2f14e535253

initial commit

author	John Tsiombikas <nuclear@member.fsf.org>
date	Sat, 01 Feb 2014 19:58:19 +0200
parents
children

rev	line source
nuclear@0	1 /*
nuclear@0	2 ---------------------------------------------------------------------------
nuclear@0	3 Open Asset Import Library (assimp)
nuclear@0	4 ---------------------------------------------------------------------------
nuclear@0	5
nuclear@0	6 Copyright (c) 2006-2012, assimp team
nuclear@0	7
nuclear@0	8 All rights reserved.
nuclear@0	9
nuclear@0	10 Redistribution and use of this software in source and binary forms,
nuclear@0	11 with or without modification, are permitted provided that the following
nuclear@0	12 conditions are met:
nuclear@0	13
nuclear@0	14 * Redistributions of source code must retain the above
nuclear@0	15 copyright notice, this list of conditions and the
nuclear@0	16 following disclaimer.
nuclear@0	17
nuclear@0	18 * Redistributions in binary form must reproduce the above
nuclear@0	19 copyright notice, this list of conditions and the
nuclear@0	20 following disclaimer in the documentation and/or other
nuclear@0	21 materials provided with the distribution.
nuclear@0	22
nuclear@0	23 * Neither the name of the assimp team, nor the names of its
nuclear@0	24 contributors may be used to endorse or promote products
nuclear@0	25 derived from this software without specific prior
nuclear@0	26 written permission of the assimp team.
nuclear@0	27
nuclear@0	28 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
nuclear@0	29 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
nuclear@0	30 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
nuclear@0	31 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
nuclear@0	32 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
nuclear@0	33 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
nuclear@0	34 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
nuclear@0	35 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
nuclear@0	36 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
nuclear@0	37 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
nuclear@0	38 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
nuclear@0	39 ---------------------------------------------------------------------------
nuclear@0	40 */
nuclear@0	41
nuclear@0	42 /** @file ColladaParser.cpp
nuclear@0	43 * @brief Implementation of the Collada parser helper
nuclear@0	44 */
nuclear@0	45
nuclear@0	46 #include "AssimpPCH.h"
nuclear@0	47 #ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER
nuclear@0	48
nuclear@0	49 #include "ColladaParser.h"
nuclear@0	50 #include "fast_atof.h"
nuclear@0	51 #include "ParsingUtils.h"
nuclear@0	52
nuclear@0	53 using namespace Assimp;
nuclear@0	54 using namespace Assimp::Collada;
nuclear@0	55
nuclear@0	56 // ------------------------------------------------------------------------------------------------
nuclear@0	57 // Constructor to be privately used by Importer
nuclear@0	58 ColladaParser::ColladaParser( IOSystem* pIOHandler, const std::string& pFile)
nuclear@0	59 : mFileName( pFile)
nuclear@0	60 {
nuclear@0	61 mRootNode = NULL;
nuclear@0	62 mUnitSize = 1.0f;
nuclear@0	63 mUpDirection = UP_Z;
nuclear@0	64
nuclear@0	65 // We assume the newest file format by default
nuclear@0	66 mFormat = FV_1_5_n;
nuclear@0	67
nuclear@0	68 // open the file
nuclear@0	69 boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile));
nuclear@0	70 if( file.get() == NULL)
nuclear@0	71 throw DeadlyImportError( "Failed to open file " + pFile + ".");
nuclear@0	72
nuclear@0	73 // generate a XML reader for it
nuclear@0	74 boost::scoped_ptr<CIrrXML_IOStreamReader> mIOWrapper( new CIrrXML_IOStreamReader( file.get()));
nuclear@0	75 mReader = irr::io::createIrrXMLReader( mIOWrapper.get());
nuclear@0	76 if( !mReader)
nuclear@0	77 ThrowException( "Collada: Unable to open file.");
nuclear@0	78
nuclear@0	79 // start reading
nuclear@0	80 ReadContents();
nuclear@0	81 }
nuclear@0	82
nuclear@0	83 // ------------------------------------------------------------------------------------------------
nuclear@0	84 // Destructor, private as well
nuclear@0	85 ColladaParser::~ColladaParser()
nuclear@0	86 {
nuclear@0	87 delete mReader;
nuclear@0	88 for( NodeLibrary::iterator it = mNodeLibrary.begin(); it != mNodeLibrary.end(); ++it)
nuclear@0	89 delete it->second;
nuclear@0	90 for( MeshLibrary::iterator it = mMeshLibrary.begin(); it != mMeshLibrary.end(); ++it)
nuclear@0	91 delete it->second;
nuclear@0	92 }
nuclear@0	93
nuclear@0	94 // ------------------------------------------------------------------------------------------------
nuclear@0	95 // Read bool from text contents of current element
nuclear@0	96 bool ColladaParser::ReadBoolFromTextContent()
nuclear@0	97 {
nuclear@0	98 const char* cur = GetTextContent();
nuclear@0	99 return (!ASSIMP_strincmp(cur,"true",4) \|\| '0' != *cur);
nuclear@0	100 }
nuclear@0	101
nuclear@0	102 // ------------------------------------------------------------------------------------------------
nuclear@0	103 // Read float from text contents of current element
nuclear@0	104 float ColladaParser::ReadFloatFromTextContent()
nuclear@0	105 {
nuclear@0	106 const char* cur = GetTextContent();
nuclear@0	107 return fast_atof(cur);
nuclear@0	108 }
nuclear@0	109
nuclear@0	110 // ------------------------------------------------------------------------------------------------
nuclear@0	111 // Reads the contents of the file
nuclear@0	112 void ColladaParser::ReadContents()
nuclear@0	113 {
nuclear@0	114 while( mReader->read())
nuclear@0	115 {
nuclear@0	116 // handle the root element "COLLADA"
nuclear@0	117 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	118 {
nuclear@0	119 if( IsElement( "COLLADA"))
nuclear@0	120 {
nuclear@0	121 // check for 'version' attribute
nuclear@0	122 const int attrib = TestAttribute("version");
nuclear@0	123 if (attrib != -1) {
nuclear@0	124 const char* version = mReader->getAttributeValue(attrib);
nuclear@0	125
nuclear@0	126 if (!::strncmp(version,"1.5",3)) {
nuclear@0	127 mFormat = FV_1_5_n;
nuclear@0	128 DefaultLogger::get()->debug("Collada schema version is 1.5.n");
nuclear@0	129 }
nuclear@0	130 else if (!::strncmp(version,"1.4",3)) {
nuclear@0	131 mFormat = FV_1_4_n;
nuclear@0	132 DefaultLogger::get()->debug("Collada schema version is 1.4.n");
nuclear@0	133 }
nuclear@0	134 else if (!::strncmp(version,"1.3",3)) {
nuclear@0	135 mFormat = FV_1_3_n;
nuclear@0	136 DefaultLogger::get()->debug("Collada schema version is 1.3.n");
nuclear@0	137 }
nuclear@0	138 }
nuclear@0	139
nuclear@0	140 ReadStructure();
nuclear@0	141 } else
nuclear@0	142 {
nuclear@0	143 DefaultLogger::get()->debug( boost::str( boost::format( "Ignoring global element <%s>.") % mReader->getNodeName()));
nuclear@0	144 SkipElement();
nuclear@0	145 }
nuclear@0	146 } else
nuclear@0	147 {
nuclear@0	148 // skip everything else silently
nuclear@0	149 }
nuclear@0	150 }
nuclear@0	151 }
nuclear@0	152
nuclear@0	153 // ------------------------------------------------------------------------------------------------
nuclear@0	154 // Reads the structure of the file
nuclear@0	155 void ColladaParser::ReadStructure()
nuclear@0	156 {
nuclear@0	157 while( mReader->read())
nuclear@0	158 {
nuclear@0	159 // beginning of elements
nuclear@0	160 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	161 {
nuclear@0	162 if( IsElement( "asset"))
nuclear@0	163 ReadAssetInfo();
nuclear@0	164 else if( IsElement( "library_animations"))
nuclear@0	165 ReadAnimationLibrary();
nuclear@0	166 else if( IsElement( "library_controllers"))
nuclear@0	167 ReadControllerLibrary();
nuclear@0	168 else if( IsElement( "library_images"))
nuclear@0	169 ReadImageLibrary();
nuclear@0	170 else if( IsElement( "library_materials"))
nuclear@0	171 ReadMaterialLibrary();
nuclear@0	172 else if( IsElement( "library_effects"))
nuclear@0	173 ReadEffectLibrary();
nuclear@0	174 else if( IsElement( "library_geometries"))
nuclear@0	175 ReadGeometryLibrary();
nuclear@0	176 else if( IsElement( "library_visual_scenes"))
nuclear@0	177 ReadSceneLibrary();
nuclear@0	178 else if( IsElement( "library_lights"))
nuclear@0	179 ReadLightLibrary();
nuclear@0	180 else if( IsElement( "library_cameras"))
nuclear@0	181 ReadCameraLibrary();
nuclear@0	182 else if( IsElement( "library_nodes"))
nuclear@0	183 ReadSceneNode(NULL); /* some hacking to reuse this piece of code */
nuclear@0	184 else if( IsElement( "scene"))
nuclear@0	185 ReadScene();
nuclear@0	186 else
nuclear@0	187 SkipElement();
nuclear@0	188 }
nuclear@0	189 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	190 {
nuclear@0	191 break;
nuclear@0	192 }
nuclear@0	193 }
nuclear@0	194 }
nuclear@0	195
nuclear@0	196 // ------------------------------------------------------------------------------------------------
nuclear@0	197 // Reads asset informations such as coordinate system informations and legal blah
nuclear@0	198 void ColladaParser::ReadAssetInfo()
nuclear@0	199 {
nuclear@0	200 if( mReader->isEmptyElement())
nuclear@0	201 return;
nuclear@0	202
nuclear@0	203 while( mReader->read())
nuclear@0	204 {
nuclear@0	205 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	206 {
nuclear@0	207 if( IsElement( "unit"))
nuclear@0	208 {
nuclear@0	209 // read unit data from the element's attributes
nuclear@0	210 const int attrIndex = TestAttribute( "meter");
nuclear@0	211 if (attrIndex == -1) {
nuclear@0	212 mUnitSize = 1.f;
nuclear@0	213 }
nuclear@0	214 else {
nuclear@0	215 mUnitSize = mReader->getAttributeValueAsFloat( attrIndex);
nuclear@0	216 }
nuclear@0	217
nuclear@0	218 // consume the trailing stuff
nuclear@0	219 if( !mReader->isEmptyElement())
nuclear@0	220 SkipElement();
nuclear@0	221 }
nuclear@0	222 else if( IsElement( "up_axis"))
nuclear@0	223 {
nuclear@0	224 // read content, strip whitespace, compare
nuclear@0	225 const char* content = GetTextContent();
nuclear@0	226 if( strncmp( content, "X_UP", 4) == 0)
nuclear@0	227 mUpDirection = UP_X;
nuclear@0	228 else if( strncmp( content, "Y_UP", 4) == 0)
nuclear@0	229 mUpDirection = UP_Y;
nuclear@0	230 else
nuclear@0	231 mUpDirection = UP_Z;
nuclear@0	232
nuclear@0	233 // check element end
nuclear@0	234 TestClosing( "up_axis");
nuclear@0	235 } else
nuclear@0	236 {
nuclear@0	237 SkipElement();
nuclear@0	238 }
nuclear@0	239 }
nuclear@0	240 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	241 {
nuclear@0	242 if( strcmp( mReader->getNodeName(), "asset") != 0)
nuclear@0	243 ThrowException( "Expected end of <asset> element.");
nuclear@0	244
nuclear@0	245 break;
nuclear@0	246 }
nuclear@0	247 }
nuclear@0	248 }
nuclear@0	249
nuclear@0	250 // ------------------------------------------------------------------------------------------------
nuclear@0	251 // Reads the animation library
nuclear@0	252 void ColladaParser::ReadAnimationLibrary()
nuclear@0	253 {
nuclear@0	254 if (mReader->isEmptyElement())
nuclear@0	255 return;
nuclear@0	256
nuclear@0	257 while( mReader->read())
nuclear@0	258 {
nuclear@0	259 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	260 {
nuclear@0	261 if( IsElement( "animation"))
nuclear@0	262 {
nuclear@0	263 // delegate the reading. Depending on the inner elements it will be a container or a anim channel
nuclear@0	264 ReadAnimation( &mAnims);
nuclear@0	265 } else
nuclear@0	266 {
nuclear@0	267 // ignore the rest
nuclear@0	268 SkipElement();
nuclear@0	269 }
nuclear@0	270 }
nuclear@0	271 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	272 {
nuclear@0	273 if( strcmp( mReader->getNodeName(), "library_animations") != 0)
nuclear@0	274 ThrowException( "Expected end of <library_animations> element.");
nuclear@0	275
nuclear@0	276 break;
nuclear@0	277 }
nuclear@0	278 }
nuclear@0	279 }
nuclear@0	280
nuclear@0	281 // ------------------------------------------------------------------------------------------------
nuclear@0	282 // Reads an animation into the given parent structure
nuclear@0	283 void ColladaParser::ReadAnimation( Collada::Animation* pParent)
nuclear@0	284 {
nuclear@0	285 if( mReader->isEmptyElement())
nuclear@0	286 return;
nuclear@0	287
nuclear@0	288 // an <animation> element may be a container for grouping sub-elements or an animation channel
nuclear@0	289 // this is the channel collection by ID, in case it has channels
nuclear@0	290 typedef std::map<std::string, AnimationChannel> ChannelMap;
nuclear@0	291 ChannelMap channels;
nuclear@0	292 // this is the anim container in case we're a container
nuclear@0	293 Animation* anim = NULL;
nuclear@0	294
nuclear@0	295 // optional name given as an attribute
nuclear@0	296 std::string animName;
nuclear@0	297 int indexName = TestAttribute( "name");
nuclear@0	298 int indexID = TestAttribute( "id");
nuclear@0	299 if( indexName >= 0)
nuclear@0	300 animName = mReader->getAttributeValue( indexName);
nuclear@0	301 else if( indexID >= 0)
nuclear@0	302 animName = mReader->getAttributeValue( indexID);
nuclear@0	303 else
nuclear@0	304 animName = "animation";
nuclear@0	305
nuclear@0	306 while( mReader->read())
nuclear@0	307 {
nuclear@0	308 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	309 {
nuclear@0	310 // we have subanimations
nuclear@0	311 if( IsElement( "animation"))
nuclear@0	312 {
nuclear@0	313 // create container from our element
nuclear@0	314 if( !anim)
nuclear@0	315 {
nuclear@0	316 anim = new Animation;
nuclear@0	317 anim->mName = animName;
nuclear@0	318 pParent->mSubAnims.push_back( anim);
nuclear@0	319 }
nuclear@0	320
nuclear@0	321 // recurse into the subelement
nuclear@0	322 ReadAnimation( anim);
nuclear@0	323 }
nuclear@0	324 else if( IsElement( "source"))
nuclear@0	325 {
nuclear@0	326 // possible animation data - we'll never know. Better store it
nuclear@0	327 ReadSource();
nuclear@0	328 }
nuclear@0	329 else if( IsElement( "sampler"))
nuclear@0	330 {
nuclear@0	331 // read the ID to assign the corresponding collada channel afterwards.
nuclear@0	332 int indexID = GetAttribute( "id");
nuclear@0	333 std::string id = mReader->getAttributeValue( indexID);
nuclear@0	334 ChannelMap::iterator newChannel = channels.insert( std::make_pair( id, AnimationChannel())).first;
nuclear@0	335
nuclear@0	336 // have it read into a channel
nuclear@0	337 ReadAnimationSampler( newChannel->second);
nuclear@0	338 }
nuclear@0	339 else if( IsElement( "channel"))
nuclear@0	340 {
nuclear@0	341 // the binding element whose whole purpose is to provide the target to animate
nuclear@0	342 // Thanks, Collada! A directly posted information would have been too simple, I guess.
nuclear@0	343 // Better add another indirection to that! Can't have enough of those.
nuclear@0	344 int indexTarget = GetAttribute( "target");
nuclear@0	345 int indexSource = GetAttribute( "source");
nuclear@0	346 const char* sourceId = mReader->getAttributeValue( indexSource);
nuclear@0	347 if( sourceId[0] == '#')
nuclear@0	348 sourceId++;
nuclear@0	349 ChannelMap::iterator cit = channels.find( sourceId);
nuclear@0	350 if( cit != channels.end())
nuclear@0	351 cit->second.mTarget = mReader->getAttributeValue( indexTarget);
nuclear@0	352
nuclear@0	353 if( !mReader->isEmptyElement())
nuclear@0	354 SkipElement();
nuclear@0	355 }
nuclear@0	356 else
nuclear@0	357 {
nuclear@0	358 // ignore the rest
nuclear@0	359 SkipElement();
nuclear@0	360 }
nuclear@0	361 }
nuclear@0	362 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	363 {
nuclear@0	364 if( strcmp( mReader->getNodeName(), "animation") != 0)
nuclear@0	365 ThrowException( "Expected end of <animation> element.");
nuclear@0	366
nuclear@0	367 break;
nuclear@0	368 }
nuclear@0	369 }
nuclear@0	370
nuclear@0	371 // it turned out to have channels - add them
nuclear@0	372 if( !channels.empty())
nuclear@0	373 {
nuclear@0	374 // special filtering for stupid exporters packing each channel into a separate animation
nuclear@0	375 if( channels.size() == 1)
nuclear@0	376 {
nuclear@0	377 pParent->mChannels.push_back( channels.begin()->second);
nuclear@0	378 } else
nuclear@0	379 {
nuclear@0	380 // else create the animation, if not done yet, and store the channels
nuclear@0	381 if( !anim)
nuclear@0	382 {
nuclear@0	383 anim = new Animation;
nuclear@0	384 anim->mName = animName;
nuclear@0	385 pParent->mSubAnims.push_back( anim);
nuclear@0	386 }
nuclear@0	387 for( ChannelMap::const_iterator it = channels.begin(); it != channels.end(); ++it)
nuclear@0	388 anim->mChannels.push_back( it->second);
nuclear@0	389 }
nuclear@0	390 }
nuclear@0	391 }
nuclear@0	392
nuclear@0	393 // ------------------------------------------------------------------------------------------------
nuclear@0	394 // Reads an animation sampler into the given anim channel
nuclear@0	395 void ColladaParser::ReadAnimationSampler( Collada::AnimationChannel& pChannel)
nuclear@0	396 {
nuclear@0	397 while( mReader->read())
nuclear@0	398 {
nuclear@0	399 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	400 {
nuclear@0	401 if( IsElement( "input"))
nuclear@0	402 {
nuclear@0	403 int indexSemantic = GetAttribute( "semantic");
nuclear@0	404 const char* semantic = mReader->getAttributeValue( indexSemantic);
nuclear@0	405 int indexSource = GetAttribute( "source");
nuclear@0	406 const char* source = mReader->getAttributeValue( indexSource);
nuclear@0	407 if( source[0] != '#')
nuclear@0	408 ThrowException( "Unsupported URL format");
nuclear@0	409 source++;
nuclear@0	410
nuclear@0	411 if( strcmp( semantic, "INPUT") == 0)
nuclear@0	412 pChannel.mSourceTimes = source;
nuclear@0	413 else if( strcmp( semantic, "OUTPUT") == 0)
nuclear@0	414 pChannel.mSourceValues = source;
nuclear@0	415
nuclear@0	416 if( !mReader->isEmptyElement())
nuclear@0	417 SkipElement();
nuclear@0	418 }
nuclear@0	419 else
nuclear@0	420 {
nuclear@0	421 // ignore the rest
nuclear@0	422 SkipElement();
nuclear@0	423 }
nuclear@0	424 }
nuclear@0	425 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	426 {
nuclear@0	427 if( strcmp( mReader->getNodeName(), "sampler") != 0)
nuclear@0	428 ThrowException( "Expected end of <sampler> element.");
nuclear@0	429
nuclear@0	430 break;
nuclear@0	431 }
nuclear@0	432 }
nuclear@0	433 }
nuclear@0	434
nuclear@0	435 // ------------------------------------------------------------------------------------------------
nuclear@0	436 // Reads the skeleton controller library
nuclear@0	437 void ColladaParser::ReadControllerLibrary()
nuclear@0	438 {
nuclear@0	439 if (mReader->isEmptyElement())
nuclear@0	440 return;
nuclear@0	441
nuclear@0	442 while( mReader->read())
nuclear@0	443 {
nuclear@0	444 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	445 {
nuclear@0	446 if( IsElement( "controller"))
nuclear@0	447 {
nuclear@0	448 // read ID. Ask the spec if it's neccessary or optional... you might be surprised.
nuclear@0	449 int attrID = GetAttribute( "id");
nuclear@0	450 std::string id = mReader->getAttributeValue( attrID);
nuclear@0	451
nuclear@0	452 // create an entry and store it in the library under its ID
nuclear@0	453 mControllerLibrary[id] = Controller();
nuclear@0	454
nuclear@0	455 // read on from there
nuclear@0	456 ReadController( mControllerLibrary[id]);
nuclear@0	457 } else
nuclear@0	458 {
nuclear@0	459 // ignore the rest
nuclear@0	460 SkipElement();
nuclear@0	461 }
nuclear@0	462 }
nuclear@0	463 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	464 {
nuclear@0	465 if( strcmp( mReader->getNodeName(), "library_controllers") != 0)
nuclear@0	466 ThrowException( "Expected end of <library_controllers> element.");
nuclear@0	467
nuclear@0	468 break;
nuclear@0	469 }
nuclear@0	470 }
nuclear@0	471 }
nuclear@0	472
nuclear@0	473 // ------------------------------------------------------------------------------------------------
nuclear@0	474 // Reads a controller into the given mesh structure
nuclear@0	475 void ColladaParser::ReadController( Collada::Controller& pController)
nuclear@0	476 {
nuclear@0	477 while( mReader->read())
nuclear@0	478 {
nuclear@0	479 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	480 {
nuclear@0	481 // two types of controllers: "skin" and "morph". Only the first one is relevant, we skip the other
nuclear@0	482 if( IsElement( "morph"))
nuclear@0	483 {
nuclear@0	484 // should skip everything inside, so there's no danger of catching elements inbetween
nuclear@0	485 SkipElement();
nuclear@0	486 }
nuclear@0	487 else if( IsElement( "skin"))
nuclear@0	488 {
nuclear@0	489 // read the mesh it refers to. According to the spec this could also be another
nuclear@0	490 // controller, but I refuse to implement every single idea they've come up with
nuclear@0	491 int sourceIndex = GetAttribute( "source");
nuclear@0	492 pController.mMeshId = mReader->getAttributeValue( sourceIndex) + 1;
nuclear@0	493 }
nuclear@0	494 else if( IsElement( "bind_shape_matrix"))
nuclear@0	495 {
nuclear@0	496 // content is 16 floats to define a matrix... it seems to be important for some models
nuclear@0	497 const char* content = GetTextContent();
nuclear@0	498
nuclear@0	499 // read the 16 floats
nuclear@0	500 for( unsigned int a = 0; a < 16; a++)
nuclear@0	501 {
nuclear@0	502 // read a number
nuclear@0	503 content = fast_atoreal_move<float>( content, pController.mBindShapeMatrix[a]);
nuclear@0	504 // skip whitespace after it
nuclear@0	505 SkipSpacesAndLineEnd( &content);
nuclear@0	506 }
nuclear@0	507
nuclear@0	508 TestClosing( "bind_shape_matrix");
nuclear@0	509 }
nuclear@0	510 else if( IsElement( "source"))
nuclear@0	511 {
nuclear@0	512 // data array - we have specialists to handle this
nuclear@0	513 ReadSource();
nuclear@0	514 }
nuclear@0	515 else if( IsElement( "joints"))
nuclear@0	516 {
nuclear@0	517 ReadControllerJoints( pController);
nuclear@0	518 }
nuclear@0	519 else if( IsElement( "vertex_weights"))
nuclear@0	520 {
nuclear@0	521 ReadControllerWeights( pController);
nuclear@0	522 }
nuclear@0	523 else
nuclear@0	524 {
nuclear@0	525 // ignore the rest
nuclear@0	526 SkipElement();
nuclear@0	527 }
nuclear@0	528 }
nuclear@0	529 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	530 {
nuclear@0	531 if( strcmp( mReader->getNodeName(), "controller") == 0)
nuclear@0	532 break;
nuclear@0	533 else if( strcmp( mReader->getNodeName(), "skin") != 0)
nuclear@0	534 ThrowException( "Expected end of <controller> element.");
nuclear@0	535 }
nuclear@0	536 }
nuclear@0	537 }
nuclear@0	538
nuclear@0	539 // ------------------------------------------------------------------------------------------------
nuclear@0	540 // Reads the joint definitions for the given controller
nuclear@0	541 void ColladaParser::ReadControllerJoints( Collada::Controller& pController)
nuclear@0	542 {
nuclear@0	543 while( mReader->read())
nuclear@0	544 {
nuclear@0	545 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	546 {
nuclear@0	547 // Input channels for joint data. Two possible semantics: "JOINT" and "INV_BIND_MATRIX"
nuclear@0	548 if( IsElement( "input"))
nuclear@0	549 {
nuclear@0	550 int indexSemantic = GetAttribute( "semantic");
nuclear@0	551 const char* attrSemantic = mReader->getAttributeValue( indexSemantic);
nuclear@0	552 int indexSource = GetAttribute( "source");
nuclear@0	553 const char* attrSource = mReader->getAttributeValue( indexSource);
nuclear@0	554
nuclear@0	555 // local URLS always start with a '#'. We don't support global URLs
nuclear@0	556 if( attrSource[0] != '#')
nuclear@0	557 ThrowException( boost::str( boost::format( "Unsupported URL format in \"%s\" in source attribute of <joints> data <input> element") % attrSource));
nuclear@0	558 attrSource++;
nuclear@0	559
nuclear@0	560 // parse source URL to corresponding source
nuclear@0	561 if( strcmp( attrSemantic, "JOINT") == 0)
nuclear@0	562 pController.mJointNameSource = attrSource;
nuclear@0	563 else if( strcmp( attrSemantic, "INV_BIND_MATRIX") == 0)
nuclear@0	564 pController.mJointOffsetMatrixSource = attrSource;
nuclear@0	565 else
nuclear@0	566 ThrowException( boost::str( boost::format( "Unknown semantic \"%s\" in <joints> data <input> element") % attrSemantic));
nuclear@0	567
nuclear@0	568 // skip inner data, if present
nuclear@0	569 if( !mReader->isEmptyElement())
nuclear@0	570 SkipElement();
nuclear@0	571 }
nuclear@0	572 else
nuclear@0	573 {
nuclear@0	574 // ignore the rest
nuclear@0	575 SkipElement();
nuclear@0	576 }
nuclear@0	577 }
nuclear@0	578 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	579 {
nuclear@0	580 if( strcmp( mReader->getNodeName(), "joints") != 0)
nuclear@0	581 ThrowException( "Expected end of <joints> element.");
nuclear@0	582
nuclear@0	583 break;
nuclear@0	584 }
nuclear@0	585 }
nuclear@0	586 }
nuclear@0	587
nuclear@0	588 // ------------------------------------------------------------------------------------------------
nuclear@0	589 // Reads the joint weights for the given controller
nuclear@0	590 void ColladaParser::ReadControllerWeights( Collada::Controller& pController)
nuclear@0	591 {
nuclear@0	592 // read vertex count from attributes and resize the array accordingly
nuclear@0	593 int indexCount = GetAttribute( "count");
nuclear@0	594 size_t vertexCount = (size_t) mReader->getAttributeValueAsInt( indexCount);
nuclear@0	595 pController.mWeightCounts.resize( vertexCount);
nuclear@0	596
nuclear@0	597 while( mReader->read())
nuclear@0	598 {
nuclear@0	599 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	600 {
nuclear@0	601 // Input channels for weight data. Two possible semantics: "JOINT" and "WEIGHT"
nuclear@0	602 if( IsElement( "input") && vertexCount > 0 )
nuclear@0	603 {
nuclear@0	604 InputChannel channel;
nuclear@0	605
nuclear@0	606 int indexSemantic = GetAttribute( "semantic");
nuclear@0	607 const char* attrSemantic = mReader->getAttributeValue( indexSemantic);
nuclear@0	608 int indexSource = GetAttribute( "source");
nuclear@0	609 const char* attrSource = mReader->getAttributeValue( indexSource);
nuclear@0	610 int indexOffset = TestAttribute( "offset");
nuclear@0	611 if( indexOffset >= 0)
nuclear@0	612 channel.mOffset = mReader->getAttributeValueAsInt( indexOffset);
nuclear@0	613
nuclear@0	614 // local URLS always start with a '#'. We don't support global URLs
nuclear@0	615 if( attrSource[0] != '#')
nuclear@0	616 ThrowException( boost::str( boost::format( "Unsupported URL format in \"%s\" in source attribute of <vertex_weights> data <input> element") % attrSource));
nuclear@0	617 channel.mAccessor = attrSource + 1;
nuclear@0	618
nuclear@0	619 // parse source URL to corresponding source
nuclear@0	620 if( strcmp( attrSemantic, "JOINT") == 0)
nuclear@0	621 pController.mWeightInputJoints = channel;
nuclear@0	622 else if( strcmp( attrSemantic, "WEIGHT") == 0)
nuclear@0	623 pController.mWeightInputWeights = channel;
nuclear@0	624 else
nuclear@0	625 ThrowException( boost::str( boost::format( "Unknown semantic \"%s\" in <vertex_weights> data <input> element") % attrSemantic));
nuclear@0	626
nuclear@0	627 // skip inner data, if present
nuclear@0	628 if( !mReader->isEmptyElement())
nuclear@0	629 SkipElement();
nuclear@0	630 }
nuclear@0	631 else if( IsElement( "vcount") && vertexCount > 0 )
nuclear@0	632 {
nuclear@0	633 // read weight count per vertex
nuclear@0	634 const char* text = GetTextContent();
nuclear@0	635 size_t numWeights = 0;
nuclear@0	636 for( std::vector<size_t>::iterator it = pController.mWeightCounts.begin(); it != pController.mWeightCounts.end(); ++it)
nuclear@0	637 {
nuclear@0	638 if( *text == 0)
nuclear@0	639 ThrowException( "Out of data while reading <vcount>");
nuclear@0	640
nuclear@0	641 *it = strtoul10( text, &text);
nuclear@0	642 numWeights += *it;
nuclear@0	643 SkipSpacesAndLineEnd( &text);
nuclear@0	644 }
nuclear@0	645
nuclear@0	646 TestClosing( "vcount");
nuclear@0	647
nuclear@0	648 // reserve weight count
nuclear@0	649 pController.mWeights.resize( numWeights);
nuclear@0	650 }
nuclear@0	651 else if( IsElement( "v") && vertexCount > 0 )
nuclear@0	652 {
nuclear@0	653 // read JointIndex - WeightIndex pairs
nuclear@0	654 const char* text = GetTextContent();
nuclear@0	655
nuclear@0	656 for( std::vector< std::pair<size_t, size_t> >::iterator it = pController.mWeights.begin(); it != pController.mWeights.end(); ++it)
nuclear@0	657 {
nuclear@0	658 if( *text == 0)
nuclear@0	659 ThrowException( "Out of data while reading <vertex_weights>");
nuclear@0	660 it->first = strtoul10( text, &text);
nuclear@0	661 SkipSpacesAndLineEnd( &text);
nuclear@0	662 if( *text == 0)
nuclear@0	663 ThrowException( "Out of data while reading <vertex_weights>");
nuclear@0	664 it->second = strtoul10( text, &text);
nuclear@0	665 SkipSpacesAndLineEnd( &text);
nuclear@0	666 }
nuclear@0	667
nuclear@0	668 TestClosing( "v");
nuclear@0	669 }
nuclear@0	670 else
nuclear@0	671 {
nuclear@0	672 // ignore the rest
nuclear@0	673 SkipElement();
nuclear@0	674 }
nuclear@0	675 }
nuclear@0	676 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	677 {
nuclear@0	678 if( strcmp( mReader->getNodeName(), "vertex_weights") != 0)
nuclear@0	679 ThrowException( "Expected end of <vertex_weights> element.");
nuclear@0	680
nuclear@0	681 break;
nuclear@0	682 }
nuclear@0	683 }
nuclear@0	684 }
nuclear@0	685
nuclear@0	686 // ------------------------------------------------------------------------------------------------
nuclear@0	687 // Reads the image library contents
nuclear@0	688 void ColladaParser::ReadImageLibrary()
nuclear@0	689 {
nuclear@0	690 if( mReader->isEmptyElement())
nuclear@0	691 return;
nuclear@0	692
nuclear@0	693 while( mReader->read())
nuclear@0	694 {
nuclear@0	695 if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
nuclear@0	696 if( IsElement( "image"))
nuclear@0	697 {
nuclear@0	698 // read ID. Another entry which is "optional" by design but obligatory in reality
nuclear@0	699 int attrID = GetAttribute( "id");
nuclear@0	700 std::string id = mReader->getAttributeValue( attrID);
nuclear@0	701
nuclear@0	702 // create an entry and store it in the library under its ID
nuclear@0	703 mImageLibrary[id] = Image();
nuclear@0	704
nuclear@0	705 // read on from there
nuclear@0	706 ReadImage( mImageLibrary[id]);
nuclear@0	707 } else
nuclear@0	708 {
nuclear@0	709 // ignore the rest
nuclear@0	710 SkipElement();
nuclear@0	711 }
nuclear@0	712 }
nuclear@0	713 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
nuclear@0	714 if( strcmp( mReader->getNodeName(), "library_images") != 0)
nuclear@0	715 ThrowException( "Expected end of <library_images> element.");
nuclear@0	716
nuclear@0	717 break;
nuclear@0	718 }
nuclear@0	719 }
nuclear@0	720 }
nuclear@0	721
nuclear@0	722 // ------------------------------------------------------------------------------------------------
nuclear@0	723 // Reads an image entry into the given image
nuclear@0	724 void ColladaParser::ReadImage( Collada::Image& pImage)
nuclear@0	725 {
nuclear@0	726 while( mReader->read())
nuclear@0	727 {
nuclear@0	728 if( mReader->getNodeType() == irr::io::EXN_ELEMENT){
nuclear@0	729 // Need to run different code paths here, depending on the Collada XSD version
nuclear@0	730 if (IsElement("image")) {
nuclear@0	731 SkipElement();
nuclear@0	732 }
nuclear@0	733 else if( IsElement( "init_from"))
nuclear@0	734 {
nuclear@0	735 if (mFormat == FV_1_4_n)
nuclear@0	736 {
nuclear@0	737 // FIX: C4D exporter writes empty <init_from/> tags
nuclear@0	738 if (!mReader->isEmptyElement()) {
nuclear@0	739 // element content is filename - hopefully
nuclear@0	740 const char* sz = TestTextContent();
nuclear@0	741 if (sz)pImage.mFileName = sz;
nuclear@0	742 TestClosing( "init_from");
nuclear@0	743 }
nuclear@0	744 if (!pImage.mFileName.length()) {
nuclear@0	745 pImage.mFileName = "unknown_texture";
nuclear@0	746 }
nuclear@0	747 }
nuclear@0	748 else if (mFormat == FV_1_5_n)
nuclear@0	749 {
nuclear@0	750 // make sure we skip over mip and array initializations, which
nuclear@0	751 // we don't support, but which could confuse the loader if
nuclear@0	752 // they're not skipped.
nuclear@0	753 int attrib = TestAttribute("array_index");
nuclear@0	754 if (attrib != -1 && mReader->getAttributeValueAsInt(attrib) > 0) {
nuclear@0	755 DefaultLogger::get()->warn("Collada: Ignoring texture array index");
nuclear@0	756 continue;
nuclear@0	757 }
nuclear@0	758
nuclear@0	759 attrib = TestAttribute("mip_index");
nuclear@0	760 if (attrib != -1 && mReader->getAttributeValueAsInt(attrib) > 0) {
nuclear@0	761 DefaultLogger::get()->warn("Collada: Ignoring MIP map layer");
nuclear@0	762 continue;
nuclear@0	763 }
nuclear@0	764
nuclear@0	765 // TODO: correctly jump over cube and volume maps?
nuclear@0	766 }
nuclear@0	767 }
nuclear@0	768 else if (mFormat == FV_1_5_n)
nuclear@0	769 {
nuclear@0	770 if( IsElement( "ref"))
nuclear@0	771 {
nuclear@0	772 // element content is filename - hopefully
nuclear@0	773 const char* sz = TestTextContent();
nuclear@0	774 if (sz)pImage.mFileName = sz;
nuclear@0	775 TestClosing( "ref");
nuclear@0	776 }
nuclear@0	777 else if( IsElement( "hex") && !pImage.mFileName.length())
nuclear@0	778 {
nuclear@0	779 // embedded image. get format
nuclear@0	780 const int attrib = TestAttribute("format");
nuclear@0	781 if (-1 == attrib)
nuclear@0	782 DefaultLogger::get()->warn("Collada: Unknown image file format");
nuclear@0	783 else pImage.mEmbeddedFormat = mReader->getAttributeValue(attrib);
nuclear@0	784
nuclear@0	785 const char* data = GetTextContent();
nuclear@0	786
nuclear@0	787 // hexadecimal-encoded binary octets. First of all, find the
nuclear@0	788 // required buffer size to reserve enough storage.
nuclear@0	789 const char* cur = data;
nuclear@0	790 while (!IsSpaceOrNewLine(*cur)) cur++;
nuclear@0	791
nuclear@0	792 const unsigned int size = (unsigned int)(cur-data) * 2;
nuclear@0	793 pImage.mImageData.resize(size);
nuclear@0	794 for (unsigned int i = 0; i < size;++i)
nuclear@0	795 pImage.mImageData[i] = HexOctetToDecimal(data+(i<<1));
nuclear@0	796
nuclear@0	797 TestClosing( "hex");
nuclear@0	798 }
nuclear@0	799 }
nuclear@0	800 else
nuclear@0	801 {
nuclear@0	802 // ignore the rest
nuclear@0	803 SkipElement();
nuclear@0	804 }
nuclear@0	805 }
nuclear@0	806 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
nuclear@0	807 if( strcmp( mReader->getNodeName(), "image") == 0)
nuclear@0	808 break;
nuclear@0	809 }
nuclear@0	810 }
nuclear@0	811 }
nuclear@0	812
nuclear@0	813 // ------------------------------------------------------------------------------------------------
nuclear@0	814 // Reads the material library
nuclear@0	815 void ColladaParser::ReadMaterialLibrary()
nuclear@0	816 {
nuclear@0	817 if( mReader->isEmptyElement())
nuclear@0	818 return;
nuclear@0	819
nuclear@0	820 while( mReader->read())
nuclear@0	821 {
nuclear@0	822 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	823 {
nuclear@0	824 if( IsElement( "material"))
nuclear@0	825 {
nuclear@0	826 // read ID. By now you propably know my opinion about this "specification"
nuclear@0	827 int attrID = GetAttribute( "id");
nuclear@0	828 std::string id = mReader->getAttributeValue( attrID);
nuclear@0	829
nuclear@0	830 // create an entry and store it in the library under its ID
nuclear@0	831 ReadMaterial(mMaterialLibrary[id] = Material());
nuclear@0	832 } else
nuclear@0	833 {
nuclear@0	834 // ignore the rest
nuclear@0	835 SkipElement();
nuclear@0	836 }
nuclear@0	837 }
nuclear@0	838 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	839 {
nuclear@0	840 if( strcmp( mReader->getNodeName(), "library_materials") != 0)
nuclear@0	841 ThrowException( "Expected end of <library_materials> element.");
nuclear@0	842
nuclear@0	843 break;
nuclear@0	844 }
nuclear@0	845 }
nuclear@0	846 }
nuclear@0	847
nuclear@0	848 // ------------------------------------------------------------------------------------------------
nuclear@0	849 // Reads the light library
nuclear@0	850 void ColladaParser::ReadLightLibrary()
nuclear@0	851 {
nuclear@0	852 if( mReader->isEmptyElement())
nuclear@0	853 return;
nuclear@0	854
nuclear@0	855 while( mReader->read())
nuclear@0	856 {
nuclear@0	857 if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
nuclear@0	858 if( IsElement( "light"))
nuclear@0	859 {
nuclear@0	860 // read ID. By now you propably know my opinion about this "specification"
nuclear@0	861 int attrID = GetAttribute( "id");
nuclear@0	862 std::string id = mReader->getAttributeValue( attrID);
nuclear@0	863
nuclear@0	864 // create an entry and store it in the library under its ID
nuclear@0	865 ReadLight(mLightLibrary[id] = Light());
nuclear@0	866
nuclear@0	867 } else
nuclear@0	868 {
nuclear@0	869 // ignore the rest
nuclear@0	870 SkipElement();
nuclear@0	871 }
nuclear@0	872 }
nuclear@0	873 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
nuclear@0	874 if( strcmp( mReader->getNodeName(), "library_lights") != 0)
nuclear@0	875 ThrowException( "Expected end of <library_lights> element.");
nuclear@0	876
nuclear@0	877 break;
nuclear@0	878 }
nuclear@0	879 }
nuclear@0	880 }
nuclear@0	881
nuclear@0	882 // ------------------------------------------------------------------------------------------------
nuclear@0	883 // Reads the camera library
nuclear@0	884 void ColladaParser::ReadCameraLibrary()
nuclear@0	885 {
nuclear@0	886 if( mReader->isEmptyElement())
nuclear@0	887 return;
nuclear@0	888
nuclear@0	889 while( mReader->read())
nuclear@0	890 {
nuclear@0	891 if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
nuclear@0	892 if( IsElement( "camera"))
nuclear@0	893 {
nuclear@0	894 // read ID. By now you propably know my opinion about this "specification"
nuclear@0	895 int attrID = GetAttribute( "id");
nuclear@0	896 std::string id = mReader->getAttributeValue( attrID);
nuclear@0	897
nuclear@0	898 // create an entry and store it in the library under its ID
nuclear@0	899 Camera& cam = mCameraLibrary[id];
nuclear@0	900 attrID = TestAttribute( "name");
nuclear@0	901 if (attrID != -1)
nuclear@0	902 cam.mName = mReader->getAttributeValue( attrID);
nuclear@0	903
nuclear@0	904 ReadCamera(cam);
nuclear@0	905
nuclear@0	906 } else
nuclear@0	907 {
nuclear@0	908 // ignore the rest
nuclear@0	909 SkipElement();
nuclear@0	910 }
nuclear@0	911 }
nuclear@0	912 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
nuclear@0	913 if( strcmp( mReader->getNodeName(), "library_cameras") != 0)
nuclear@0	914 ThrowException( "Expected end of <library_cameras> element.");
nuclear@0	915
nuclear@0	916 break;
nuclear@0	917 }
nuclear@0	918 }
nuclear@0	919 }
nuclear@0	920
nuclear@0	921 // ------------------------------------------------------------------------------------------------
nuclear@0	922 // Reads a material entry into the given material
nuclear@0	923 void ColladaParser::ReadMaterial( Collada::Material& pMaterial)
nuclear@0	924 {
nuclear@0	925 while( mReader->read())
nuclear@0	926 {
nuclear@0	927 if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
nuclear@0	928 if (IsElement("material")) {
nuclear@0	929 SkipElement();
nuclear@0	930 }
nuclear@0	931 else if( IsElement( "instance_effect"))
nuclear@0	932 {
nuclear@0	933 // referred effect by URL
nuclear@0	934 int attrUrl = GetAttribute( "url");
nuclear@0	935 const char* url = mReader->getAttributeValue( attrUrl);
nuclear@0	936 if( url[0] != '#')
nuclear@0	937 ThrowException( "Unknown reference format");
nuclear@0	938
nuclear@0	939 pMaterial.mEffect = url+1;
nuclear@0	940
nuclear@0	941 SkipElement();
nuclear@0	942 } else
nuclear@0	943 {
nuclear@0	944 // ignore the rest
nuclear@0	945 SkipElement();
nuclear@0	946 }
nuclear@0	947 }
nuclear@0	948 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
nuclear@0	949 if( strcmp( mReader->getNodeName(), "material") != 0)
nuclear@0	950 ThrowException( "Expected end of <material> element.");
nuclear@0	951
nuclear@0	952 break;
nuclear@0	953 }
nuclear@0	954 }
nuclear@0	955 }
nuclear@0	956
nuclear@0	957 // ------------------------------------------------------------------------------------------------
nuclear@0	958 // Reads a light entry into the given light
nuclear@0	959 void ColladaParser::ReadLight( Collada::Light& pLight)
nuclear@0	960 {
nuclear@0	961 while( mReader->read())
nuclear@0	962 {
nuclear@0	963 if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
nuclear@0	964 if (IsElement("light")) {
nuclear@0	965 SkipElement();
nuclear@0	966 }
nuclear@0	967 else if (IsElement("spot")) {
nuclear@0	968 pLight.mType = aiLightSource_SPOT;
nuclear@0	969 }
nuclear@0	970 else if (IsElement("ambient")) {
nuclear@0	971 pLight.mType = aiLightSource_AMBIENT;
nuclear@0	972 }
nuclear@0	973 else if (IsElement("directional")) {
nuclear@0	974 pLight.mType = aiLightSource_DIRECTIONAL;
nuclear@0	975 }
nuclear@0	976 else if (IsElement("point")) {
nuclear@0	977 pLight.mType = aiLightSource_POINT;
nuclear@0	978 }
nuclear@0	979 else if (IsElement("color")) {
nuclear@0	980 // text content contains 3 floats
nuclear@0	981 const char* content = GetTextContent();
nuclear@0	982
nuclear@0	983 content = fast_atoreal_move<float>( content, (float&)pLight.mColor.r);
nuclear@0	984 SkipSpacesAndLineEnd( &content);
nuclear@0	985
nuclear@0	986 content = fast_atoreal_move<float>( content, (float&)pLight.mColor.g);
nuclear@0	987 SkipSpacesAndLineEnd( &content);
nuclear@0	988
nuclear@0	989 content = fast_atoreal_move<float>( content, (float&)pLight.mColor.b);
nuclear@0	990 SkipSpacesAndLineEnd( &content);
nuclear@0	991
nuclear@0	992 TestClosing( "color");
nuclear@0	993 }
nuclear@0	994 else if (IsElement("constant_attenuation")) {
nuclear@0	995 pLight.mAttConstant = ReadFloatFromTextContent();
nuclear@0	996 TestClosing("constant_attenuation");
nuclear@0	997 }
nuclear@0	998 else if (IsElement("linear_attenuation")) {
nuclear@0	999 pLight.mAttLinear = ReadFloatFromTextContent();
nuclear@0	1000 TestClosing("linear_attenuation");
nuclear@0	1001 }
nuclear@0	1002 else if (IsElement("quadratic_attenuation")) {
nuclear@0	1003 pLight.mAttQuadratic = ReadFloatFromTextContent();
nuclear@0	1004 TestClosing("quadratic_attenuation");
nuclear@0	1005 }
nuclear@0	1006 else if (IsElement("falloff_angle")) {
nuclear@0	1007 pLight.mFalloffAngle = ReadFloatFromTextContent();
nuclear@0	1008 TestClosing("falloff_angle");
nuclear@0	1009 }
nuclear@0	1010 else if (IsElement("falloff_exponent")) {
nuclear@0	1011 pLight.mFalloffExponent = ReadFloatFromTextContent();
nuclear@0	1012 TestClosing("falloff_exponent");
nuclear@0	1013 }
nuclear@0	1014 // FCOLLADA extensions
nuclear@0	1015 // -------------------------------------------------------
nuclear@0	1016 else if (IsElement("outer_cone")) {
nuclear@0	1017 pLight.mOuterAngle = ReadFloatFromTextContent();
nuclear@0	1018 TestClosing("outer_cone");
nuclear@0	1019 }
nuclear@0	1020 // ... and this one is even deprecated
nuclear@0	1021 else if (IsElement("penumbra_angle")) {
nuclear@0	1022 pLight.mPenumbraAngle = ReadFloatFromTextContent();
nuclear@0	1023 TestClosing("penumbra_angle");
nuclear@0	1024 }
nuclear@0	1025 else if (IsElement("intensity")) {
nuclear@0	1026 pLight.mIntensity = ReadFloatFromTextContent();
nuclear@0	1027 TestClosing("intensity");
nuclear@0	1028 }
nuclear@0	1029 else if (IsElement("falloff")) {
nuclear@0	1030 pLight.mOuterAngle = ReadFloatFromTextContent();
nuclear@0	1031 TestClosing("falloff");
nuclear@0	1032 }
nuclear@0	1033 else if (IsElement("hotspot_beam")) {
nuclear@0	1034 pLight.mFalloffAngle = ReadFloatFromTextContent();
nuclear@0	1035 TestClosing("hotspot_beam");
nuclear@0	1036 }
nuclear@0	1037 }
nuclear@0	1038 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
nuclear@0	1039 if( strcmp( mReader->getNodeName(), "light") == 0)
nuclear@0	1040 break;
nuclear@0	1041 }
nuclear@0	1042 }
nuclear@0	1043 }
nuclear@0	1044
nuclear@0	1045 // ------------------------------------------------------------------------------------------------
nuclear@0	1046 // Reads a camera entry into the given light
nuclear@0	1047 void ColladaParser::ReadCamera( Collada::Camera& pCamera)
nuclear@0	1048 {
nuclear@0	1049 while( mReader->read())
nuclear@0	1050 {
nuclear@0	1051 if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
nuclear@0	1052 if (IsElement("camera")) {
nuclear@0	1053 SkipElement();
nuclear@0	1054 }
nuclear@0	1055 else if (IsElement("orthographic")) {
nuclear@0	1056 pCamera.mOrtho = true;
nuclear@0	1057 }
nuclear@0	1058 else if (IsElement("xfov") \|\| IsElement("xmag")) {
nuclear@0	1059 pCamera.mHorFov = ReadFloatFromTextContent();
nuclear@0	1060 TestClosing((pCamera.mOrtho ? "xmag" : "xfov"));
nuclear@0	1061 }
nuclear@0	1062 else if (IsElement("yfov") \|\| IsElement("ymag")) {
nuclear@0	1063 pCamera.mVerFov = ReadFloatFromTextContent();
nuclear@0	1064 TestClosing((pCamera.mOrtho ? "ymag" : "yfov"));
nuclear@0	1065 }
nuclear@0	1066 else if (IsElement("aspect_ratio")) {
nuclear@0	1067 pCamera.mAspect = ReadFloatFromTextContent();
nuclear@0	1068 TestClosing("aspect_ratio");
nuclear@0	1069 }
nuclear@0	1070 else if (IsElement("znear")) {
nuclear@0	1071 pCamera.mZNear = ReadFloatFromTextContent();
nuclear@0	1072 TestClosing("znear");
nuclear@0	1073 }
nuclear@0	1074 else if (IsElement("zfar")) {
nuclear@0	1075 pCamera.mZFar = ReadFloatFromTextContent();
nuclear@0	1076 TestClosing("zfar");
nuclear@0	1077 }
nuclear@0	1078 }
nuclear@0	1079 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
nuclear@0	1080 if( strcmp( mReader->getNodeName(), "camera") == 0)
nuclear@0	1081 break;
nuclear@0	1082 }
nuclear@0	1083 }
nuclear@0	1084 }
nuclear@0	1085
nuclear@0	1086 // ------------------------------------------------------------------------------------------------
nuclear@0	1087 // Reads the effect library
nuclear@0	1088 void ColladaParser::ReadEffectLibrary()
nuclear@0	1089 {
nuclear@0	1090 if (mReader->isEmptyElement()) {
nuclear@0	1091 return;
nuclear@0	1092 }
nuclear@0	1093
nuclear@0	1094 while( mReader->read())
nuclear@0	1095 {
nuclear@0	1096 if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
nuclear@0	1097 if( IsElement( "effect"))
nuclear@0	1098 {
nuclear@0	1099 // read ID. Do I have to repeat my ranting about "optional" attributes?
nuclear@0	1100 int attrID = GetAttribute( "id");
nuclear@0	1101 std::string id = mReader->getAttributeValue( attrID);
nuclear@0	1102
nuclear@0	1103 // create an entry and store it in the library under its ID
nuclear@0	1104 mEffectLibrary[id] = Effect();
nuclear@0	1105 // read on from there
nuclear@0	1106 ReadEffect( mEffectLibrary[id]);
nuclear@0	1107 } else
nuclear@0	1108 {
nuclear@0	1109 // ignore the rest
nuclear@0	1110 SkipElement();
nuclear@0	1111 }
nuclear@0	1112 }
nuclear@0	1113 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
nuclear@0	1114 if( strcmp( mReader->getNodeName(), "library_effects") != 0)
nuclear@0	1115 ThrowException( "Expected end of <library_effects> element.");
nuclear@0	1116
nuclear@0	1117 break;
nuclear@0	1118 }
nuclear@0	1119 }
nuclear@0	1120 }
nuclear@0	1121
nuclear@0	1122 // ------------------------------------------------------------------------------------------------
nuclear@0	1123 // Reads an effect entry into the given effect
nuclear@0	1124 void ColladaParser::ReadEffect( Collada::Effect& pEffect)
nuclear@0	1125 {
nuclear@0	1126 // for the moment we don't support any other type of effect.
nuclear@0	1127 while( mReader->read())
nuclear@0	1128 {
nuclear@0	1129 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	1130 {
nuclear@0	1131 if( IsElement( "profile_COMMON"))
nuclear@0	1132 ReadEffectProfileCommon( pEffect);
nuclear@0	1133 else
nuclear@0	1134 SkipElement();
nuclear@0	1135 }
nuclear@0	1136 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	1137 {
nuclear@0	1138 if( strcmp( mReader->getNodeName(), "effect") != 0)
nuclear@0	1139 ThrowException( "Expected end of <effect> element.");
nuclear@0	1140
nuclear@0	1141 break;
nuclear@0	1142 }
nuclear@0	1143 }
nuclear@0	1144 }
nuclear@0	1145
nuclear@0	1146 // ------------------------------------------------------------------------------------------------
nuclear@0	1147 // Reads an COMMON effect profile
nuclear@0	1148 void ColladaParser::ReadEffectProfileCommon( Collada::Effect& pEffect)
nuclear@0	1149 {
nuclear@0	1150 while( mReader->read())
nuclear@0	1151 {
nuclear@0	1152 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	1153 {
nuclear@0	1154 if( IsElement( "newparam")) {
nuclear@0	1155 // save ID
nuclear@0	1156 int attrSID = GetAttribute( "sid");
nuclear@0	1157 std::string sid = mReader->getAttributeValue( attrSID);
nuclear@0	1158 pEffect.mParams[sid] = EffectParam();
nuclear@0	1159 ReadEffectParam( pEffect.mParams[sid]);
nuclear@0	1160 }
nuclear@0	1161 else if( IsElement( "technique") \|\| IsElement( "extra"))
nuclear@0	1162 {
nuclear@0	1163 // just syntactic sugar
nuclear@0	1164 }
nuclear@0	1165
nuclear@0	1166 /* Shading modes */
nuclear@0	1167 else if( IsElement( "phong"))
nuclear@0	1168 pEffect.mShadeType = Shade_Phong;
nuclear@0	1169 else if( IsElement( "constant"))
nuclear@0	1170 pEffect.mShadeType = Shade_Constant;
nuclear@0	1171 else if( IsElement( "lambert"))
nuclear@0	1172 pEffect.mShadeType = Shade_Lambert;
nuclear@0	1173 else if( IsElement( "blinn"))
nuclear@0	1174 pEffect.mShadeType = Shade_Blinn;
nuclear@0	1175
nuclear@0	1176 /* Color + texture properties */
nuclear@0	1177 else if( IsElement( "emission"))
nuclear@0	1178 ReadEffectColor( pEffect.mEmissive, pEffect.mTexEmissive);
nuclear@0	1179 else if( IsElement( "ambient"))
nuclear@0	1180 ReadEffectColor( pEffect.mAmbient, pEffect.mTexAmbient);
nuclear@0	1181 else if( IsElement( "diffuse"))
nuclear@0	1182 ReadEffectColor( pEffect.mDiffuse, pEffect.mTexDiffuse);
nuclear@0	1183 else if( IsElement( "specular"))
nuclear@0	1184 ReadEffectColor( pEffect.mSpecular, pEffect.mTexSpecular);
nuclear@0	1185 else if( IsElement( "reflective")) {
nuclear@0	1186 ReadEffectColor( pEffect.mReflective, pEffect.mTexReflective);
nuclear@0	1187 }
nuclear@0	1188 else if( IsElement( "transparent")) {
nuclear@0	1189 ReadEffectColor( pEffect.mTransparent,pEffect.mTexTransparent);
nuclear@0	1190 }
nuclear@0	1191 else if( IsElement( "shininess"))
nuclear@0	1192 ReadEffectFloat( pEffect.mShininess);
nuclear@0	1193 else if( IsElement( "reflectivity"))
nuclear@0	1194 ReadEffectFloat( pEffect.mReflectivity);
nuclear@0	1195
nuclear@0	1196 /* Single scalar properties */
nuclear@0	1197 else if( IsElement( "transparency"))
nuclear@0	1198 ReadEffectFloat( pEffect.mTransparency);
nuclear@0	1199 else if( IsElement( "index_of_refraction"))
nuclear@0	1200 ReadEffectFloat( pEffect.mRefractIndex);
nuclear@0	1201
nuclear@0	1202 // GOOGLEEARTH/OKINO extensions
nuclear@0	1203 // -------------------------------------------------------
nuclear@0	1204 else if( IsElement( "double_sided"))
nuclear@0	1205 pEffect.mDoubleSided = ReadBoolFromTextContent();
nuclear@0	1206
nuclear@0	1207 // FCOLLADA extensions
nuclear@0	1208 // -------------------------------------------------------
nuclear@0	1209 else if( IsElement( "bump")) {
nuclear@0	1210 aiColor4D dummy;
nuclear@0	1211 ReadEffectColor( dummy,pEffect.mTexBump);
nuclear@0	1212 }
nuclear@0	1213
nuclear@0	1214 // MAX3D extensions
nuclear@0	1215 // -------------------------------------------------------
nuclear@0	1216 else if( IsElement( "wireframe")) {
nuclear@0	1217 pEffect.mWireframe = ReadBoolFromTextContent();
nuclear@0	1218 TestClosing( "wireframe");
nuclear@0	1219 }
nuclear@0	1220 else if( IsElement( "faceted")) {
nuclear@0	1221 pEffect.mFaceted = ReadBoolFromTextContent();
nuclear@0	1222 TestClosing( "faceted");
nuclear@0	1223 }
nuclear@0	1224 else
nuclear@0	1225 {
nuclear@0	1226 // ignore the rest
nuclear@0	1227 SkipElement();
nuclear@0	1228 }
nuclear@0	1229 }
nuclear@0	1230 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
nuclear@0	1231 if( strcmp( mReader->getNodeName(), "profile_COMMON") == 0)
nuclear@0	1232 {
nuclear@0	1233 break;
nuclear@0	1234 }
nuclear@0	1235 }
nuclear@0	1236 }
nuclear@0	1237 }
nuclear@0	1238
nuclear@0	1239 // ------------------------------------------------------------------------------------------------
nuclear@0	1240 // Read texture wrapping + UV transform settings from a profile==Maya chunk
nuclear@0	1241 void ColladaParser::ReadSamplerProperties( Sampler& out )
nuclear@0	1242 {
nuclear@0	1243 if (mReader->isEmptyElement()) {
nuclear@0	1244 return;
nuclear@0	1245 }
nuclear@0	1246
nuclear@0	1247 while( mReader->read())
nuclear@0	1248 {
nuclear@0	1249 if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
nuclear@0	1250
nuclear@0	1251 // MAYA extensions
nuclear@0	1252 // -------------------------------------------------------
nuclear@0	1253 if( IsElement( "wrapU")) {
nuclear@0	1254 out.mWrapU = ReadBoolFromTextContent();
nuclear@0	1255 TestClosing( "wrapU");
nuclear@0	1256 }
nuclear@0	1257 else if( IsElement( "wrapV")) {
nuclear@0	1258 out.mWrapV = ReadBoolFromTextContent();
nuclear@0	1259 TestClosing( "wrapV");
nuclear@0	1260 }
nuclear@0	1261 else if( IsElement( "mirrorU")) {
nuclear@0	1262 out.mMirrorU = ReadBoolFromTextContent();
nuclear@0	1263 TestClosing( "mirrorU");
nuclear@0	1264 }
nuclear@0	1265 else if( IsElement( "mirrorV")) {
nuclear@0	1266 out.mMirrorV = ReadBoolFromTextContent();
nuclear@0	1267 TestClosing( "mirrorV");
nuclear@0	1268 }
nuclear@0	1269 else if( IsElement( "repeatU")) {
nuclear@0	1270 out.mTransform.mScaling.x = ReadFloatFromTextContent();
nuclear@0	1271 TestClosing( "repeatU");
nuclear@0	1272 }
nuclear@0	1273 else if( IsElement( "repeatV")) {
nuclear@0	1274 out.mTransform.mScaling.y = ReadFloatFromTextContent();
nuclear@0	1275 TestClosing( "repeatV");
nuclear@0	1276 }
nuclear@0	1277 else if( IsElement( "offsetU")) {
nuclear@0	1278 out.mTransform.mTranslation.x = ReadFloatFromTextContent();
nuclear@0	1279 TestClosing( "offsetU");
nuclear@0	1280 }
nuclear@0	1281 else if( IsElement( "offsetV")) {
nuclear@0	1282 out.mTransform.mTranslation.y = ReadFloatFromTextContent();
nuclear@0	1283 TestClosing( "offsetV");
nuclear@0	1284 }
nuclear@0	1285 else if( IsElement( "rotateUV")) {
nuclear@0	1286 out.mTransform.mRotation = ReadFloatFromTextContent();
nuclear@0	1287 TestClosing( "rotateUV");
nuclear@0	1288 }
nuclear@0	1289 else if( IsElement( "blend_mode")) {
nuclear@0	1290
nuclear@0	1291 const char* sz = GetTextContent();
nuclear@0	1292 // http://www.feelingsoftware.com/content/view/55/72/lang,en/
nuclear@0	1293 // NONE, OVER, IN, OUT, ADD, SUBTRACT, MULTIPLY, DIFFERENCE, LIGHTEN, DARKEN, SATURATE, DESATURATE and ILLUMINATE
nuclear@0	1294 if (0 == ASSIMP_strincmp(sz,"ADD",3))
nuclear@0	1295 out.mOp = aiTextureOp_Add;
nuclear@0	1296
nuclear@0	1297 else if (0 == ASSIMP_strincmp(sz,"SUBTRACT",8))
nuclear@0	1298 out.mOp = aiTextureOp_Subtract;
nuclear@0	1299
nuclear@0	1300 else if (0 == ASSIMP_strincmp(sz,"MULTIPLY",8))
nuclear@0	1301 out.mOp = aiTextureOp_Multiply;
nuclear@0	1302
nuclear@0	1303 else {
nuclear@0	1304 DefaultLogger::get()->warn("Collada: Unsupported MAYA texture blend mode");
nuclear@0	1305 }
nuclear@0	1306 TestClosing( "blend_mode");
nuclear@0	1307 }
nuclear@0	1308 // OKINO extensions
nuclear@0	1309 // -------------------------------------------------------
nuclear@0	1310 else if( IsElement( "weighting")) {
nuclear@0	1311 out.mWeighting = ReadFloatFromTextContent();
nuclear@0	1312 TestClosing( "weighting");
nuclear@0	1313 }
nuclear@0	1314 else if( IsElement( "mix_with_previous_layer")) {
nuclear@0	1315 out.mMixWithPrevious = ReadFloatFromTextContent();
nuclear@0	1316 TestClosing( "mix_with_previous_layer");
nuclear@0	1317 }
nuclear@0	1318 // MAX3D extensions
nuclear@0	1319 // -------------------------------------------------------
nuclear@0	1320 else if( IsElement( "amount")) {
nuclear@0	1321 out.mWeighting = ReadFloatFromTextContent();
nuclear@0	1322 TestClosing( "amount");
nuclear@0	1323 }
nuclear@0	1324 }
nuclear@0	1325 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
nuclear@0	1326 if( strcmp( mReader->getNodeName(), "technique") == 0)
nuclear@0	1327 break;
nuclear@0	1328 }
nuclear@0	1329 }
nuclear@0	1330 }
nuclear@0	1331
nuclear@0	1332 // ------------------------------------------------------------------------------------------------
nuclear@0	1333 // Reads an effect entry containing a color or a texture defining that color
nuclear@0	1334 void ColladaParser::ReadEffectColor( aiColor4D& pColor, Sampler& pSampler)
nuclear@0	1335 {
nuclear@0	1336 if (mReader->isEmptyElement())
nuclear@0	1337 return;
nuclear@0	1338
nuclear@0	1339 // Save current element name
nuclear@0	1340 const std::string curElem = mReader->getNodeName();
nuclear@0	1341
nuclear@0	1342 while( mReader->read())
nuclear@0	1343 {
nuclear@0	1344 if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
nuclear@0	1345 if( IsElement( "color"))
nuclear@0	1346 {
nuclear@0	1347 // text content contains 4 floats
nuclear@0	1348 const char* content = GetTextContent();
nuclear@0	1349
nuclear@0	1350 content = fast_atoreal_move<float>( content, (float&)pColor.r);
nuclear@0	1351 SkipSpacesAndLineEnd( &content);
nuclear@0	1352
nuclear@0	1353 content = fast_atoreal_move<float>( content, (float&)pColor.g);
nuclear@0	1354 SkipSpacesAndLineEnd( &content);
nuclear@0	1355
nuclear@0	1356 content = fast_atoreal_move<float>( content, (float&)pColor.b);
nuclear@0	1357 SkipSpacesAndLineEnd( &content);
nuclear@0	1358
nuclear@0	1359 content = fast_atoreal_move<float>( content, (float&)pColor.a);
nuclear@0	1360 SkipSpacesAndLineEnd( &content);
nuclear@0	1361 TestClosing( "color");
nuclear@0	1362 }
nuclear@0	1363 else if( IsElement( "texture"))
nuclear@0	1364 {
nuclear@0	1365 // get name of source textur/sampler
nuclear@0	1366 int attrTex = GetAttribute( "texture");
nuclear@0	1367 pSampler.mName = mReader->getAttributeValue( attrTex);
nuclear@0	1368
nuclear@0	1369 // get name of UV source channel. Specification demands it to be there, but some exporters
nuclear@0	1370 // don't write it. It will be the default UV channel in case it's missing.
nuclear@0	1371 attrTex = TestAttribute( "texcoord");
nuclear@0	1372 if( attrTex >= 0 )
nuclear@0	1373 pSampler.mUVChannel = mReader->getAttributeValue( attrTex);
nuclear@0	1374 //SkipElement();
nuclear@0	1375 }
nuclear@0	1376 else if( IsElement( "technique"))
nuclear@0	1377 {
nuclear@0	1378 const int _profile = GetAttribute( "profile");
nuclear@0	1379 const char* profile = mReader->getAttributeValue( _profile );
nuclear@0	1380
nuclear@0	1381 // Some extensions are quite useful ... ReadSamplerProperties processes
nuclear@0	1382 // several extensions in MAYA, OKINO and MAX3D profiles.
nuclear@0	1383 if (!::strcmp(profile,"MAYA") \|\| !::strcmp(profile,"MAX3D") \|\| !::strcmp(profile,"OKINO"))
nuclear@0	1384 {
nuclear@0	1385 // get more information on this sampler
nuclear@0	1386 ReadSamplerProperties(pSampler);
nuclear@0	1387 }
nuclear@0	1388 else SkipElement();
nuclear@0	1389 }
nuclear@0	1390 else if( !IsElement( "extra"))
nuclear@0	1391 {
nuclear@0	1392 // ignore the rest
nuclear@0	1393 SkipElement();
nuclear@0	1394 }
nuclear@0	1395 }
nuclear@0	1396 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END){
nuclear@0	1397 if (mReader->getNodeName() == curElem)
nuclear@0	1398 break;
nuclear@0	1399 }
nuclear@0	1400 }
nuclear@0	1401 }
nuclear@0	1402
nuclear@0	1403 // ------------------------------------------------------------------------------------------------
nuclear@0	1404 // Reads an effect entry containing a float
nuclear@0	1405 void ColladaParser::ReadEffectFloat( float& pFloat)
nuclear@0	1406 {
nuclear@0	1407 while( mReader->read())
nuclear@0	1408 {
nuclear@0	1409 if( mReader->getNodeType() == irr::io::EXN_ELEMENT){
nuclear@0	1410 if( IsElement( "float"))
nuclear@0	1411 {
nuclear@0	1412 // text content contains a single floats
nuclear@0	1413 const char* content = GetTextContent();
nuclear@0	1414 content = fast_atoreal_move<float>( content, pFloat);
nuclear@0	1415 SkipSpacesAndLineEnd( &content);
nuclear@0	1416
nuclear@0	1417 TestClosing( "float");
nuclear@0	1418 } else
nuclear@0	1419 {
nuclear@0	1420 // ignore the rest
nuclear@0	1421 SkipElement();
nuclear@0	1422 }
nuclear@0	1423 }
nuclear@0	1424 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END){
nuclear@0	1425 break;
nuclear@0	1426 }
nuclear@0	1427 }
nuclear@0	1428 }
nuclear@0	1429
nuclear@0	1430 // ------------------------------------------------------------------------------------------------
nuclear@0	1431 // Reads an effect parameter specification of any kind
nuclear@0	1432 void ColladaParser::ReadEffectParam( Collada::EffectParam& pParam)
nuclear@0	1433 {
nuclear@0	1434 while( mReader->read())
nuclear@0	1435 {
nuclear@0	1436 if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
nuclear@0	1437 if( IsElement( "surface"))
nuclear@0	1438 {
nuclear@0	1439 // image ID given inside <init_from> tags
nuclear@0	1440 TestOpening( "init_from");
nuclear@0	1441 const char* content = GetTextContent();
nuclear@0	1442 pParam.mType = Param_Surface;
nuclear@0	1443 pParam.mReference = content;
nuclear@0	1444 TestClosing( "init_from");
nuclear@0	1445
nuclear@0	1446 // don't care for remaining stuff
nuclear@0	1447 SkipElement( "surface");
nuclear@0	1448 }
nuclear@0	1449 else if( IsElement( "sampler2D"))
nuclear@0	1450 {
nuclear@0	1451 // surface ID is given inside <source> tags
nuclear@0	1452 TestOpening( "source");
nuclear@0	1453 const char* content = GetTextContent();
nuclear@0	1454 pParam.mType = Param_Sampler;
nuclear@0	1455 pParam.mReference = content;
nuclear@0	1456 TestClosing( "source");
nuclear@0	1457
nuclear@0	1458 // don't care for remaining stuff
nuclear@0	1459 SkipElement( "sampler2D");
nuclear@0	1460 } else
nuclear@0	1461 {
nuclear@0	1462 // ignore unknown element
nuclear@0	1463 SkipElement();
nuclear@0	1464 }
nuclear@0	1465 }
nuclear@0	1466 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
nuclear@0	1467 break;
nuclear@0	1468 }
nuclear@0	1469 }
nuclear@0	1470 }
nuclear@0	1471
nuclear@0	1472 // ------------------------------------------------------------------------------------------------
nuclear@0	1473 // Reads the geometry library contents
nuclear@0	1474 void ColladaParser::ReadGeometryLibrary()
nuclear@0	1475 {
nuclear@0	1476 if( mReader->isEmptyElement())
nuclear@0	1477 return;
nuclear@0	1478
nuclear@0	1479 while( mReader->read())
nuclear@0	1480 {
nuclear@0	1481 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	1482 {
nuclear@0	1483 if( IsElement( "geometry"))
nuclear@0	1484 {
nuclear@0	1485 // read ID. Another entry which is "optional" by design but obligatory in reality
nuclear@0	1486 int indexID = GetAttribute( "id");
nuclear@0	1487 std::string id = mReader->getAttributeValue( indexID);
nuclear@0	1488
nuclear@0	1489 // TODO: (thom) support SIDs
nuclear@0	1490 // ai_assert( TestAttribute( "sid") == -1);
nuclear@0	1491
nuclear@0	1492 // create a mesh and store it in the library under its ID
nuclear@0	1493 Mesh* mesh = new Mesh;
nuclear@0	1494 mMeshLibrary[id] = mesh;
nuclear@0	1495
nuclear@0	1496 // read on from there
nuclear@0	1497 ReadGeometry( mesh);
nuclear@0	1498 } else
nuclear@0	1499 {
nuclear@0	1500 // ignore the rest
nuclear@0	1501 SkipElement();
nuclear@0	1502 }
nuclear@0	1503 }
nuclear@0	1504 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	1505 {
nuclear@0	1506 if( strcmp( mReader->getNodeName(), "library_geometries") != 0)
nuclear@0	1507 ThrowException( "Expected end of <library_geometries> element.");
nuclear@0	1508
nuclear@0	1509 break;
nuclear@0	1510 }
nuclear@0	1511 }
nuclear@0	1512 }
nuclear@0	1513
nuclear@0	1514 // ------------------------------------------------------------------------------------------------
nuclear@0	1515 // Reads a geometry from the geometry library.
nuclear@0	1516 void ColladaParser::ReadGeometry( Collada::Mesh* pMesh)
nuclear@0	1517 {
nuclear@0	1518 if( mReader->isEmptyElement())
nuclear@0	1519 return;
nuclear@0	1520
nuclear@0	1521 while( mReader->read())
nuclear@0	1522 {
nuclear@0	1523 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	1524 {
nuclear@0	1525 if( IsElement( "mesh"))
nuclear@0	1526 {
nuclear@0	1527 // read on from there
nuclear@0	1528 ReadMesh( pMesh);
nuclear@0	1529 } else
nuclear@0	1530 {
nuclear@0	1531 // ignore the rest
nuclear@0	1532 SkipElement();
nuclear@0	1533 }
nuclear@0	1534 }
nuclear@0	1535 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	1536 {
nuclear@0	1537 if( strcmp( mReader->getNodeName(), "geometry") != 0)
nuclear@0	1538 ThrowException( "Expected end of <geometry> element.");
nuclear@0	1539
nuclear@0	1540 break;
nuclear@0	1541 }
nuclear@0	1542 }
nuclear@0	1543 }
nuclear@0	1544
nuclear@0	1545 // ------------------------------------------------------------------------------------------------
nuclear@0	1546 // Reads a mesh from the geometry library
nuclear@0	1547 void ColladaParser::ReadMesh( Mesh* pMesh)
nuclear@0	1548 {
nuclear@0	1549 if( mReader->isEmptyElement())
nuclear@0	1550 return;
nuclear@0	1551
nuclear@0	1552 while( mReader->read())
nuclear@0	1553 {
nuclear@0	1554 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	1555 {
nuclear@0	1556 if( IsElement( "source"))
nuclear@0	1557 {
nuclear@0	1558 // we have professionals dealing with this
nuclear@0	1559 ReadSource();
nuclear@0	1560 }
nuclear@0	1561 else if( IsElement( "vertices"))
nuclear@0	1562 {
nuclear@0	1563 // read per-vertex mesh data
nuclear@0	1564 ReadVertexData( pMesh);
nuclear@0	1565 }
nuclear@0	1566 else if( IsElement( "triangles") \|\| IsElement( "lines") \|\| IsElement( "linestrips")
nuclear@0	1567 \|\| IsElement( "polygons") \|\| IsElement( "polylist") \|\| IsElement( "trifans") \|\| IsElement( "tristrips"))
nuclear@0	1568 {
nuclear@0	1569 // read per-index mesh data and faces setup
nuclear@0	1570 ReadIndexData( pMesh);
nuclear@0	1571 } else
nuclear@0	1572 {
nuclear@0	1573 // ignore the rest
nuclear@0	1574 SkipElement();
nuclear@0	1575 }
nuclear@0	1576 }
nuclear@0	1577 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	1578 {
nuclear@0	1579 if( strcmp( mReader->getNodeName(), "technique_common") == 0)
nuclear@0	1580 {
nuclear@0	1581 // end of another meaningless element - read over it
nuclear@0	1582 }
nuclear@0	1583 else if( strcmp( mReader->getNodeName(), "mesh") == 0)
nuclear@0	1584 {
nuclear@0	1585 // end of <mesh> element - we're done here
nuclear@0	1586 break;
nuclear@0	1587 } else
nuclear@0	1588 {
nuclear@0	1589 // everything else should be punished
nuclear@0	1590 ThrowException( "Expected end of <mesh> element.");
nuclear@0	1591 }
nuclear@0	1592 }
nuclear@0	1593 }
nuclear@0	1594 }
nuclear@0	1595
nuclear@0	1596 // ------------------------------------------------------------------------------------------------
nuclear@0	1597 // Reads a source element
nuclear@0	1598 void ColladaParser::ReadSource()
nuclear@0	1599 {
nuclear@0	1600 int indexID = GetAttribute( "id");
nuclear@0	1601 std::string sourceID = mReader->getAttributeValue( indexID);
nuclear@0	1602
nuclear@0	1603 while( mReader->read())
nuclear@0	1604 {
nuclear@0	1605 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	1606 {
nuclear@0	1607 if( IsElement( "float_array") \|\| IsElement( "IDREF_array") \|\| IsElement( "Name_array"))
nuclear@0	1608 {
nuclear@0	1609 ReadDataArray();
nuclear@0	1610 }
nuclear@0	1611 else if( IsElement( "technique_common"))
nuclear@0	1612 {
nuclear@0	1613 // I don't care for your profiles
nuclear@0	1614 }
nuclear@0	1615 else if( IsElement( "accessor"))
nuclear@0	1616 {
nuclear@0	1617 ReadAccessor( sourceID);
nuclear@0	1618 } else
nuclear@0	1619 {
nuclear@0	1620 // ignore the rest
nuclear@0	1621 SkipElement();
nuclear@0	1622 }
nuclear@0	1623 }
nuclear@0	1624 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	1625 {
nuclear@0	1626 if( strcmp( mReader->getNodeName(), "source") == 0)
nuclear@0	1627 {
nuclear@0	1628 // end of <source> - we're done
nuclear@0	1629 break;
nuclear@0	1630 }
nuclear@0	1631 else if( strcmp( mReader->getNodeName(), "technique_common") == 0)
nuclear@0	1632 {
nuclear@0	1633 // end of another meaningless element - read over it
nuclear@0	1634 } else
nuclear@0	1635 {
nuclear@0	1636 // everything else should be punished
nuclear@0	1637 ThrowException( "Expected end of <source> element.");
nuclear@0	1638 }
nuclear@0	1639 }
nuclear@0	1640 }
nuclear@0	1641 }
nuclear@0	1642
nuclear@0	1643 // ------------------------------------------------------------------------------------------------
nuclear@0	1644 // Reads a data array holding a number of floats, and stores it in the global library
nuclear@0	1645 void ColladaParser::ReadDataArray()
nuclear@0	1646 {
nuclear@0	1647 std::string elmName = mReader->getNodeName();
nuclear@0	1648 bool isStringArray = (elmName == "IDREF_array" \|\| elmName == "Name_array");
nuclear@0	1649 bool isEmptyElement = mReader->isEmptyElement();
nuclear@0	1650
nuclear@0	1651 // read attributes
nuclear@0	1652 int indexID = GetAttribute( "id");
nuclear@0	1653 std::string id = mReader->getAttributeValue( indexID);
nuclear@0	1654 int indexCount = GetAttribute( "count");
nuclear@0	1655 unsigned int count = (unsigned int) mReader->getAttributeValueAsInt( indexCount);
nuclear@0	1656 if (count == 0) { return; } // some exporters write empty data arrays with count="0"
nuclear@0	1657 const char* content = TestTextContent();
nuclear@0	1658
nuclear@0	1659 // read values and store inside an array in the data library
nuclear@0	1660 mDataLibrary[id] = Data();
nuclear@0	1661 Data& data = mDataLibrary[id];
nuclear@0	1662 data.mIsStringArray = isStringArray;
nuclear@0	1663
nuclear@0	1664 // some exporters write empty data arrays, but we need to conserve them anyways because others might reference them
nuclear@0	1665 if (content)
nuclear@0	1666 {
nuclear@0	1667 if( isStringArray)
nuclear@0	1668 {
nuclear@0	1669 data.mStrings.reserve( count);
nuclear@0	1670 std::string s;
nuclear@0	1671
nuclear@0	1672 for( unsigned int a = 0; a < count; a++)
nuclear@0	1673 {
nuclear@0	1674 if( *content == 0)
nuclear@0	1675 ThrowException( "Expected more values while reading IDREF_array contents.");
nuclear@0	1676
nuclear@0	1677 s.clear();
nuclear@0	1678 while( !IsSpaceOrNewLine( *content))
nuclear@0	1679 s += *content++;
nuclear@0	1680 data.mStrings.push_back( s);
nuclear@0	1681
nuclear@0	1682 SkipSpacesAndLineEnd( &content);
nuclear@0	1683 }
nuclear@0	1684 } else
nuclear@0	1685 {
nuclear@0	1686 data.mValues.reserve( count);
nuclear@0	1687
nuclear@0	1688 for( unsigned int a = 0; a < count; a++)
nuclear@0	1689 {
nuclear@0	1690 if( *content == 0)
nuclear@0	1691 ThrowException( "Expected more values while reading float_array contents.");
nuclear@0	1692
nuclear@0	1693 float value;
nuclear@0	1694 // read a number
nuclear@0	1695 content = fast_atoreal_move<float>( content, value);
nuclear@0	1696 data.mValues.push_back( value);
nuclear@0	1697 // skip whitespace after it
nuclear@0	1698 SkipSpacesAndLineEnd( &content);
nuclear@0	1699 }
nuclear@0	1700 }
nuclear@0	1701 }
nuclear@0	1702
nuclear@0	1703 // test for closing tag
nuclear@0	1704 if( !isEmptyElement )
nuclear@0	1705 TestClosing( elmName.c_str());
nuclear@0	1706 }
nuclear@0	1707
nuclear@0	1708 // ------------------------------------------------------------------------------------------------
nuclear@0	1709 // Reads an accessor and stores it in the global library
nuclear@0	1710 void ColladaParser::ReadAccessor( const std::string& pID)
nuclear@0	1711 {
nuclear@0	1712 // read accessor attributes
nuclear@0	1713 int attrSource = GetAttribute( "source");
nuclear@0	1714 const char* source = mReader->getAttributeValue( attrSource);
nuclear@0	1715 if( source[0] != '#')
nuclear@0	1716 ThrowException( boost::str( boost::format( "Unknown reference format in url \"%s\" in source attribute of <accessor> element.") % source));
nuclear@0	1717 int attrCount = GetAttribute( "count");
nuclear@0	1718 unsigned int count = (unsigned int) mReader->getAttributeValueAsInt( attrCount);
nuclear@0	1719 int attrOffset = TestAttribute( "offset");
nuclear@0	1720 unsigned int offset = 0;
nuclear@0	1721 if( attrOffset > -1)
nuclear@0	1722 offset = (unsigned int) mReader->getAttributeValueAsInt( attrOffset);
nuclear@0	1723 int attrStride = TestAttribute( "stride");
nuclear@0	1724 unsigned int stride = 1;
nuclear@0	1725 if( attrStride > -1)
nuclear@0	1726 stride = (unsigned int) mReader->getAttributeValueAsInt( attrStride);
nuclear@0	1727
nuclear@0	1728 // store in the library under the given ID
nuclear@0	1729 mAccessorLibrary[pID] = Accessor();
nuclear@0	1730 Accessor& acc = mAccessorLibrary[pID];
nuclear@0	1731 acc.mCount = count;
nuclear@0	1732 acc.mOffset = offset;
nuclear@0	1733 acc.mStride = stride;
nuclear@0	1734 acc.mSource = source+1; // ignore the leading '#'
nuclear@0	1735 acc.mSize = 0; // gets incremented with every param
nuclear@0	1736
nuclear@0	1737 // and read the components
nuclear@0	1738 while( mReader->read())
nuclear@0	1739 {
nuclear@0	1740 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	1741 {
nuclear@0	1742 if( IsElement( "param"))
nuclear@0	1743 {
nuclear@0	1744 // read data param
nuclear@0	1745 int attrName = TestAttribute( "name");
nuclear@0	1746 std::string name;
nuclear@0	1747 if( attrName > -1)
nuclear@0	1748 {
nuclear@0	1749 name = mReader->getAttributeValue( attrName);
nuclear@0	1750
nuclear@0	1751 // analyse for common type components and store it's sub-offset in the corresponding field
nuclear@0	1752
nuclear@0	1753 /* Cartesian coordinates */
nuclear@0	1754 if( name == "X") acc.mSubOffset[0] = acc.mParams.size();
nuclear@0	1755 else if( name == "Y") acc.mSubOffset[1] = acc.mParams.size();
nuclear@0	1756 else if( name == "Z") acc.mSubOffset[2] = acc.mParams.size();
nuclear@0	1757
nuclear@0	1758 /* RGBA colors */
nuclear@0	1759 else if( name == "R") acc.mSubOffset[0] = acc.mParams.size();
nuclear@0	1760 else if( name == "G") acc.mSubOffset[1] = acc.mParams.size();
nuclear@0	1761 else if( name == "B") acc.mSubOffset[2] = acc.mParams.size();
nuclear@0	1762 else if( name == "A") acc.mSubOffset[3] = acc.mParams.size();
nuclear@0	1763
nuclear@0	1764 /* UVWQ (STPQ) texture coordinates */
nuclear@0	1765 else if( name == "S") acc.mSubOffset[0] = acc.mParams.size();
nuclear@0	1766 else if( name == "T") acc.mSubOffset[1] = acc.mParams.size();
nuclear@0	1767 else if( name == "P") acc.mSubOffset[2] = acc.mParams.size();
nuclear@0	1768 // else if( name == "Q") acc.mSubOffset[3] = acc.mParams.size();
nuclear@0	1769 /* 4D uv coordinates are not supported in Assimp */
nuclear@0	1770
nuclear@0	1771 /* Generic extra data, interpreted as UV data, too*/
nuclear@0	1772 else if( name == "U") acc.mSubOffset[0] = acc.mParams.size();
nuclear@0	1773 else if( name == "V") acc.mSubOffset[1] = acc.mParams.size();
nuclear@0	1774 //else
nuclear@0	1775 // DefaultLogger::get()->warn( boost::str( boost::format( "Unknown accessor parameter \"%s\". Ignoring data channel.") % name));
nuclear@0	1776 }
nuclear@0	1777
nuclear@0	1778 // read data type
nuclear@0	1779 int attrType = TestAttribute( "type");
nuclear@0	1780 if( attrType > -1)
nuclear@0	1781 {
nuclear@0	1782 // for the moment we only distinguish between a 4x4 matrix and anything else.
nuclear@0	1783 // TODO: (thom) I don't have a spec here at work. Check if there are other multi-value types
nuclear@0	1784 // which should be tested for here.
nuclear@0	1785 std::string type = mReader->getAttributeValue( attrType);
nuclear@0	1786 if( type == "float4x4")
nuclear@0	1787 acc.mSize += 16;
nuclear@0	1788 else
nuclear@0	1789 acc.mSize += 1;
nuclear@0	1790 }
nuclear@0	1791
nuclear@0	1792 acc.mParams.push_back( name);
nuclear@0	1793
nuclear@0	1794 // skip remaining stuff of this element, if any
nuclear@0	1795 SkipElement();
nuclear@0	1796 } else
nuclear@0	1797 {
nuclear@0	1798 ThrowException( boost::str( boost::format( "Unexpected sub element <%s> in tag <accessor>") % mReader->getNodeName()));
nuclear@0	1799 }
nuclear@0	1800 }
nuclear@0	1801 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	1802 {
nuclear@0	1803 if( strcmp( mReader->getNodeName(), "accessor") != 0)
nuclear@0	1804 ThrowException( "Expected end of <accessor> element.");
nuclear@0	1805 break;
nuclear@0	1806 }
nuclear@0	1807 }
nuclear@0	1808 }
nuclear@0	1809
nuclear@0	1810 // ------------------------------------------------------------------------------------------------
nuclear@0	1811 // Reads input declarations of per-vertex mesh data into the given mesh
nuclear@0	1812 void ColladaParser::ReadVertexData( Mesh* pMesh)
nuclear@0	1813 {
nuclear@0	1814 // extract the ID of the <vertices> element. Not that we care, but to catch strange referencing schemes we should warn about
nuclear@0	1815 int attrID= GetAttribute( "id");
nuclear@0	1816 pMesh->mVertexID = mReader->getAttributeValue( attrID);
nuclear@0	1817
nuclear@0	1818 // a number of <input> elements
nuclear@0	1819 while( mReader->read())
nuclear@0	1820 {
nuclear@0	1821 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	1822 {
nuclear@0	1823 if( IsElement( "input"))
nuclear@0	1824 {
nuclear@0	1825 ReadInputChannel( pMesh->mPerVertexData);
nuclear@0	1826 } else
nuclear@0	1827 {
nuclear@0	1828 ThrowException( boost::str( boost::format( "Unexpected sub element <%s> in tag <vertices>") % mReader->getNodeName()));
nuclear@0	1829 }
nuclear@0	1830 }
nuclear@0	1831 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	1832 {
nuclear@0	1833 if( strcmp( mReader->getNodeName(), "vertices") != 0)
nuclear@0	1834 ThrowException( "Expected end of <vertices> element.");
nuclear@0	1835
nuclear@0	1836 break;
nuclear@0	1837 }
nuclear@0	1838 }
nuclear@0	1839 }
nuclear@0	1840
nuclear@0	1841 // ------------------------------------------------------------------------------------------------
nuclear@0	1842 // Reads input declarations of per-index mesh data into the given mesh
nuclear@0	1843 void ColladaParser::ReadIndexData( Mesh* pMesh)
nuclear@0	1844 {
nuclear@0	1845 std::vector<size_t> vcount;
nuclear@0	1846 std::vector<InputChannel> perIndexData;
nuclear@0	1847
nuclear@0	1848 // read primitive count from the attribute
nuclear@0	1849 int attrCount = GetAttribute( "count");
nuclear@0	1850 size_t numPrimitives = (size_t) mReader->getAttributeValueAsInt( attrCount);
nuclear@0	1851
nuclear@0	1852 // material subgroup
nuclear@0	1853 int attrMaterial = TestAttribute( "material");
nuclear@0	1854 SubMesh subgroup;
nuclear@0	1855 if( attrMaterial > -1)
nuclear@0	1856 subgroup.mMaterial = mReader->getAttributeValue( attrMaterial);
nuclear@0	1857 subgroup.mNumFaces = numPrimitives;
nuclear@0	1858 pMesh->mSubMeshes.push_back( subgroup);
nuclear@0	1859
nuclear@0	1860 // distinguish between polys and triangles
nuclear@0	1861 std::string elementName = mReader->getNodeName();
nuclear@0	1862 PrimitiveType primType = Prim_Invalid;
nuclear@0	1863 if( IsElement( "lines"))
nuclear@0	1864 primType = Prim_Lines;
nuclear@0	1865 else if( IsElement( "linestrips"))
nuclear@0	1866 primType = Prim_LineStrip;
nuclear@0	1867 else if( IsElement( "polygons"))
nuclear@0	1868 primType = Prim_Polygon;
nuclear@0	1869 else if( IsElement( "polylist"))
nuclear@0	1870 primType = Prim_Polylist;
nuclear@0	1871 else if( IsElement( "triangles"))
nuclear@0	1872 primType = Prim_Triangles;
nuclear@0	1873 else if( IsElement( "trifans"))
nuclear@0	1874 primType = Prim_TriFans;
nuclear@0	1875 else if( IsElement( "tristrips"))
nuclear@0	1876 primType = Prim_TriStrips;
nuclear@0	1877
nuclear@0	1878 ai_assert( primType != Prim_Invalid);
nuclear@0	1879
nuclear@0	1880 // also a number of <input> elements, but in addition a <p> primitive collection and propably index counts for all primitives
nuclear@0	1881 while( mReader->read())
nuclear@0	1882 {
nuclear@0	1883 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	1884 {
nuclear@0	1885 if( IsElement( "input"))
nuclear@0	1886 {
nuclear@0	1887 ReadInputChannel( perIndexData);
nuclear@0	1888 }
nuclear@0	1889 else if( IsElement( "vcount"))
nuclear@0	1890 {
nuclear@0	1891 if( !mReader->isEmptyElement())
nuclear@0	1892 {
nuclear@0	1893 if (numPrimitives) // It is possible to define a mesh without any primitives
nuclear@0	1894 {
nuclear@0	1895 // case <polylist> - specifies the number of indices for each polygon
nuclear@0	1896 const char* content = GetTextContent();
nuclear@0	1897 vcount.reserve( numPrimitives);
nuclear@0	1898 for( unsigned int a = 0; a < numPrimitives; a++)
nuclear@0	1899 {
nuclear@0	1900 if( *content == 0)
nuclear@0	1901 ThrowException( "Expected more values while reading <vcount> contents.");
nuclear@0	1902 // read a number
nuclear@0	1903 vcount.push_back( (size_t) strtoul10( content, &content));
nuclear@0	1904 // skip whitespace after it
nuclear@0	1905 SkipSpacesAndLineEnd( &content);
nuclear@0	1906 }
nuclear@0	1907 }
nuclear@0	1908
nuclear@0	1909 TestClosing( "vcount");
nuclear@0	1910 }
nuclear@0	1911 }
nuclear@0	1912 else if( IsElement( "p"))
nuclear@0	1913 {
nuclear@0	1914 if( !mReader->isEmptyElement())
nuclear@0	1915 {
nuclear@0	1916 // now here the actual fun starts - these are the indices to construct the mesh data from
nuclear@0	1917 ReadPrimitives( pMesh, perIndexData, numPrimitives, vcount, primType);
nuclear@0	1918 }
nuclear@0	1919 } else
nuclear@0	1920 {
nuclear@0	1921 ThrowException( boost::str( boost::format( "Unexpected sub element <%s> in tag <%s>") % mReader->getNodeName() % elementName));
nuclear@0	1922 }
nuclear@0	1923 }
nuclear@0	1924 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	1925 {
nuclear@0	1926 if( mReader->getNodeName() != elementName)
nuclear@0	1927 ThrowException( boost::str( boost::format( "Expected end of <%s> element.") % elementName));
nuclear@0	1928
nuclear@0	1929 break;
nuclear@0	1930 }
nuclear@0	1931 }
nuclear@0	1932 }
nuclear@0	1933
nuclear@0	1934 // ------------------------------------------------------------------------------------------------
nuclear@0	1935 // Reads a single input channel element and stores it in the given array, if valid
nuclear@0	1936 void ColladaParser::ReadInputChannel( std::vector<InputChannel>& poChannels)
nuclear@0	1937 {
nuclear@0	1938 InputChannel channel;
nuclear@0	1939
nuclear@0	1940 // read semantic
nuclear@0	1941 int attrSemantic = GetAttribute( "semantic");
nuclear@0	1942 std::string semantic = mReader->getAttributeValue( attrSemantic);
nuclear@0	1943 channel.mType = GetTypeForSemantic( semantic);
nuclear@0	1944
nuclear@0	1945 // read source
nuclear@0	1946 int attrSource = GetAttribute( "source");
nuclear@0	1947 const char* source = mReader->getAttributeValue( attrSource);
nuclear@0	1948 if( source[0] != '#')
nuclear@0	1949 ThrowException( boost::str( boost::format( "Unknown reference format in url \"%s\" in source attribute of <input> element.") % source));
nuclear@0	1950 channel.mAccessor = source+1; // skipping the leading #, hopefully the remaining text is the accessor ID only
nuclear@0	1951
nuclear@0	1952 // read index offset, if per-index <input>
nuclear@0	1953 int attrOffset = TestAttribute( "offset");
nuclear@0	1954 if( attrOffset > -1)
nuclear@0	1955 channel.mOffset = mReader->getAttributeValueAsInt( attrOffset);
nuclear@0	1956
nuclear@0	1957 // read set if texture coordinates
nuclear@0	1958 if(channel.mType == IT_Texcoord \|\| channel.mType == IT_Color){
nuclear@0	1959 int attrSet = TestAttribute("set");
nuclear@0	1960 if(attrSet > -1){
nuclear@0	1961 attrSet = mReader->getAttributeValueAsInt( attrSet);
nuclear@0	1962 if(attrSet < 0)
nuclear@0	1963 ThrowException( boost::str( boost::format( "Invalid index \"%i\" in set attribute of <input> element") % (attrSet)));
nuclear@0	1964
nuclear@0	1965 channel.mIndex = attrSet;
nuclear@0	1966 }
nuclear@0	1967 }
nuclear@0	1968
nuclear@0	1969 // store, if valid type
nuclear@0	1970 if( channel.mType != IT_Invalid)
nuclear@0	1971 poChannels.push_back( channel);
nuclear@0	1972
nuclear@0	1973 // skip remaining stuff of this element, if any
nuclear@0	1974 SkipElement();
nuclear@0	1975 }
nuclear@0	1976
nuclear@0	1977 // ------------------------------------------------------------------------------------------------
nuclear@0	1978 // Reads a <p> primitive index list and assembles the mesh data into the given mesh
nuclear@0	1979 void ColladaParser::ReadPrimitives( Mesh* pMesh, std::vector<InputChannel>& pPerIndexChannels,
nuclear@0	1980 size_t pNumPrimitives, const std::vector<size_t>& pVCount, PrimitiveType pPrimType)
nuclear@0	1981 {
nuclear@0	1982 // determine number of indices coming per vertex
nuclear@0	1983 // find the offset index for all per-vertex channels
nuclear@0	1984 size_t numOffsets = 1;
nuclear@0	1985 size_t perVertexOffset = SIZE_MAX; // invalid value
nuclear@0	1986 BOOST_FOREACH( const InputChannel& channel, pPerIndexChannels)
nuclear@0	1987 {
nuclear@0	1988 numOffsets = std::max( numOffsets, channel.mOffset+1);
nuclear@0	1989 if( channel.mType == IT_Vertex)
nuclear@0	1990 perVertexOffset = channel.mOffset;
nuclear@0	1991 }
nuclear@0	1992
nuclear@0	1993 // determine the expected number of indices
nuclear@0	1994 size_t expectedPointCount = 0;
nuclear@0	1995 switch( pPrimType)
nuclear@0	1996 {
nuclear@0	1997 case Prim_Polylist:
nuclear@0	1998 {
nuclear@0	1999 BOOST_FOREACH( size_t i, pVCount)
nuclear@0	2000 expectedPointCount += i;
nuclear@0	2001 break;
nuclear@0	2002 }
nuclear@0	2003 case Prim_Lines:
nuclear@0	2004 expectedPointCount = 2 * pNumPrimitives;
nuclear@0	2005 break;
nuclear@0	2006 case Prim_Triangles:
nuclear@0	2007 expectedPointCount = 3 * pNumPrimitives;
nuclear@0	2008 break;
nuclear@0	2009 default:
nuclear@0	2010 // other primitive types don't state the index count upfront... we need to guess
nuclear@0	2011 break;
nuclear@0	2012 }
nuclear@0	2013
nuclear@0	2014 // and read all indices into a temporary array
nuclear@0	2015 std::vector<size_t> indices;
nuclear@0	2016 if( expectedPointCount > 0)
nuclear@0	2017 indices.reserve( expectedPointCount * numOffsets);
nuclear@0	2018
nuclear@0	2019 if (pNumPrimitives > 0) // It is possible to not contain any indicies
nuclear@0	2020 {
nuclear@0	2021 const char* content = GetTextContent();
nuclear@0	2022 while( *content != 0)
nuclear@0	2023 {
nuclear@0	2024 // read a value.
nuclear@0	2025 // Hack: (thom) Some exporters put negative indices sometimes. We just try to carry on anyways.
nuclear@0	2026 int value = std::max( 0, strtol10( content, &content));
nuclear@0	2027 indices.push_back( size_t( value));
nuclear@0	2028 // skip whitespace after it
nuclear@0	2029 SkipSpacesAndLineEnd( &content);
nuclear@0	2030 }
nuclear@0	2031 }
nuclear@0	2032
nuclear@0	2033 // complain if the index count doesn't fit
nuclear@0	2034 if( expectedPointCount > 0 && indices.size() != expectedPointCount * numOffsets)
nuclear@0	2035 ThrowException( "Expected different index count in <p> element.");
nuclear@0	2036 else if( expectedPointCount == 0 && (indices.size() % numOffsets) != 0)
nuclear@0	2037 ThrowException( "Expected different index count in <p> element.");
nuclear@0	2038
nuclear@0	2039 // find the data for all sources
nuclear@0	2040 for( std::vector<InputChannel>::iterator it = pMesh->mPerVertexData.begin(); it != pMesh->mPerVertexData.end(); ++it)
nuclear@0	2041 {
nuclear@0	2042 InputChannel& input = *it;
nuclear@0	2043 if( input.mResolved)
nuclear@0	2044 continue;
nuclear@0	2045
nuclear@0	2046 // find accessor
nuclear@0	2047 input.mResolved = &ResolveLibraryReference( mAccessorLibrary, input.mAccessor);
nuclear@0	2048 // resolve accessor's data pointer as well, if neccessary
nuclear@0	2049 const Accessor* acc = input.mResolved;
nuclear@0	2050 if( !acc->mData)
nuclear@0	2051 acc->mData = &ResolveLibraryReference( mDataLibrary, acc->mSource);
nuclear@0	2052 }
nuclear@0	2053 // and the same for the per-index channels
nuclear@0	2054 for( std::vector<InputChannel>::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it)
nuclear@0	2055 {
nuclear@0	2056 InputChannel& input = *it;
nuclear@0	2057 if( input.mResolved)
nuclear@0	2058 continue;
nuclear@0	2059
nuclear@0	2060 // ignore vertex pointer, it doesn't refer to an accessor
nuclear@0	2061 if( input.mType == IT_Vertex)
nuclear@0	2062 {
nuclear@0	2063 // warn if the vertex channel does not refer to the <vertices> element in the same mesh
nuclear@0	2064 if( input.mAccessor != pMesh->mVertexID)
nuclear@0	2065 ThrowException( "Unsupported vertex referencing scheme.");
nuclear@0	2066 continue;
nuclear@0	2067 }
nuclear@0	2068
nuclear@0	2069 // find accessor
nuclear@0	2070 input.mResolved = &ResolveLibraryReference( mAccessorLibrary, input.mAccessor);
nuclear@0	2071 // resolve accessor's data pointer as well, if neccessary
nuclear@0	2072 const Accessor* acc = input.mResolved;
nuclear@0	2073 if( !acc->mData)
nuclear@0	2074 acc->mData = &ResolveLibraryReference( mDataLibrary, acc->mSource);
nuclear@0	2075 }
nuclear@0	2076
nuclear@0	2077
nuclear@0	2078 // now assemble vertex data according to those indices
nuclear@0	2079 std::vector<size_t>::const_iterator idx = indices.begin();
nuclear@0	2080
nuclear@0	2081 // For continued primitives, the given count does not come all in one <p>, but only one primitive per <p>
nuclear@0	2082 size_t numPrimitives = pNumPrimitives;
nuclear@0	2083 if( pPrimType == Prim_TriFans \|\| pPrimType == Prim_Polygon)
nuclear@0	2084 numPrimitives = 1;
nuclear@0	2085
nuclear@0	2086 pMesh->mFaceSize.reserve( numPrimitives);
nuclear@0	2087 pMesh->mFacePosIndices.reserve( indices.size() / numOffsets);
nuclear@0	2088
nuclear@0	2089 for( size_t a = 0; a < numPrimitives; a++)
nuclear@0	2090 {
nuclear@0	2091 // determine number of points for this primitive
nuclear@0	2092 size_t numPoints = 0;
nuclear@0	2093 switch( pPrimType)
nuclear@0	2094 {
nuclear@0	2095 case Prim_Lines:
nuclear@0	2096 numPoints = 2;
nuclear@0	2097 break;
nuclear@0	2098 case Prim_Triangles:
nuclear@0	2099 numPoints = 3;
nuclear@0	2100 break;
nuclear@0	2101 case Prim_Polylist:
nuclear@0	2102 numPoints = pVCount[a];
nuclear@0	2103 break;
nuclear@0	2104 case Prim_TriFans:
nuclear@0	2105 case Prim_Polygon:
nuclear@0	2106 numPoints = indices.size() / numOffsets;
nuclear@0	2107 break;
nuclear@0	2108 default:
nuclear@0	2109 // LineStrip and TriStrip not supported due to expected index unmangling
nuclear@0	2110 ThrowException( "Unsupported primitive type.");
nuclear@0	2111 break;
nuclear@0	2112 }
nuclear@0	2113
nuclear@0	2114 // store the face size to later reconstruct the face from
nuclear@0	2115 pMesh->mFaceSize.push_back( numPoints);
nuclear@0	2116
nuclear@0	2117 // gather that number of vertices
nuclear@0	2118 for( size_t b = 0; b < numPoints; b++)
nuclear@0	2119 {
nuclear@0	2120 // read all indices for this vertex. Yes, in a hacky local array
nuclear@0	2121 ai_assert( numOffsets < 20 && perVertexOffset < 20);
nuclear@0	2122 size_t vindex[20];
nuclear@0	2123 for( size_t offsets = 0; offsets < numOffsets; ++offsets)
nuclear@0	2124 vindex[offsets] = *idx++;
nuclear@0	2125
nuclear@0	2126 // extract per-vertex channels using the global per-vertex offset
nuclear@0	2127 for( std::vector<InputChannel>::iterator it = pMesh->mPerVertexData.begin(); it != pMesh->mPerVertexData.end(); ++it)
nuclear@0	2128 ExtractDataObjectFromChannel( *it, vindex[perVertexOffset], pMesh);
nuclear@0	2129 // and extract per-index channels using there specified offset
nuclear@0	2130 for( std::vector<InputChannel>::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it)
nuclear@0	2131 ExtractDataObjectFromChannel( *it, vindex[it->mOffset], pMesh);
nuclear@0	2132
nuclear@0	2133 // store the vertex-data index for later assignment of bone vertex weights
nuclear@0	2134 pMesh->mFacePosIndices.push_back( vindex[perVertexOffset]);
nuclear@0	2135 }
nuclear@0	2136 }
nuclear@0	2137
nuclear@0	2138
nuclear@0	2139 // if I ever get my hands on that guy who invented this steaming pile of indirection...
nuclear@0	2140 TestClosing( "p");
nuclear@0	2141 }
nuclear@0	2142
nuclear@0	2143 // ------------------------------------------------------------------------------------------------
nuclear@0	2144 // Extracts a single object from an input channel and stores it in the appropriate mesh data array
nuclear@0	2145 void ColladaParser::ExtractDataObjectFromChannel( const InputChannel& pInput, size_t pLocalIndex, Mesh* pMesh)
nuclear@0	2146 {
nuclear@0	2147 // ignore vertex referrer - we handle them that separate
nuclear@0	2148 if( pInput.mType == IT_Vertex)
nuclear@0	2149 return;
nuclear@0	2150
nuclear@0	2151 const Accessor& acc = *pInput.mResolved;
nuclear@0	2152 if( pLocalIndex >= acc.mCount)
nuclear@0	2153 ThrowException( boost::str( boost::format( "Invalid data index (%d/%d) in primitive specification") % pLocalIndex % acc.mCount));
nuclear@0	2154
nuclear@0	2155 // get a pointer to the start of the data object referred to by the accessor and the local index
nuclear@0	2156 const float* dataObject = &(acc.mData->mValues[0]) + acc.mOffset + pLocalIndex* acc.mStride;
nuclear@0	2157
nuclear@0	2158 // assemble according to the accessors component sub-offset list. We don't care, yet,
nuclear@0	2159 // what kind of object exactly we're extracting here
nuclear@0	2160 float obj[4];
nuclear@0	2161 for( size_t c = 0; c < 4; ++c)
nuclear@0	2162 obj[c] = dataObject[acc.mSubOffset[c]];
nuclear@0	2163
nuclear@0	2164 // now we reinterpret it according to the type we're reading here
nuclear@0	2165 switch( pInput.mType)
nuclear@0	2166 {
nuclear@0	2167 case IT_Position: // ignore all position streams except 0 - there can be only one position
nuclear@0	2168 if( pInput.mIndex == 0)
nuclear@0	2169 pMesh->mPositions.push_back( aiVector3D( obj[0], obj[1], obj[2]));
nuclear@0	2170 else
nuclear@0	2171 DefaultLogger::get()->error("Collada: just one vertex position stream supported");
nuclear@0	2172 break;
nuclear@0	2173 case IT_Normal:
nuclear@0	2174 // pad to current vertex count if necessary
nuclear@0	2175 if( pMesh->mNormals.size() < pMesh->mPositions.size()-1)
nuclear@0	2176 pMesh->mNormals.insert( pMesh->mNormals.end(), pMesh->mPositions.size() - pMesh->mNormals.size() - 1, aiVector3D( 0, 1, 0));
nuclear@0	2177
nuclear@0	2178 // ignore all normal streams except 0 - there can be only one normal
nuclear@0	2179 if( pInput.mIndex == 0)
nuclear@0	2180 pMesh->mNormals.push_back( aiVector3D( obj[0], obj[1], obj[2]));
nuclear@0	2181 else
nuclear@0	2182 DefaultLogger::get()->error("Collada: just one vertex normal stream supported");
nuclear@0	2183 break;
nuclear@0	2184 case IT_Tangent:
nuclear@0	2185 // pad to current vertex count if necessary
nuclear@0	2186 if( pMesh->mTangents.size() < pMesh->mPositions.size()-1)
nuclear@0	2187 pMesh->mTangents.insert( pMesh->mTangents.end(), pMesh->mPositions.size() - pMesh->mTangents.size() - 1, aiVector3D( 1, 0, 0));
nuclear@0	2188
nuclear@0	2189 // ignore all tangent streams except 0 - there can be only one tangent
nuclear@0	2190 if( pInput.mIndex == 0)
nuclear@0	2191 pMesh->mTangents.push_back( aiVector3D( obj[0], obj[1], obj[2]));
nuclear@0	2192 else
nuclear@0	2193 DefaultLogger::get()->error("Collada: just one vertex tangent stream supported");
nuclear@0	2194 break;
nuclear@0	2195 case IT_Bitangent:
nuclear@0	2196 // pad to current vertex count if necessary
nuclear@0	2197 if( pMesh->mBitangents.size() < pMesh->mPositions.size()-1)
nuclear@0	2198 pMesh->mBitangents.insert( pMesh->mBitangents.end(), pMesh->mPositions.size() - pMesh->mBitangents.size() - 1, aiVector3D( 0, 0, 1));
nuclear@0	2199
nuclear@0	2200 // ignore all bitangent streams except 0 - there can be only one bitangent
nuclear@0	2201 if( pInput.mIndex == 0)
nuclear@0	2202 pMesh->mBitangents.push_back( aiVector3D( obj[0], obj[1], obj[2]));
nuclear@0	2203 else
nuclear@0	2204 DefaultLogger::get()->error("Collada: just one vertex bitangent stream supported");
nuclear@0	2205 break;
nuclear@0	2206 case IT_Texcoord:
nuclear@0	2207 // up to 4 texture coord sets are fine, ignore the others
nuclear@0	2208 if( pInput.mIndex < AI_MAX_NUMBER_OF_TEXTURECOORDS)
nuclear@0	2209 {
nuclear@0	2210 // pad to current vertex count if necessary
nuclear@0	2211 if( pMesh->mTexCoords[pInput.mIndex].size() < pMesh->mPositions.size()-1)
nuclear@0	2212 pMesh->mTexCoords[pInput.mIndex].insert( pMesh->mTexCoords[pInput.mIndex].end(),
nuclear@0	2213 pMesh->mPositions.size() - pMesh->mTexCoords[pInput.mIndex].size() - 1, aiVector3D( 0, 0, 0));
nuclear@0	2214
nuclear@0	2215 pMesh->mTexCoords[pInput.mIndex].push_back( aiVector3D( obj[0], obj[1], obj[2]));
nuclear@0	2216 if (0 != acc.mSubOffset[2] \|\| 0 != acc.mSubOffset[3]) /* hack ... consider cleaner solution */
nuclear@0	2217 pMesh->mNumUVComponents[pInput.mIndex]=3;
nuclear@0	2218 } else
nuclear@0	2219 {
nuclear@0	2220 DefaultLogger::get()->error("Collada: too many texture coordinate sets. Skipping.");
nuclear@0	2221 }
nuclear@0	2222 break;
nuclear@0	2223 case IT_Color:
nuclear@0	2224 // up to 4 color sets are fine, ignore the others
nuclear@0	2225 if( pInput.mIndex < AI_MAX_NUMBER_OF_COLOR_SETS)
nuclear@0	2226 {
nuclear@0	2227 // pad to current vertex count if necessary
nuclear@0	2228 if( pMesh->mColors[pInput.mIndex].size() < pMesh->mPositions.size()-1)
nuclear@0	2229 pMesh->mColors[pInput.mIndex].insert( pMesh->mColors[pInput.mIndex].end(),
nuclear@0	2230 pMesh->mPositions.size() - pMesh->mColors[pInput.mIndex].size() - 1, aiColor4D( 0, 0, 0, 1));
nuclear@0	2231
nuclear@0	2232 aiColor4D result(0, 0, 0, 1);
nuclear@0	2233 for (size_t i = 0; i < pInput.mResolved->mSize; ++i)
nuclear@0	2234 {
nuclear@0	2235 result[i] = obj[pInput.mResolved->mSubOffset[i]];
nuclear@0	2236 }
nuclear@0	2237 pMesh->mColors[pInput.mIndex].push_back(result);
nuclear@0	2238 } else
nuclear@0	2239 {
nuclear@0	2240 DefaultLogger::get()->error("Collada: too many vertex color sets. Skipping.");
nuclear@0	2241 }
nuclear@0	2242
nuclear@0	2243 break;
nuclear@0	2244 default:
nuclear@0	2245 // IT_Invalid and IT_Vertex
nuclear@0	2246 ai_assert(false && "shouldn't ever get here");
nuclear@0	2247 }
nuclear@0	2248 }
nuclear@0	2249
nuclear@0	2250 // ------------------------------------------------------------------------------------------------
nuclear@0	2251 // Reads the library of node hierarchies and scene parts
nuclear@0	2252 void ColladaParser::ReadSceneLibrary()
nuclear@0	2253 {
nuclear@0	2254 if( mReader->isEmptyElement())
nuclear@0	2255 return;
nuclear@0	2256
nuclear@0	2257 while( mReader->read())
nuclear@0	2258 {
nuclear@0	2259 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	2260 {
nuclear@0	2261 // a visual scene - generate root node under its ID and let ReadNode() do the recursive work
nuclear@0	2262 if( IsElement( "visual_scene"))
nuclear@0	2263 {
nuclear@0	2264 // read ID. Is optional according to the spec, but how on earth should a scene_instance refer to it then?
nuclear@0	2265 int indexID = GetAttribute( "id");
nuclear@0	2266 const char* attrID = mReader->getAttributeValue( indexID);
nuclear@0	2267
nuclear@0	2268 // read name if given.
nuclear@0	2269 int indexName = TestAttribute( "name");
nuclear@0	2270 const char* attrName = "unnamed";
nuclear@0	2271 if( indexName > -1)
nuclear@0	2272 attrName = mReader->getAttributeValue( indexName);
nuclear@0	2273
nuclear@0	2274 // create a node and store it in the library under its ID
nuclear@0	2275 Node* node = new Node;
nuclear@0	2276 node->mID = attrID;
nuclear@0	2277 node->mName = attrName;
nuclear@0	2278 mNodeLibrary[node->mID] = node;
nuclear@0	2279
nuclear@0	2280 ReadSceneNode( node);
nuclear@0	2281 } else
nuclear@0	2282 {
nuclear@0	2283 // ignore the rest
nuclear@0	2284 SkipElement();
nuclear@0	2285 }
nuclear@0	2286 }
nuclear@0	2287 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	2288 {
nuclear@0	2289 if( strcmp( mReader->getNodeName(), "library_visual_scenes") == 0)
nuclear@0	2290 //ThrowException( "Expected end of \"library_visual_scenes\" element.");
nuclear@0	2291
nuclear@0	2292 break;
nuclear@0	2293 }
nuclear@0	2294 }
nuclear@0	2295 }
nuclear@0	2296
nuclear@0	2297 // ------------------------------------------------------------------------------------------------
nuclear@0	2298 // Reads a scene node's contents including children and stores it in the given node
nuclear@0	2299 void ColladaParser::ReadSceneNode( Node* pNode)
nuclear@0	2300 {
nuclear@0	2301 // quit immediately on <bla/> elements
nuclear@0	2302 if( mReader->isEmptyElement())
nuclear@0	2303 return;
nuclear@0	2304
nuclear@0	2305 while( mReader->read())
nuclear@0	2306 {
nuclear@0	2307 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	2308 {
nuclear@0	2309 if( IsElement( "node"))
nuclear@0	2310 {
nuclear@0	2311 Node* child = new Node;
nuclear@0	2312 int attrID = TestAttribute( "id");
nuclear@0	2313 if( attrID > -1)
nuclear@0	2314 child->mID = mReader->getAttributeValue( attrID);
nuclear@0	2315 int attrSID = TestAttribute( "sid");
nuclear@0	2316 if( attrSID > -1)
nuclear@0	2317 child->mSID = mReader->getAttributeValue( attrSID);
nuclear@0	2318
nuclear@0	2319 int attrName = TestAttribute( "name");
nuclear@0	2320 if( attrName > -1)
nuclear@0	2321 child->mName = mReader->getAttributeValue( attrName);
nuclear@0	2322
nuclear@0	2323 // TODO: (thom) support SIDs
nuclear@0	2324 // ai_assert( TestAttribute( "sid") == -1);
nuclear@0	2325
nuclear@0	2326 if (pNode)
nuclear@0	2327 {
nuclear@0	2328 pNode->mChildren.push_back( child);
nuclear@0	2329 child->mParent = pNode;
nuclear@0	2330 }
nuclear@0	2331 else
nuclear@0	2332 {
nuclear@0	2333 // no parent node given, probably called from <library_nodes> element.
nuclear@0	2334 // create new node in node library
nuclear@0	2335 mNodeLibrary[child->mID] = child;
nuclear@0	2336 }
nuclear@0	2337
nuclear@0	2338 // read on recursively from there
nuclear@0	2339 ReadSceneNode( child);
nuclear@0	2340 continue;
nuclear@0	2341 }
nuclear@0	2342 // For any further stuff we need a valid node to work on
nuclear@0	2343 else if (!pNode)
nuclear@0	2344 continue;
nuclear@0	2345
nuclear@0	2346 if( IsElement( "lookat"))
nuclear@0	2347 ReadNodeTransformation( pNode, TF_LOOKAT);
nuclear@0	2348 else if( IsElement( "matrix"))
nuclear@0	2349 ReadNodeTransformation( pNode, TF_MATRIX);
nuclear@0	2350 else if( IsElement( "rotate"))
nuclear@0	2351 ReadNodeTransformation( pNode, TF_ROTATE);
nuclear@0	2352 else if( IsElement( "scale"))
nuclear@0	2353 ReadNodeTransformation( pNode, TF_SCALE);
nuclear@0	2354 else if( IsElement( "skew"))
nuclear@0	2355 ReadNodeTransformation( pNode, TF_SKEW);
nuclear@0	2356 else if( IsElement( "translate"))
nuclear@0	2357 ReadNodeTransformation( pNode, TF_TRANSLATE);
nuclear@0	2358 else if( IsElement( "render") && pNode->mParent == NULL && 0 == pNode->mPrimaryCamera.length())
nuclear@0	2359 {
nuclear@0	2360 // ... scene evaluation or, in other words, postprocessing pipeline,
nuclear@0	2361 // or, again in other words, a turing-complete description how to
nuclear@0	2362 // render a Collada scene. The only thing that is interesting for
nuclear@0	2363 // us is the primary camera.
nuclear@0	2364 int attrId = TestAttribute("camera_node");
nuclear@0	2365 if (-1 != attrId)
nuclear@0	2366 {
nuclear@0	2367 const char* s = mReader->getAttributeValue(attrId);
nuclear@0	2368 if (s[0] != '#')
nuclear@0	2369 DefaultLogger::get()->error("Collada: Unresolved reference format of camera");
nuclear@0	2370 else
nuclear@0	2371 pNode->mPrimaryCamera = s+1;
nuclear@0	2372 }
nuclear@0	2373 }
nuclear@0	2374 else if( IsElement( "instance_node"))
nuclear@0	2375 {
nuclear@0	2376 // find the node in the library
nuclear@0	2377 int attrID = TestAttribute( "url");
nuclear@0	2378 if( attrID != -1)
nuclear@0	2379 {
nuclear@0	2380 const char* s = mReader->getAttributeValue(attrID);
nuclear@0	2381 if (s[0] != '#')
nuclear@0	2382 DefaultLogger::get()->error("Collada: Unresolved reference format of node");
nuclear@0	2383 else
nuclear@0	2384 {
nuclear@0	2385 pNode->mNodeInstances.push_back(NodeInstance());
nuclear@0	2386 pNode->mNodeInstances.back().mNode = s+1;
nuclear@0	2387 }
nuclear@0	2388 }
nuclear@0	2389 }
nuclear@0	2390 else if( IsElement( "instance_geometry") \|\| IsElement( "instance_controller"))
nuclear@0	2391 {
nuclear@0	2392 // Reference to a mesh or controller, with possible material associations
nuclear@0	2393 ReadNodeGeometry( pNode);
nuclear@0	2394 }
nuclear@0	2395 else if( IsElement( "instance_light"))
nuclear@0	2396 {
nuclear@0	2397 // Reference to a light, name given in 'url' attribute
nuclear@0	2398 int attrID = TestAttribute("url");
nuclear@0	2399 if (-1 == attrID)
nuclear@0	2400 DefaultLogger::get()->warn("Collada: Expected url attribute in <instance_light> element");
nuclear@0	2401 else
nuclear@0	2402 {
nuclear@0	2403 const char* url = mReader->getAttributeValue( attrID);
nuclear@0	2404 if( url[0] != '#')
nuclear@0	2405 ThrowException( "Unknown reference format in <instance_light> element");
nuclear@0	2406
nuclear@0	2407 pNode->mLights.push_back(LightInstance());
nuclear@0	2408 pNode->mLights.back().mLight = url+1;
nuclear@0	2409 }
nuclear@0	2410 }
nuclear@0	2411 else if( IsElement( "instance_camera"))
nuclear@0	2412 {
nuclear@0	2413 // Reference to a camera, name given in 'url' attribute
nuclear@0	2414 int attrID = TestAttribute("url");
nuclear@0	2415 if (-1 == attrID)
nuclear@0	2416 DefaultLogger::get()->warn("Collada: Expected url attribute in <instance_camera> element");
nuclear@0	2417 else
nuclear@0	2418 {
nuclear@0	2419 const char* url = mReader->getAttributeValue( attrID);
nuclear@0	2420 if( url[0] != '#')
nuclear@0	2421 ThrowException( "Unknown reference format in <instance_camera> element");
nuclear@0	2422
nuclear@0	2423 pNode->mCameras.push_back(CameraInstance());
nuclear@0	2424 pNode->mCameras.back().mCamera = url+1;
nuclear@0	2425 }
nuclear@0	2426 }
nuclear@0	2427 else
nuclear@0	2428 {
nuclear@0	2429 // skip everything else for the moment
nuclear@0	2430 SkipElement();
nuclear@0	2431 }
nuclear@0	2432 }
nuclear@0	2433 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
nuclear@0	2434 break;
nuclear@0	2435 }
nuclear@0	2436 }
nuclear@0	2437 }
nuclear@0	2438
nuclear@0	2439 // ------------------------------------------------------------------------------------------------
nuclear@0	2440 // Reads a node transformation entry of the given type and adds it to the given node's transformation list.
nuclear@0	2441 void ColladaParser::ReadNodeTransformation( Node* pNode, TransformType pType)
nuclear@0	2442 {
nuclear@0	2443 if( mReader->isEmptyElement())
nuclear@0	2444 return;
nuclear@0	2445
nuclear@0	2446 std::string tagName = mReader->getNodeName();
nuclear@0	2447
nuclear@0	2448 Transform tf;
nuclear@0	2449 tf.mType = pType;
nuclear@0	2450
nuclear@0	2451 // read SID
nuclear@0	2452 int indexSID = TestAttribute( "sid");
nuclear@0	2453 if( indexSID >= 0)
nuclear@0	2454 tf.mID = mReader->getAttributeValue( indexSID);
nuclear@0	2455
nuclear@0	2456 // how many parameters to read per transformation type
nuclear@0	2457 static const unsigned int sNumParameters[] = { 9, 4, 3, 3, 7, 16 };
nuclear@0	2458 const char* content = GetTextContent();
nuclear@0	2459
nuclear@0	2460 // read as many parameters and store in the transformation
nuclear@0	2461 for( unsigned int a = 0; a < sNumParameters[pType]; a++)
nuclear@0	2462 {
nuclear@0	2463 // read a number
nuclear@0	2464 content = fast_atoreal_move<float>( content, tf.f[a]);
nuclear@0	2465 // skip whitespace after it
nuclear@0	2466 SkipSpacesAndLineEnd( &content);
nuclear@0	2467 }
nuclear@0	2468
nuclear@0	2469 // place the transformation at the queue of the node
nuclear@0	2470 pNode->mTransforms.push_back( tf);
nuclear@0	2471
nuclear@0	2472 // and consume the closing tag
nuclear@0	2473 TestClosing( tagName.c_str());
nuclear@0	2474 }
nuclear@0	2475
nuclear@0	2476 // ------------------------------------------------------------------------------------------------
nuclear@0	2477 // Processes bind_vertex_input and bind elements
nuclear@0	2478 void ColladaParser::ReadMaterialVertexInputBinding( Collada::SemanticMappingTable& tbl)
nuclear@0	2479 {
nuclear@0	2480 while( mReader->read())
nuclear@0	2481 {
nuclear@0	2482 if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
nuclear@0	2483 if( IsElement( "bind_vertex_input"))
nuclear@0	2484 {
nuclear@0	2485 Collada::InputSemanticMapEntry vn;
nuclear@0	2486
nuclear@0	2487 // effect semantic
nuclear@0	2488 int n = GetAttribute("semantic");
nuclear@0	2489 std::string s = mReader->getAttributeValue(n);
nuclear@0	2490
nuclear@0	2491 // input semantic
nuclear@0	2492 n = GetAttribute("input_semantic");
nuclear@0	2493 vn.mType = GetTypeForSemantic( mReader->getAttributeValue(n) );
nuclear@0	2494
nuclear@0	2495 // index of input set
nuclear@0	2496 n = TestAttribute("input_set");
nuclear@0	2497 if (-1 != n)
nuclear@0	2498 vn.mSet = mReader->getAttributeValueAsInt(n);
nuclear@0	2499
nuclear@0	2500 tbl.mMap[s] = vn;
nuclear@0	2501 }
nuclear@0	2502 else if( IsElement( "bind")) {
nuclear@0	2503 DefaultLogger::get()->warn("Collada: Found unsupported <bind> element");
nuclear@0	2504 }
nuclear@0	2505 }
nuclear@0	2506 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
nuclear@0	2507 if( strcmp( mReader->getNodeName(), "instance_material") == 0)
nuclear@0	2508 break;
nuclear@0	2509 }
nuclear@0	2510 }
nuclear@0	2511 }
nuclear@0	2512
nuclear@0	2513 // ------------------------------------------------------------------------------------------------
nuclear@0	2514 // Reads a mesh reference in a node and adds it to the node's mesh list
nuclear@0	2515 void ColladaParser::ReadNodeGeometry( Node* pNode)
nuclear@0	2516 {
nuclear@0	2517 // referred mesh is given as an attribute of the <instance_geometry> element
nuclear@0	2518 int attrUrl = GetAttribute( "url");
nuclear@0	2519 const char* url = mReader->getAttributeValue( attrUrl);
nuclear@0	2520 if( url[0] != '#')
nuclear@0	2521 ThrowException( "Unknown reference format");
nuclear@0	2522
nuclear@0	2523 Collada::MeshInstance instance;
nuclear@0	2524 instance.mMeshOrController = url+1; // skipping the leading #
nuclear@0	2525
nuclear@0	2526 if( !mReader->isEmptyElement())
nuclear@0	2527 {
nuclear@0	2528 // read material associations. Ignore additional elements inbetween
nuclear@0	2529 while( mReader->read())
nuclear@0	2530 {
nuclear@0	2531 if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
nuclear@0	2532 {
nuclear@0	2533 if( IsElement( "instance_material"))
nuclear@0	2534 {
nuclear@0	2535 // read ID of the geometry subgroup and the target material
nuclear@0	2536 int attrGroup = GetAttribute( "symbol");
nuclear@0	2537 std::string group = mReader->getAttributeValue( attrGroup);
nuclear@0	2538 int attrMaterial = GetAttribute( "target");
nuclear@0	2539 const char* urlMat = mReader->getAttributeValue( attrMaterial);
nuclear@0	2540 Collada::SemanticMappingTable s;
nuclear@0	2541 if( urlMat[0] == '#')
nuclear@0	2542 urlMat++;
nuclear@0	2543
nuclear@0	2544 s.mMatName = urlMat;
nuclear@0	2545
nuclear@0	2546 // resolve further material details + THIS UGLY AND NASTY semantic mapping stuff
nuclear@0	2547 if( !mReader->isEmptyElement())
nuclear@0	2548 ReadMaterialVertexInputBinding(s);
nuclear@0	2549
nuclear@0	2550 // store the association
nuclear@0	2551 instance.mMaterials[group] = s;
nuclear@0	2552 }
nuclear@0	2553 }
nuclear@0	2554 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	2555 {
nuclear@0	2556 if( strcmp( mReader->getNodeName(), "instance_geometry") == 0
nuclear@0	2557 \|\| strcmp( mReader->getNodeName(), "instance_controller") == 0)
nuclear@0	2558 break;
nuclear@0	2559 }
nuclear@0	2560 }
nuclear@0	2561 }
nuclear@0	2562
nuclear@0	2563 // store it
nuclear@0	2564 pNode->mMeshes.push_back( instance);
nuclear@0	2565 }
nuclear@0	2566
nuclear@0	2567 // ------------------------------------------------------------------------------------------------
nuclear@0	2568 // Reads the collada scene
nuclear@0	2569 void ColladaParser::ReadScene()
nuclear@0	2570 {
nuclear@0	2571 if( mReader->isEmptyElement())
nuclear@0	2572 return;
nuclear@0	2573
nuclear@0	2574 while( mReader->read())
nuclear@0	2575 {
nuclear@0	2576 if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
nuclear@0	2577 if( IsElement( "instance_visual_scene"))
nuclear@0	2578 {
nuclear@0	2579 // should be the first and only occurence
nuclear@0	2580 if( mRootNode)
nuclear@0	2581 ThrowException( "Invalid scene containing multiple root nodes in <instance_visual_scene> element");
nuclear@0	2582
nuclear@0	2583 // read the url of the scene to instance. Should be of format "#some_name"
nuclear@0	2584 int urlIndex = GetAttribute( "url");
nuclear@0	2585 const char* url = mReader->getAttributeValue( urlIndex);
nuclear@0	2586 if( url[0] != '#')
nuclear@0	2587 ThrowException( "Unknown reference format in <instance_visual_scene> element");
nuclear@0	2588
nuclear@0	2589 // find the referred scene, skip the leading #
nuclear@0	2590 NodeLibrary::const_iterator sit = mNodeLibrary.find( url+1);
nuclear@0	2591 if( sit == mNodeLibrary.end())
nuclear@0	2592 ThrowException( "Unable to resolve visual_scene reference \"" + std::string(url) + "\" in <instance_visual_scene> element.");
nuclear@0	2593 mRootNode = sit->second;
nuclear@0	2594 } else {
nuclear@0	2595 SkipElement();
nuclear@0	2596 }
nuclear@0	2597 }
nuclear@0	2598 else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END){
nuclear@0	2599 break;
nuclear@0	2600 }
nuclear@0	2601 }
nuclear@0	2602 }
nuclear@0	2603
nuclear@0	2604 // ------------------------------------------------------------------------------------------------
nuclear@0	2605 // Aborts the file reading with an exception
nuclear@0	2606 void ColladaParser::ThrowException( const std::string& pError) const
nuclear@0	2607 {
nuclear@0	2608 throw DeadlyImportError( boost::str( boost::format( "Collada: %s - %s") % mFileName % pError));
nuclear@0	2609 }
nuclear@0	2610
nuclear@0	2611 // ------------------------------------------------------------------------------------------------
nuclear@0	2612 // Skips all data until the end node of the current element
nuclear@0	2613 void ColladaParser::SkipElement()
nuclear@0	2614 {
nuclear@0	2615 // nothing to skip if it's an <element />
nuclear@0	2616 if( mReader->isEmptyElement())
nuclear@0	2617 return;
nuclear@0	2618
nuclear@0	2619 // reroute
nuclear@0	2620 SkipElement( mReader->getNodeName());
nuclear@0	2621 }
nuclear@0	2622
nuclear@0	2623 // ------------------------------------------------------------------------------------------------
nuclear@0	2624 // Skips all data until the end node of the given element
nuclear@0	2625 void ColladaParser::SkipElement( const char* pElement)
nuclear@0	2626 {
nuclear@0	2627 // copy the current node's name because it'a pointer to the reader's internal buffer,
nuclear@0	2628 // which is going to change with the upcoming parsing
nuclear@0	2629 std::string element = pElement;
nuclear@0	2630 while( mReader->read())
nuclear@0	2631 {
nuclear@0	2632 if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
nuclear@0	2633 if( mReader->getNodeName() == element)
nuclear@0	2634 break;
nuclear@0	2635 }
nuclear@0	2636 }
nuclear@0	2637
nuclear@0	2638 // ------------------------------------------------------------------------------------------------
nuclear@0	2639 // Tests for an opening element of the given name, throws an exception if not found
nuclear@0	2640 void ColladaParser::TestOpening( const char* pName)
nuclear@0	2641 {
nuclear@0	2642 // read element start
nuclear@0	2643 if( !mReader->read())
nuclear@0	2644 ThrowException( boost::str( boost::format( "Unexpected end of file while beginning of <%s> element.") % pName));
nuclear@0	2645 // whitespace in front is ok, just read again if found
nuclear@0	2646 if( mReader->getNodeType() == irr::io::EXN_TEXT)
nuclear@0	2647 if( !mReader->read())
nuclear@0	2648 ThrowException( boost::str( boost::format( "Unexpected end of file while reading beginning of <%s> element.") % pName));
nuclear@0	2649
nuclear@0	2650 if( mReader->getNodeType() != irr::io::EXN_ELEMENT \|\| strcmp( mReader->getNodeName(), pName) != 0)
nuclear@0	2651 ThrowException( boost::str( boost::format( "Expected start of <%s> element.") % pName));
nuclear@0	2652 }
nuclear@0	2653
nuclear@0	2654 // ------------------------------------------------------------------------------------------------
nuclear@0	2655 // Tests for the closing tag of the given element, throws an exception if not found
nuclear@0	2656 void ColladaParser::TestClosing( const char* pName)
nuclear@0	2657 {
nuclear@0	2658 // check if we're already on the closing tag and return right away
nuclear@0	2659 if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END && strcmp( mReader->getNodeName(), pName) == 0)
nuclear@0	2660 return;
nuclear@0	2661
nuclear@0	2662 // if not, read some more
nuclear@0	2663 if( !mReader->read())
nuclear@0	2664 ThrowException( boost::str( boost::format( "Unexpected end of file while reading end of <%s> element.") % pName));
nuclear@0	2665 // whitespace in front is ok, just read again if found
nuclear@0	2666 if( mReader->getNodeType() == irr::io::EXN_TEXT)
nuclear@0	2667 if( !mReader->read())
nuclear@0	2668 ThrowException( boost::str( boost::format( "Unexpected end of file while reading end of <%s> element.") % pName));
nuclear@0	2669
nuclear@0	2670 // but this has the be the closing tag, or we're lost
nuclear@0	2671 if( mReader->getNodeType() != irr::io::EXN_ELEMENT_END \|\| strcmp( mReader->getNodeName(), pName) != 0)
nuclear@0	2672 ThrowException( boost::str( boost::format( "Expected end of <%s> element.") % pName));
nuclear@0	2673 }
nuclear@0	2674
nuclear@0	2675 // ------------------------------------------------------------------------------------------------
nuclear@0	2676 // Returns the index of the named attribute or -1 if not found. Does not throw, therefore useful for optional attributes
nuclear@0	2677 int ColladaParser::GetAttribute( const char* pAttr) const
nuclear@0	2678 {
nuclear@0	2679 int index = TestAttribute( pAttr);
nuclear@0	2680 if( index != -1)
nuclear@0	2681 return index;
nuclear@0	2682
nuclear@0	2683 // attribute not found -> throw an exception
nuclear@0	2684 ThrowException( boost::str( boost::format( "Expected attribute \"%s\" for element <%s>.") % pAttr % mReader->getNodeName()));
nuclear@0	2685 return -1;
nuclear@0	2686 }
nuclear@0	2687
nuclear@0	2688 // ------------------------------------------------------------------------------------------------
nuclear@0	2689 // Tests the present element for the presence of one attribute, returns its index or throws an exception if not found
nuclear@0	2690 int ColladaParser::TestAttribute( const char* pAttr) const
nuclear@0	2691 {
nuclear@0	2692 for( int a = 0; a < mReader->getAttributeCount(); a++)
nuclear@0	2693 if( strcmp( mReader->getAttributeName( a), pAttr) == 0)
nuclear@0	2694 return a;
nuclear@0	2695
nuclear@0	2696 return -1;
nuclear@0	2697 }
nuclear@0	2698
nuclear@0	2699 // ------------------------------------------------------------------------------------------------
nuclear@0	2700 // Reads the text contents of an element, throws an exception if not given. Skips leading whitespace.
nuclear@0	2701 const char* ColladaParser::GetTextContent()
nuclear@0	2702 {
nuclear@0	2703 const char* sz = TestTextContent();
nuclear@0	2704 if(!sz) {
nuclear@0	2705 ThrowException( "Invalid contents in element \"n\".");
nuclear@0	2706 }
nuclear@0	2707 return sz;
nuclear@0	2708 }
nuclear@0	2709
nuclear@0	2710 // ------------------------------------------------------------------------------------------------
nuclear@0	2711 // Reads the text contents of an element, returns NULL if not given. Skips leading whitespace.
nuclear@0	2712 const char* ColladaParser::TestTextContent()
nuclear@0	2713 {
nuclear@0	2714 // present node should be the beginning of an element
nuclear@0	2715 if( mReader->getNodeType() != irr::io::EXN_ELEMENT \|\| mReader->isEmptyElement())
nuclear@0	2716 return NULL;
nuclear@0	2717
nuclear@0	2718 // read contents of the element
nuclear@0	2719 if( !mReader->read() )
nuclear@0	2720 return NULL;
nuclear@0	2721 if( mReader->getNodeType() != irr::io::EXN_TEXT)
nuclear@0	2722 return NULL;
nuclear@0	2723
nuclear@0	2724 // skip leading whitespace
nuclear@0	2725 const char* text = mReader->getNodeData();
nuclear@0	2726 SkipSpacesAndLineEnd( &text);
nuclear@0	2727
nuclear@0	2728 return text;
nuclear@0	2729 }
nuclear@0	2730
nuclear@0	2731 // ------------------------------------------------------------------------------------------------
nuclear@0	2732 // Calculates the resulting transformation fromm all the given transform steps
nuclear@0	2733 aiMatrix4x4 ColladaParser::CalculateResultTransform( const std::vector<Transform>& pTransforms) const
nuclear@0	2734 {
nuclear@0	2735 aiMatrix4x4 res;
nuclear@0	2736
nuclear@0	2737 for( std::vector<Transform>::const_iterator it = pTransforms.begin(); it != pTransforms.end(); ++it)
nuclear@0	2738 {
nuclear@0	2739 const Transform& tf = *it;
nuclear@0	2740 switch( tf.mType)
nuclear@0	2741 {
nuclear@0	2742 case TF_LOOKAT:
nuclear@0	2743 {
nuclear@0	2744 aiVector3D pos( tf.f[0], tf.f[1], tf.f[2]);
nuclear@0	2745 aiVector3D dstPos( tf.f[3], tf.f[4], tf.f[5]);
nuclear@0	2746 aiVector3D up = aiVector3D( tf.f[6], tf.f[7], tf.f[8]).Normalize();
nuclear@0	2747 aiVector3D dir = aiVector3D( dstPos - pos).Normalize();
nuclear@0	2748 aiVector3D right = (dir ^ up).Normalize();
nuclear@0	2749
nuclear@0	2750 res *= aiMatrix4x4(
nuclear@0	2751 right.x, up.x, -dir.x, pos.x,
nuclear@0	2752 right.y, up.y, -dir.y, pos.y,
nuclear@0	2753 right.z, up.z, -dir.z, pos.z,
nuclear@0	2754 0, 0, 0, 1);
nuclear@0	2755 break;
nuclear@0	2756 }
nuclear@0	2757 case TF_ROTATE:
nuclear@0	2758 {
nuclear@0	2759 aiMatrix4x4 rot;
nuclear@0	2760 float angle = tf.f[3] * float( AI_MATH_PI) / 180.0f;
nuclear@0	2761 aiVector3D axis( tf.f[0], tf.f[1], tf.f[2]);
nuclear@0	2762 aiMatrix4x4::Rotation( angle, axis, rot);
nuclear@0	2763 res *= rot;
nuclear@0	2764 break;
nuclear@0	2765 }
nuclear@0	2766 case TF_TRANSLATE:
nuclear@0	2767 {
nuclear@0	2768 aiMatrix4x4 trans;
nuclear@0	2769 aiMatrix4x4::Translation( aiVector3D( tf.f[0], tf.f[1], tf.f[2]), trans);
nuclear@0	2770 res *= trans;
nuclear@0	2771 break;
nuclear@0	2772 }
nuclear@0	2773 case TF_SCALE:
nuclear@0	2774 {
nuclear@0	2775 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,
nuclear@0	2776 0.0f, 0.0f, 0.0f, 1.0f);
nuclear@0	2777 res *= scale;
nuclear@0	2778 break;
nuclear@0	2779 }
nuclear@0	2780 case TF_SKEW:
nuclear@0	2781 // TODO: (thom)
nuclear@0	2782 ai_assert( false);
nuclear@0	2783 break;
nuclear@0	2784 case TF_MATRIX:
nuclear@0	2785 {
nuclear@0	2786 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],
nuclear@0	2787 tf.f[8], tf.f[9], tf.f[10], tf.f[11], tf.f[12], tf.f[13], tf.f[14], tf.f[15]);
nuclear@0	2788 res *= mat;
nuclear@0	2789 break;
nuclear@0	2790 }
nuclear@0	2791 default:
nuclear@0	2792 ai_assert( false);
nuclear@0	2793 break;
nuclear@0	2794 }
nuclear@0	2795 }
nuclear@0	2796
nuclear@0	2797 return res;
nuclear@0	2798 }
nuclear@0	2799
nuclear@0	2800 // ------------------------------------------------------------------------------------------------
nuclear@0	2801 // Determines the input data type for the given semantic string
nuclear@0	2802 Collada::InputType ColladaParser::GetTypeForSemantic( const std::string& pSemantic)
nuclear@0	2803 {
nuclear@0	2804 if( pSemantic == "POSITION")
nuclear@0	2805 return IT_Position;
nuclear@0	2806 else if( pSemantic == "TEXCOORD")
nuclear@0	2807 return IT_Texcoord;
nuclear@0	2808 else if( pSemantic == "NORMAL")
nuclear@0	2809 return IT_Normal;
nuclear@0	2810 else if( pSemantic == "COLOR")
nuclear@0	2811 return IT_Color;
nuclear@0	2812 else if( pSemantic == "VERTEX")
nuclear@0	2813 return IT_Vertex;
nuclear@0	2814 else if( pSemantic == "BINORMAL" \|\| pSemantic == "TEXBINORMAL")
nuclear@0	2815 return IT_Bitangent;
nuclear@0	2816 else if( pSemantic == "TANGENT" \|\| pSemantic == "TEXTANGENT")
nuclear@0	2817 return IT_Tangent;
nuclear@0	2818
nuclear@0	2819 DefaultLogger::get()->warn( boost::str( boost::format( "Unknown vertex input type \"%s\". Ignoring.") % pSemantic));
nuclear@0	2820 return IT_Invalid;
nuclear@0	2821 }
nuclear@0	2822
nuclear@0	2823 #endif // !! ASSIMP_BUILD_NO_DAE_IMPORTER