Source/System/FileIO/Collada/OSGColladaNode.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *                Copyright (C) 2009 by the OpenSG Forum                     *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 #if __GNUC__ >= 4 || __GNUC_MINOR__ >=3
  40 #pragma GCC diagnostic ignored "-Wold-style-cast"
  41 #endif
  42
  43 #include "OSGColladaNode.h"
  44
  45 #if defined(OSG_WITH_COLLADA) || defined(OSG_DO_DOC)
  46
  47 #include "OSGColladaLog.h"
  48 #include "OSGColladaGlobal.h"
  49 #include "OSGColladaInstanceNode.h"
  50 #include "OSGColladaInstanceLight.h"
  51 #include "OSGColladaInstanceGeometry.h"
  52 #include "OSGColladaInstanceController.h"
  53 #include "OSGTransform.h"
  54 #include "OSGSkeletonJoint.h"
  55 #include "OSGNameAttachment.h"
  56
  57 #include <dom/domLookat.h>
  58 #include <dom/domMatrix.h>
  59 #include <dom/domRotate.h>
  60 #include <dom/domScale.h>
  61 #include <dom/domSkew.h>
  62 #include <dom/domTranslate.h>
  63 #include <dom/domInstance_node.h>
  64 #include <dom/domNode.h>
  65
  66 OSG_BEGIN_NAMESPACE
  67
  68 // ===========================================================================
  69
  70 ColladaInstInfoTransitPtr
  71 ColladaNode::ColladaNodeInstInfo::create(
  72     ColladaElement *colInstParent, ColladaInstanceNode *colInst,
  73     Node           *parentN                                     )
  74 {
  75     return ColladaInstInfoTransitPtr(
  76         new ColladaNodeInstInfo(colInstParent, colInst,parentN));
  77 }
  78
  79 void
  80 ColladaNode::ColladaNodeInstInfo::process(void)
  81 {
  82     SFATAL << "ColladaNodeInstInfo::process called!" << std::endl;
  83 }
  84
  85 ColladaNode::ColladaNodeInstInfo::ColladaNodeInstInfo(
  86     ColladaElement *colInstParent, ColladaInstanceNode *colInst,
  87     Node           *parentN                                     )
  88
  89     : Inherited     (colInstParent, colInst)
  90     , _colInstTarget(NULL                  )
  91     , _parentN      (parentN               )
  92 {
  93 }
  94
  95 ColladaNode::ColladaNodeInstInfo::~ColladaNodeInstInfo(void)
  96 {
  97 }
  98
  99 // ===========================================================================
 100
 101 ColladaNode::NodeLoaderStateTransitPtr
 102 ColladaNode::NodeLoaderState::create(void)
 103 {
 104     return NodeLoaderStateTransitPtr(new NodeLoaderState());
 105 }
 106
 107 void
 108 ColladaNode::NodeLoaderState::pushNodePath(const std::string &nodeId)
 109 {
 110     _nodePath.push_back(nodeId);
 111 }
 112
 113 void
 114 ColladaNode::NodeLoaderState::popNodePath(void)
 115 {
 116     OSG_ASSERT(_nodePath.empty() == false);
 117
 118     _nodePath.pop_back();
 119 }
 120
 121 const ColladaNode::NodePath &
 122 ColladaNode::NodeLoaderState::getNodePath(void) const
 123 {
 124     return _nodePath;
 125 }
 126
 127 void
 128 ColladaNode::NodeLoaderState::dumpNodePath(void) const
 129 {
 130     NodePathConstIt npIt  = _nodePath.begin();
 131     NodePathConstIt npEnd = _nodePath.end  ();
 132
 133     OSG_COLLADA_LOG(("node path ["));
 134
 135     for(; npIt != npEnd; ++npIt)
 136     {
 137         OSG_COLLADA_PLOG((" '%s'", npIt->c_str()));
 138     }
 139
 140     OSG_COLLADA_PLOG((" ]\n"));
 141 }
 142
 143 void
 144 ColladaNode::NodeLoaderState::pushMatrix(const Matrix &matrix)
 145 {
 146     _matrixStack.push_back(_worldMatrix);
 147     _worldMatrix.mult(matrix);
 148 }
 149
 150 void
 151 ColladaNode::NodeLoaderState::popMatrix(void)
 152 {
 153     OSG_ASSERT(_matrixStack.empty() == false);
 154
 155     _worldMatrix = _matrixStack.back();
 156     _matrixStack.pop_back();
 157 }
 158
 159 const Matrix &
 160 ColladaNode::NodeLoaderState::getWorldMatrix(void) const
 161 {
 162     return _worldMatrix;
 163 }
 164
 165 Skeleton *
 166 ColladaNode::NodeLoaderState::getSkeleton(void) const
 167 {
 168     return _skel;
 169 }
 170
 171 void
 172 ColladaNode::NodeLoaderState::setSkeleton(Skeleton *skel)
 173 {
 174     _skel = skel;
 175 }
 176
 177 Int16
 178 ColladaNode::NodeLoaderState::getJointId(void) const
 179 {
 180     return _jointId;
 181 }
 182
 183 void
 184 ColladaNode::NodeLoaderState::setJointId(Int16 jointId)
 185 {
 186     _jointId = jointId;
 187 }
 188
 189 ColladaNode::NodeLoaderState::NodeLoaderState(void)
 190     : Inherited   ()
 191     , _nodePath   ()
 192     , _skel       ()
 193     , _jointId    (SkeletonJoint::INVALID_JOINT_ID)
 194     , _worldMatrix()
 195     , _matrixStack()
 196 {
 197 }
 198
 199 ColladaNode::NodeLoaderState::~NodeLoaderState(void)
 200 {
 201 }
 202
 203 // ===========================================================================
 204
 205 ColladaNode::InstData::InstData(void)
 206     : _nodePath   ()
 207     , _localMatrix()
 208     , _skel       (NULL)
 209     , _topN       (NULL)
 210     , _bottomN    (NULL)
 211     , _sidMap     ()
 212 {
 213 }
 214
 215 ColladaNode::InstData::~InstData(void)
 216 {
 217 }
 218
 219 // ===========================================================================
 220
 221 ColladaElementRegistrationHelper ColladaNode::_regHelper(
 222     &ColladaNode::create, "node");
 223
 224 const std::string                ColladaNode::_loaderStateName("ColladaNode");
 225
 226 ColladaElementTransitPtr
 227 ColladaNode::create(daeElement *elem, ColladaGlobal *global)
 228 {
 229     if(global->getLoaderState(_loaderStateName) == NULL)
 230     {
 231         NodeLoaderStateRefPtr state = NodeLoaderState::create();
 232
 233         global->addLoaderState(_loaderStateName, state);
 234     }
 235
 236     return ColladaElementTransitPtr(new ColladaNode(elem, global));
 237 }
 238
 239 void
 240 ColladaNode::read(ColladaElement *colElemParent)
 241 {
 242     domNodeRef node = getDOMElementAs<domNode>();
 243
 244     OSG_COLLADA_LOG(("ColladaNode::read id [%s]\n", node->getId()));
 245
 246     // <node>
 247     const domNode_Array &nodes = node->getNode_array();
 248     for(UInt32 i = 0; i < nodes.getCount(); ++i)
 249         readNode(nodes[i]);
 250
 251     // <instance_node>
 252     const domInstance_node_Array &instNodes =
 253         node->getInstance_node_array();
 254
 255     for(UInt32 i = 0; i < instNodes.getCount(); ++i)
 256         readInstanceNode(instNodes[i]);
 257
 258     // <instance_light>
 259     const domInstance_light_Array &instLights =
 260         node->getInstance_light_array();
 261
 262     for(UInt32 i = 0; i < instLights.getCount(); ++i)
 263         readInstanceLight(instLights[i]);
 264     // <instance_geometry>
 265     const domInstance_geometry_Array &instGeos =
 266         node->getInstance_geometry_array();
 267
 268     for(UInt32 i = 0; i < instGeos.getCount(); ++i)
 269         readInstanceGeometry(instGeos[i]);
 270
 271     // <instance_controller>
 272     const domInstance_controller_Array &instControllers =
 273         node->getInstance_controller_array();
 274
 275     for(UInt32 i = 0; i < instControllers.getCount(); ++i)
 276         readInstanceController(instControllers[i]);
 277 }
 278
 279 Node *
 280 ColladaNode::createInstance(ColladaInstInfo *colInstInfo)
 281 {
 282     Node       *retVal = NULL;
 283     domNodeRef  node   = getDOMElementAs<domNode>();
 284
 285 #if 0 // old trunk patch
 286     if(_topN->getParent() != NULL)
 287     {
 288         retVal = cloneTree(_topN);
 289     }
 290 #endif
 291
 292     if(node->getType() == NODETYPE_JOINT)
 293     {
 294         retVal = createInstanceJoint(colInstInfo, node);
 295     }
 296     else
 297     {
 298         retVal = createInstanceNode(colInstInfo, node);
 299     }
 300
 301     return retVal;
 302 }
 303
 304 bool
 305 ColladaNode::isJoint(void) const
 306 {
 307     domNodeRef node = getDOMElementAs<domNode>();
 308
 309     return (node->getType() == NODETYPE_JOINT);
 310 }
 311
 312 Skeleton *
 313 ColladaNode::getSkeleton(void) const
 314 {
 315     OSG_ASSERT(_instDataStore.empty() == false);
 316
 317     if(_instDataStore.size() > 1)
 318     {
 319         domNodeRef node = getDOMElementAs<domNode>();
 320
 321         SWARNING << "ColladaNode::getSkeleton: id ["
 322                  << (node->getId() != NULL ? node->getId() : "")
 323                  << "] has multiple instances, skeleton is ambiguous."
 324                  << std::endl;
 325     }
 326
 327     return _instDataStore[0]._skel;
 328 }
 329
 330 Node *
 331 ColladaNode::getTopNode(UInt32 instIdx) const
 332 {
 333     OSG_ASSERT(instIdx < _instDataStore.size());
 334
 335     return _instDataStore[instIdx]._topN;
 336 }
 337
 338 Node *
 339 ColladaNode::getBottomNode(UInt32 instIdx) const
 340 {
 341     OSG_ASSERT(instIdx < _instDataStore.size());
 342
 343     return _instDataStore[instIdx]._bottomN;
 344 }
 345
 346 Node *
 347 ColladaNode::getNodeBySid(UInt32 instIdx, const std::string &sid) const
 348 {
 349     OSG_ASSERT(instIdx < _instDataStore.size());
 350
 351     Node              *retVal   = NULL;
 352     const InstData    &instData = _instDataStore[instIdx];
 353     SIdNodeMapConstIt  sidIt    = instData._sidMap.find(sid);
 354     if(sidIt != instData._sidMap.end())
 355     {
 356         retVal = sidIt->second;
 357     }
 358     else
 359     {
 360         SWARNING << "ColladaNode::getNodeBySid: Could not find a node "
 361                  << "for sid [" << sid << "]." << std::endl;
 362     }
 363
 364     return retVal;
 365 }
 366
 367
 368 ColladaNode::ColladaNode(daeElement *elem, ColladaGlobal *global)
 369     : Inherited     (elem, global)
 370     , _instDataStore(            )
 371 {
 372 }
 373
 374 ColladaNode::~ColladaNode(void)
 375 {
 376 }
 377
 378 Node *
 379 ColladaNode::createInstanceNode(ColladaInstInfo *colInstInfo, domNode *node)
 380 {
 381     OSG_COLLADA_LOG(("ColladaNode::createInstanceNode id [%s]\n",
 382                      node->getId()));
 383
 384     NodeLoaderState *state =
 385         getGlobal()->getLoaderStateAs<NodeLoaderState>(_loaderStateName);
 386     OSG_ASSERT(state != NULL);
 387
 388     state->pushNodePath(node->getId() != NULL ? node->getId() : "");
 389     state->dumpNodePath();
 390
 391     NodeUnrecPtr retVal = NULL;
 392     InstData     instData;
 393
 394     instData._nodePath = state->getNodePath();
 395     const daeElementRefArray &contents = node->getContents();
 396
 397     // read "transform" child elements in the order
 398     // they occur in the document
 399     for(UInt32 i = 0; i < contents.getCount(); ++i)
 400     {
 401         if(contents[i]->typeID() == domLookat::ID())
 402         {
 403             handleLookAt(daeSafeCast<domLookat>(contents[i]), instData);
 404         }
 405         else if(contents[i]->typeID() == domMatrix::ID())
 406         {
 407             handleMatrix(daeSafeCast<domMatrix>(contents[i]), instData);
 408         }
 409         else if(contents[i]->typeID() == domRotate::ID())
 410         {
 411             handleRotate(daeSafeCast<domRotate>(contents[i]), instData);
 412         }
 413         else if(contents[i]->typeID() == domScale::ID())
 414         {
 415             handleScale(daeSafeCast<domScale>(contents[i]), instData);
 416         }
 417         else if(contents[i]->typeID() == domSkew::ID())
 418         {
 419             handleSkew(daeSafeCast<domSkew>(contents[i]), instData);
 420         }
 421         else if(contents[i]->typeID() == domTranslate::ID())
 422         {
 423             handleTranslate(daeSafeCast<domTranslate>(contents[i]), instData);
 424         }
 425     }
 426
 427     // assert top and bottom are both set or both unset
 428     OSG_ASSERT((instData._topN != NULL && instData._bottomN != NULL) ||
 429                (instData._topN == NULL && instData._bottomN == NULL)   );
 430
 431     // if no xforms were created make a group for this <node>
 432     if(instData._topN == NULL && instData._bottomN == NULL)
 433     {
 434         instData._topN    = makeCoredNode<Group>();
 435         instData._bottomN = instData._topN;
 436
 437         if(getGlobal()->getOptions()->getCreateNameAttachments() == true &&
 438            node->getName()                                       != NULL   )
 439         {
 440             setName(instData._topN, node->getName());
 441         }
 442     }
 443
 444     // update world matrix before we instantiate child nodes, etc.
 445     state->pushMatrix(instData._localMatrix);
 446
 447     // add <node> child elements
 448     const domNode_Array &nodes = node->getNode_array();
 449
 450     for(UInt32 i = 0; i < nodes.getCount(); ++i)
 451         handleNode(nodes[i], instData);
 452
 453     // add <instance_node> child elements
 454     const domInstance_node_Array &instNodes =
 455         node->getInstance_node_array();
 456
 457     for(UInt32 i = 0; i < instNodes.getCount(); ++i)
 458         handleInstanceNode(instNodes[i], instData);
 459
 460     // add <instance_light> child elements
 461     const domInstance_light_Array &instLights =
 462         node->getInstance_light_array();
 463
 464     for(UInt32 i = 0; i < instLights.getCount(); ++i)
 465         handleInstanceLight(instLights[i], instData);
 466
 467     // add <instance_geometry> child elements
 468     const domInstance_geometry_Array &instGeos =
 469         node->getInstance_geometry_array();
 470
 471     for(UInt32 i = 0; i < instGeos.getCount(); ++i)
 472         handleInstanceGeometry(instGeos[i], instData);
 473
 474     // add <instance_controller> child elemnts
 475     const domInstance_controller_Array &instControllers =
 476         node->getInstance_controller_array();
 477
 478     for(UInt32 i = 0; i < instControllers.getCount(); ++i)
 479         handleInstanceController(instControllers[i], instData);
 480
 481     editInstStore().push_back(instData._topN);
 482     _instDataStore .push_back(instData      );
 483     retVal = instData._topN;
 484
 485     state->popMatrix  ();
 486     state->popNodePath();
 487
 488     return retVal;
 489 }
 490
 491 Node *
 492 ColladaNode::createInstanceJoint(ColladaInstInfo *colInstInfo, domNode *node)
 493 {
 494     NodeUnrecPtr retVal    = NULL;
 495     bool         startSkel = false;
 496
 497     // if there is a ColladaInstanceElement someone tried to use <instance_node>
 498     // with this joint as target - this is currently not supported
 499     if(colInstInfo->getColInst() != NULL)
 500     {
 501         SWARNING << "ColladaNode::createInstanceJoint: <instance_node> with "
 502                  << "target <node> of type JOINT not supported." << std::endl;
 503         return retVal;
 504     }
 505
 506     NodeLoaderState *state =
 507         getGlobal()->getLoaderStateAs<NodeLoaderState>(_loaderStateName);
 508     OSG_ASSERT(state != NULL);
 509
 510     state->pushNodePath(node->getId() != NULL ? node->getId() : "");
 511     state->dumpNodePath();
 512
 513     InstData instData;
 514     instData._nodePath = state->getNodePath();
 515     instData._skel     = state->getSkeleton();
 516
 517     if(instData._skel == NULL)
 518     {
 519         startSkel      = true;
 520         instData._skel = Skeleton::create();
 521
 522         state->setSkeleton(instData._skel);
 523         state->setJointId (0             );
 524
 525         OSG_COLLADA_LOG(("ColladaNode::createInstanceJoint: id [%s] "
 526                          "root joint\n", node->getId()));
 527     }
 528     else
 529     {
 530         state->setJointId(state->getJointId() + 1);
 531
 532         OSG_COLLADA_LOG(("ColladaNode::createInstanceJoint: id [%s] "
 533                          "joint [%d]\n", node->getId(), state->getJointId()));
 534     }
 535
 536     const daeElementRefArray &contents = node->getContents();
 537
 538     for(UInt32 i = 0; i < contents.getCount(); ++i)
 539     {
 540         if(contents[i]->typeID() == domLookat::ID())
 541         {
 542             handleLookAt(daeSafeCast<domLookat>(contents[i]), instData);
 543         }
 544         else if(contents[i]->typeID() == domMatrix::ID())
 545         {
 546             handleMatrix(daeSafeCast<domMatrix>(contents[i]), instData);
 547         }
 548         else if(contents[i]->typeID() == domRotate::ID())
 549         {
 550             handleRotate(daeSafeCast<domRotate>(contents[i]), instData);
 551         }
 552         else if(contents[i]->typeID() == domScale::ID())
 553         {
 554             handleScale(daeSafeCast<domScale>(contents[i]), instData);
 555         }
 556         else if(contents[i]->typeID() == domSkew::ID())
 557         {
 558             handleSkew(daeSafeCast<domSkew>(contents[i]), instData);
 559         }
 560         else if(contents[i]->typeID() == domTranslate::ID())
 561         {
 562             handleTranslate(daeSafeCast<domTranslate>(contents[i]), instData);
 563         }
 564     }
 565
 566     // assert top and bottom are both set or both unset
 567     OSG_ASSERT((instData._topN != NULL && instData._bottomN != NULL) ||
 568                (instData._topN == NULL && instData._bottomN == NULL)   );
 569
 570     if(instData._topN == NULL && instData._bottomN == NULL)
 571     {
 572         // no xforms were created, make a SkeletonJoint for this <node>
 573
 574         SkeletonJointUnrecPtr joint = SkeletonJoint::create();
 575
 576         joint->setJointId(state->getJointId());
 577
 578         instData._topN    = makeNodeFor(joint);
 579         instData._bottomN = instData._topN;
 580
 581         if(getGlobal()->getOptions()->getCreateNameAttachments() == true &&
 582            node->getName()                                       != NULL   )
 583         {
 584             setName(instData._topN, node->getName());
 585         }
 586     }
 587     else if(getGlobal()->getOptions()->getMergeTransforms() == false)
 588     {
 589         // when not merging transforms add SkeletonJoint core now
 590
 591         SkeletonJointUnrecPtr joint  = SkeletonJoint::create();
 592         NodeUnrecPtr          jointN = makeNodeFor(joint);
 593
 594         joint->setJointId(state->getJointId());
 595
 596         instData._bottomN->addChild(jointN);
 597         instData._bottomN = jointN;
 598     }
 599
 600     if(startSkel == true)
 601     {
 602         // add a transform for the world matrix up to this node to put
 603         // the Skeleton in the correct coordinate system
 604
 605         TransformUnrecPtr xform  = Transform::create();
 606         NodeUnrecPtr      xformN = makeNodeFor(xform);
 607
 608         xform->setMatrix(state->getWorldMatrix());
 609
 610         xformN->addChild(instData._topN);
 611         instData._topN = xformN;
 612
 613         if(getGlobal()->getOptions()->getCreateNameAttachments() == true)
 614             setName(xformN, "SkeletonWorldMatrix");
 615     }
 616
 617     // update world matrix before we instantiate child nodes, etc.
 618     state->pushMatrix(instData._localMatrix);
 619
 620     // add <node> child elements
 621     const domNode_Array &nodes = node->getNode_array();
 622
 623     for(UInt32 i = 0; i < nodes.getCount(); ++i)
 624         handleNode(nodes[i], instData);
 625
 626     // add <instance_node> child elements
 627     const domInstance_node_Array &instNodes =
 628         node->getInstance_node_array();
 629
 630     for(UInt32 i = 0; i < instNodes.getCount(); ++i)
 631         handleInstanceNode(instNodes[i], instData);
 632
 633     // we don't handle other <instance_*> tags here, it does not
 634     // make sense to have them inside a skeleton
 635
 636     editInstStore().push_back(instData._topN);
 637     _instDataStore .push_back(instData      );
 638     retVal = instData._topN;
 639
 640     if(startSkel == true)
 641     {
 642         instData._skel->pushToRoots(instData._topN);
 643
 644         state->setSkeleton(NULL);
 645         state->setJointId (SkeletonJoint::INVALID_JOINT_ID);
 646     }
 647
 648     state->popMatrix  ();
 649     state->popNodePath();
 650
 651     return retVal;
 652 }
 653
 654 void
 655 ColladaNode::handleLookAt(domLookat *lookat, InstData &instData)
 656 {
 657     if(lookat == NULL)
 658         return;
 659
 660     SWARNING << "ColladaNode::handleLookAt: NIY" << std::endl;
 661 }
 662
 663 void
 664 ColladaNode::handleMatrix(domMatrix *matrix, InstData &instData)
 665 {
 666     if(matrix == NULL)
 667         return;
 668
 669     Matrix m(matrix->getValue()[0],      // rVal00
 670              matrix->getValue()[1],      // rVal10
 671              matrix->getValue()[2],      // rVal20
 672              matrix->getValue()[3],      // rVal30
 673              matrix->getValue()[4],      // rVal01
 674              matrix->getValue()[5],      // rVal11
 675              matrix->getValue()[6],      // rVal21
 676              matrix->getValue()[7],      // rVal31
 677              matrix->getValue()[8],      // rVal02
 678              matrix->getValue()[9],      // rVal12
 679              matrix->getValue()[10],     // rVal22
 680              matrix->getValue()[11],     // rVal32
 681              matrix->getValue()[12],     // rVal03
 682              matrix->getValue()[13],     // rVal13
 683              matrix->getValue()[14],     // rVal23
 684              matrix->getValue()[15] );   // rVal33
 685
 686     std::string xformSID;
 687
 688     if(matrix->getSid() != NULL)
 689         xformSID.assign(matrix->getSid());
 690
 691     appendXForm(m, xformSID, instData);
 692 }
 693
 694 void
 695 ColladaNode::handleRotate(domRotate *rotate, InstData &instData)
 696 {
 697     if(rotate == NULL)
 698         return;
 699
 700     Matrix     m;
 701     Quaternion q;
 702     q.setValueAsAxisDeg(rotate->getValue()[0],
 703                         rotate->getValue()[1],
 704                         rotate->getValue()[2],
 705                         rotate->getValue()[3] );
 706
 707     m.setRotate(q);
 708
 709     std::string xformSID;
 710
 711     if(rotate->getSid() != NULL)
 712         xformSID.assign(rotate->getSid());
 713
 714     appendXForm(m, xformSID, instData);
 715 }
 716
 717 void
 718 ColladaNode::handleScale(domScale *scale, InstData &instData)
 719 {
 720     if(scale == NULL)
 721         return;
 722
 723     Matrix m;
 724     m.setScale(scale->getValue()[0],
 725                scale->getValue()[1],
 726                scale->getValue()[2] );
 727
 728     std::string xformSID;
 729
 730     if(scale->getSid() != NULL)
 731         xformSID.assign(scale->getSid());
 732
 733     appendXForm(m, xformSID, instData);
 734 }
 735
 736 void
 737 ColladaNode::handleSkew(domSkew *skew, InstData &instData)
 738 {
 739     /*
 740      * Implemented in accordance with the RenderMan specification.
 741      * See http://www.koders.com/cpp/fidA08C276050F880D11C2E49280DD9997478DC5BA1.aspx for
 742      * the implementation that this was copied from.
 743      * (If the url is invalid, this implementation was copied from the GNU GMAN project,
 744      * in the gmanmatrix4.cpp file.)
 745      *
 746      */
 747     if(skew == NULL)
 748         return;
 749
 750    // SWARNING << "ColladaNode::handleSkew: NIY" << std::endl;
 751     Real32 angle,an1,an2,rx,ry,alpha;
 752     Matrix m;
 753     Vec3f a1,a2,n1,n2;
 754
 755     domFloat7 elems = skew->getValue();
 756     angle = elems[0];
 757     Vec3f a(elems[1],elems[2],elems[3]), b(elems[4],elems[5],elems[6]);
 758     b.normalize();
 759     a1 = b * a.dot(b);
 760     a2 = a - a1;
 761     a2.normalize();
 762
 763     an1 = a.dot(a2);
 764     an2 = a.dot(b);
 765
 766     angle = osgDegree2Rad(angle);
 767     rx = an1*osgCos(angle) - an2*osgSin(angle);
 768     ry = an1*osgSin(angle) + an2*osgCos(angle);
 769
 770     if(rx <= 0.0f)
 771     {  // skew angle too large, and we can't calculate the skew matrix
 772         SWARNING << "ColladaNode::handleSkew: Skew Angle too large! ( rx = "
 773                  << rx << " )" << std::endl;
 774         return;
 775     }
 776
 777     // are A and B parallel?
 778     if(OSG::osgAbs(an1) < 0.000001)
 779         alpha = 0.0f;
 780     else
 781         alpha = ry/rx - an2/an1;
 782
 783     m[0][0] = a2.x() * b.x() * alpha + 1.0f;
 784     m[1][0] = a2.y() * b.x() * alpha;
 785     m[2][0] = a2.z() * b.x() * alpha;
 786
 787     m[0][1] = a2.x() * b.y() * alpha;
 788     m[1][1] = a2.y() * b.y() * alpha + 1.0f;
 789     m[2][1] = a2.z() * b.y() * alpha;
 790
 791     m[0][2] = a2.x() * b.z() * alpha;
 792     m[1][2] = a2.y() * b.z() * alpha;
 793     m[2][2] = a2.z() * b.z() * alpha + 1.0f;
 794
 795     std::string xformSID;
 796
 797     if(skew->getSid() != NULL)
 798         xformSID.assign(skew->getSid());
 799
 800     appendXForm(m, xformSID, instData);
 801 }
 802
 803 void
 804 ColladaNode::handleTranslate(domTranslate *translate, InstData &instData)
 805 {
 806     if(translate == NULL)
 807         return;
 808
 809     Matrix m;
 810     m.setTranslate(translate->getValue()[0],
 811                    translate->getValue()[1],
 812                    translate->getValue()[2] );
 813
 814     std::string nameSuffix;
 815
 816     if(translate->getSid() != NULL)
 817     {
 818         nameSuffix.append("."                );
 819         nameSuffix.append(translate->getSid());
 820     }
 821
 822     appendXForm(m, nameSuffix, instData);
 823 }
 824
 825 void
 826 ColladaNode::appendXForm(const Matrix      &m,
 827                          const std::string &xformSID,
 828                          InstData          &instData   )
 829 {
 830     domNodeRef       node  = getDOMElementAs<domNode>();
 831     NodeLoaderState *state =
 832         getGlobal()->getLoaderStateAs<NodeLoaderState>(_loaderStateName);
 833     OSG_ASSERT(state != NULL);
 834
 835     if(getGlobal()->getOptions()->getMergeTransforms() == true)
 836     {
 837         if(instData._bottomN == NULL)
 838         {
 839             if(node->getType() == NODETYPE_JOINT)
 840             {
 841                 SkeletonJointUnrecPtr joint = SkeletonJoint::create();
 842                 instData._bottomN           = makeNodeFor(joint);
 843
 844                 joint->setMatrix(m);
 845                 joint->setJointId(state->getJointId());
 846             }
 847             else
 848             {
 849                 TransformUnrecPtr xform = Transform::create();
 850                 instData._bottomN       = makeNodeFor(xform);
 851
 852                 xform->setMatrix(m);
 853             }
 854
 855             instData._localMatrix = m;
 856         }
 857         else
 858         {
 859             if(node->getType() == NODETYPE_JOINT)
 860             {
 861                 SkeletonJoint *joint =
 862                     dynamic_cast<SkeletonJoint *>(instData._bottomN->getCore());
 863                 OSG_ASSERT(joint != NULL);
 864
 865                 joint->editMatrix().mult(m);
 866             }
 867             else
 868             {
 869                 Transform *xform =
 870                     dynamic_cast<Transform *>(instData._bottomN->getCore());
 871                 OSG_ASSERT(xform != NULL);
 872
 873                 xform->editMatrix().mult(m);
 874             }
 875
 876             instData._localMatrix.mult(m);
 877         }
 878
 879         if(instData._topN == NULL)
 880             instData._topN = instData._bottomN;
 881
 882         if(xformSID.empty() == false)
 883             instData._sidMap[xformSID] = instData._bottomN;
 884
 885         if(getGlobal()->getOptions()->getCreateNameAttachments() == true &&
 886            node->getName()                                       != NULL &&
 887            getName(instData._bottomN)                            == NULL   )
 888         {
 889             std::string nodeName = node->getName();
 890
 891             setName(instData._bottomN, nodeName);
 892         }
 893     }
 894     else
 895     {
 896         TransformUnrecPtr xform  = Transform::create();
 897         NodeUnrecPtr      xformN = makeNodeFor(xform);
 898
 899         if(instData._bottomN != NULL)
 900             instData._bottomN->addChild(xformN);
 901
 902         xform->setMatrix(m);
 903         instData._localMatrix.mult(m);
 904
 905         instData._bottomN = xformN;
 906
 907         if(instData._topN == NULL)
 908             instData._topN = instData._bottomN;
 909
 910         if(xformSID.empty() == false)
 911             instData._sidMap[xformSID] = xformN;
 912
 913         if(getGlobal()->getOptions()->getCreateNameAttachments() == true &&
 914            node->getName()                                       != NULL   )
 915         {
 916             std::string nodeName = node->getName();
 917
 918             if(xformSID.empty() == false)
 919             {
 920                 nodeName.append("."     );
 921                 nodeName.append(xformSID);
 922             }
 923
 924             setName(instData._bottomN, nodeName);
 925         }
 926     }
 927 }
 928
 929 void
 930 ColladaNode::appendChild(domNode  *child,
 931                          Node     *childN,
 932                          InstData &instData)
 933 {
 934     domNodeRef node = getDOMElementAs<domNode>();
 935
 936     // only add the child if it is not the first joint
 937     // in a hierarchy
 938
 939     if(child->getType() != NODETYPE_JOINT ||
 940        node ->getType() != NODETYPE_NODE    )
 941     {
 942         OSG_ASSERT(instData._topN    != NULL);
 943         OSG_ASSERT(instData._bottomN != NULL);
 944
 945         instData._bottomN->addChild(childN);
 946     }
 947 }
 948
 949 void
 950 ColladaNode::readNode(domNode *child)
 951 {
 952     ColladaNodeRefPtr colNodeChild = getUserDataAs<ColladaNode>(child);
 953
 954     if(colNodeChild == NULL)
 955     {
 956         colNodeChild = dynamic_pointer_cast<ColladaNode>(
 957             ColladaElementFactory::the()->create(child, getGlobal()));
 958
 959         colNodeChild->read(this);
 960     }
 961 }
 962
 963 void
 964 ColladaNode::handleNode(domNode  *child,
 965                         InstData &instData)
 966 {
 967     ColladaNodeRefPtr     colNodeChild = getUserDataAs<ColladaNode>(child);
 968     ColladaInstInfoRefPtr colInstInfo  =
 969         ColladaNodeInstInfo::create(this, NULL, instData._bottomN);
 970
 971     Node *childN = colNodeChild->createInstance(colInstInfo);
 972
 973     appendChild(child, childN, instData);
 974 }
 975
 976 void
 977 ColladaNode::readInstanceNode(domInstance_node *instNode)
 978 {
 979     ColladaInstanceNodeRefPtr colInstNode =
 980         getUserDataAs<ColladaInstanceNode>(instNode);
 981
 982     if(colInstNode == NULL)
 983     {
 984         colInstNode = dynamic_pointer_cast<ColladaInstanceNode>(
 985             ColladaElementFactory::the()->create(instNode, getGlobal()));
 986
 987         colInstNode->read(this);
 988     }
 989 }
 990
 991 void
 992 ColladaNode::handleInstanceNode(domInstance_node *instNode,
 993                                 InstData         &instData)
 994 {
 995     ColladaInstanceNodeRefPtr colInstNode =
 996         getUserDataAs<ColladaInstanceNode>(instNode);
 997     ColladaInstInfoRefPtr     colInstInfo =
 998         ColladaNodeInstInfo::create(this, colInstNode, instData._bottomN);
 999
1000     Node *childN = colInstNode->getTargetElem()->createInstance(colInstInfo);
1001
1002     appendChild(colInstNode->getTargetDOMElem(), childN, instData);
1003 }
1004
1005 void
1006 ColladaNode::readInstanceLight(domInstance_light *instLight)
1007 {
1008     if(getGlobal()->getOptions()->getLoadLights() == false)
1009         return;
1010
1011     ColladaInstanceLightRefPtr colInstLight =
1012         getUserDataAs<ColladaInstanceLight>(instLight);
1013
1014     if(colInstLight == NULL)
1015     {
1016         colInstLight = dynamic_pointer_cast<ColladaInstanceLight>(
1017             ColladaElementFactory::the()->create(instLight, getGlobal()));
1018
1019         colInstLight->read(this);
1020     }
1021 }
1022
1023 void
1024 ColladaNode::handleInstanceLight(domInstance_light *instLight,
1025                                  InstData          &instData  )
1026 {
1027     if(getGlobal()->getOptions()->getLoadLights() == false)
1028         return;
1029
1030     ColladaInstanceLightRefPtr colInstLight =
1031         getUserDataAs<ColladaInstanceLight>(instLight);
1032
1033     ColladaInstInfoRefPtr lightInstInfo =
1034         ColladaLight::ColladaLightInstInfo::create(
1035             this, colInstLight, instData._bottomN);
1036
1037     getGlobal()->editInstQueue().push_back(lightInstInfo);
1038 }
1039
1040 void
1041 ColladaNode::readInstanceGeometry(domInstance_geometry *instGeo)
1042 {
1043     ColladaInstanceGeometryRefPtr colInstGeo =
1044         getUserDataAs<ColladaInstanceGeometry>(instGeo);
1045
1046     if(colInstGeo == NULL)
1047     {
1048         colInstGeo = dynamic_pointer_cast<ColladaInstanceGeometry>(
1049             ColladaElementFactory::the()->create(instGeo, getGlobal()));
1050
1051         colInstGeo->read(this);
1052     }
1053 }
1054
1055 void
1056 ColladaNode::handleInstanceGeometry(domInstance_geometry *instGeo,
1057                                     InstData             &instData)
1058 {
1059     ColladaInstanceGeometryRefPtr colInstGeo =
1060         getUserDataAs<ColladaInstanceGeometry>(instGeo);
1061
1062     ColladaInstInfoRefPtr geoInstInfo =
1063         ColladaGeometry::ColladaGeometryInstInfo::create(
1064             this, colInstGeo, instData._bottomN);
1065
1066     getGlobal()->editInstQueue().push_back(geoInstInfo);
1067 }
1068
1069 void
1070 ColladaNode::readInstanceController(domInstance_controller *instCtrl)
1071 {
1072     ColladaInstanceControllerRefPtr colInstCtrl =
1073         getUserDataAs<ColladaInstanceController>(instCtrl);
1074
1075     if(colInstCtrl == NULL)
1076     {
1077         colInstCtrl = dynamic_pointer_cast<ColladaInstanceController>(
1078             ColladaElementFactory::the()->create(instCtrl, getGlobal()));
1079
1080         colInstCtrl->read(this);
1081     }
1082 }
1083
1084 void
1085 ColladaNode::handleInstanceController(
1086     domInstance_controller *instCtrl,
1087     InstData               &instData )
1088 {
1089     ColladaInstanceControllerRefPtr colInstCtrl =
1090         getUserDataAs<ColladaInstanceController>(instCtrl);
1091
1092     ColladaInstInfoRefPtr ctrlInstInfo =
1093         ColladaController::ColladaControllerInstInfo::create(
1094             this, colInstCtrl, instData._bottomN);
1095
1096     getGlobal()->editInstQueue().push_back(ctrlInstInfo);
1097 }
1098
1099 OSG_END_NAMESPACE
1100
1101 #endif // OSG_WITH_COLLADA