Source/System/FileIO/Collada/OSGColladaController.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 "OSGColladaController.h"
  44
  45 #ifdef OSG_WITH_COLLADA
  46
  47 #include "OSGColladaLog.h"
  48 #include "OSGColladaGlobal.h"
  49 #include "OSGColladaInstanceController.h"
  50 #include "OSGColladaSource.h"
  51 #include "OSGColladaNode.h"
  52 #include "OSGGroup.h"
  53 #include "OSGTransform.h"
  54 #include "OSGSkinnedGeometry.h"
  55 #include "OSGSkeletonJoint.h"
  56 #include "OSGNameAttachment.h"
  57 #include "OSGFieldContainerUtils.h"
  58
  59 #include "OSGTypedGeoVectorProperty.h"
  60
  61 #include <dom/domController.h>
  62 #include <dom/domGeometry.h>
  63
  64 #include <set>
  65
  66 OSG_BEGIN_NAMESPACE
  67
  68 ColladaInstInfoTransitPtr
  69 ColladaController::ColladaControllerInstInfo::create(
  70     ColladaNode *colInstParent, ColladaInstanceController *colInst,
  71     Node        *parentN                                           )
  72 {
  73     return ColladaInstInfoTransitPtr(
  74         new ColladaControllerInstInfo(colInstParent, colInst, parentN));
  75 }
  76
  77 void
  78 ColladaController::ColladaControllerInstInfo::process(void)
  79 {
  80      Node *ctrlInstN = dynamic_cast<Node *>(
  81         getColInst()->getTargetElem()->createInstance(this));
  82
  83     getParentNode()->addChild(ctrlInstN);
  84 }
  85
  86 ColladaController::ColladaControllerInstInfo::ColladaControllerInstInfo(
  87     ColladaNode *colInstParent, ColladaInstanceController *colInst,
  88     Node        *parentN                                           )
  89
  90     : Inherited(colInstParent, colInst)
  91     , _parentN (parentN               )
  92 {
  93 }
  94
  95 ColladaController::ColladaControllerInstInfo::~ColladaControllerInstInfo(void)
  96 {
  97 }
  98
  99 // ===========================================================================
 100
 101 ColladaElementRegistrationHelper ColladaController::_regHelper(
 102     &ColladaController::create, "controller");
 103
 104
 105 ColladaElementTransitPtr
 106 ColladaController::create(daeElement *elem, ColladaGlobal *global)
 107 {
 108     return ColladaElementTransitPtr(new ColladaController(elem, global));
 109 }
 110
 111 void
 112 ColladaController::read(ColladaElement *colElemParent)
 113 {
 114     domControllerRef ctrl = getDOMElementAs<domController>();
 115     domSkinRef       skin = ctrl->getSkin();
 116
 117     OSG_COLLADA_LOG(("ColladaController::read id [%s]\n", ctrl->getId()));
 118
 119     if(skin == NULL)
 120     {
 121         SWARNING << "ColladaController::read: No <skin>" << std::endl;
 122         return;
 123     }
 124
 125     readSkin(skin);
 126 }
 127
 128 Node *
 129 ColladaController::createInstance(ColladaInstInfo *colInstInfo)
 130 {
 131     typedef ColladaInstanceController::MaterialMap        ColMaterialMap;
 132     typedef ColladaInstanceController::MaterialMapConstIt ColMaterialMapConstIt;
 133
 134     domControllerRef ctrl = getDOMElementAs<domController>();
 135
 136     OSG_COLLADA_LOG(("ColladaController::createInstance id [%s]\n",
 137                      ctrl->getId()));
 138
 139     domSkinRef                      skin        = ctrl->getSkin();
 140     NodeUnrecPtr                    groupN      = makeCoredNode<Group>();
 141     ColladaInstanceControllerRefPtr colInstCtrl =
 142         dynamic_cast<ColladaInstanceController *>(colInstInfo->getColInst());
 143
 144     if(getGlobal()->getOptions()->getCreateNameAttachments() == true &&
 145        ctrl->getName()                                       != NULL   )
 146     {
 147         setName(groupN, ctrl->getName());
 148     }
 149
 150     // create Skeleton
 151
 152     // find all joints and store them in jointStore
 153     JointInfoStore jointStore;
 154     JointIdMap     jointIdMap;
 155     resolveJoints(skin, colInstCtrl, jointStore, jointIdMap);
 156     remapJointIds(skin, colInstCtrl, jointStore, jointIdMap);
 157
 158     // create SkinnedGeometry
 159
 160     const ColMaterialMap &matMap = colInstCtrl->getMaterialMap();
 161
 162     // iterate over all parts of geometry
 163     GeoStoreIt gsIt   = _geoStore.begin();
 164     GeoStoreIt gsEnd  = _geoStore.end  ();
 165
 166     for(; gsIt != gsEnd; ++gsIt)
 167     {
 168         OSG_ASSERT(gsIt->_propStore.size() == gsIt->_indexStore.size());
 169
 170         // find the material associated with the geometry's material symbol
 171         ColMaterialMapConstIt mmIt       = matMap.find(gsIt->_matSymbol);
 172         std::string           matTarget;
 173
 174         if(mmIt != matMap.end())
 175         {
 176             matTarget = mmIt->second->getTarget();
 177         }
 178
 179         // can't reuse SkinnedGeometry, it may be instantiated with
 180         // a different Skeleton
 181
 182         // create new geometry
 183         SkinnedGeometryUnrecPtr geo = SkinnedGeometry::create();
 184
 185         getGlobal()->getStatCollector()->getElem(
 186             ColladaGlobal::statNGeometryCreated)->inc();
 187
 188         geo->setLengths(gsIt->_lengths);
 189         geo->setTypes  (gsIt->_types  );
 190
 191         Inherited::handleBindMaterial(*gsIt, geo, colInstCtrl);
 192
 193         geo->setSkeleton       (_skeleton                    );
 194         geo->setBindShapeMatrix(_matBindShape                );
 195         geo->setRenderMode     (SkinnedGeometry::RMSkinnedGPU);
 196
 197         PropStoreConstIt psIt  = (*gsIt)._propStore .begin();
 198         PropStoreConstIt psEnd = (*gsIt)._propStore .end  ();
 199
 200         for(; psIt != psEnd; ++psIt)
 201         {
 202             if((*psIt)._semantic == "JOINT_INDEX")
 203             {
 204                 for(UInt16 i = 0; i < geo->getMFProperties()->size(); ++i)
 205                 {
 206                     if((*psIt)._prop == geo->getProperty(i))
 207                     {
 208                         geo->setJointIndexProperty(i);
 209                         break;
 210                     }
 211                 }
 212             }
 213
 214             if((*psIt)._semantic == "JOINT_WEIGHT")
 215             {
 216                 for(UInt16 i = 0; i < geo->getMFProperties()->size(); ++i)
 217                 {
 218                     if((*psIt)._prop == geo->getProperty(i))
 219                     {
 220                         geo->setJointWeightProperty(i);
 221                         break;
 222                     }
 223                 }
 224             }
 225         }
 226
 227
 228         NodeUnrecPtr geoN = makeNodeFor(geo);
 229
 230         groupN->addChild(geoN);
 231     }
 232
 233     // store the generated group node
 234     editInstStore().push_back(groupN);
 235
 236     return groupN;
 237 }
 238
 239 ColladaController::ColladaController(daeElement *elem, ColladaGlobal *global)
 240     : Inherited    (elem, global)
 241     , _matBindShape()
 242     , _skeleton    (NULL)
 243 {
 244 }
 245
 246 ColladaController::~ColladaController(void)
 247 {
 248 }
 249
 250 void
 251 ColladaController::readSkin(domSkin *skin)
 252 {
 253     daeURI         geoURI = skin->getSource();
 254     domGeometryRef geo    = daeSafeCast<domGeometry>(geoURI.getElement());
 255
 256     if(geo == NULL)
 257     {
 258         SWARNING << "ColladaController::readSkin: Could not resolve source "
 259                  << "URI [" << geoURI.str() << "] to a <geometry>"
 260                  << std::endl;
 261         return;
 262     }
 263
 264     domMeshRef mesh = geo->getMesh();
 265
 266     if(mesh == NULL)
 267     {
 268         SWARNING << "ColladaController::readSkin: No <mesh> in <geometry>"
 269                  << std::endl;
 270         return;
 271     }
 272
 273     Inherited::readMesh(mesh);
 274
 275     readBindShapeMatrix(skin);
 276
 277     Inherited::readSources(skin->getSource_array());
 278
 279     // evaluate <vertex_weights>
 280     domSkin::domVertex_weightsRef    vweights = skin->getVertex_weights();
 281     const domInputLocalOffset_Array &inputs   = vweights->getInput_array();
 282
 283     UInt32              jointIdx  = UInt32(inputs.getCount());
 284     ColladaSourceRefPtr weightSrc = NULL;
 285
 286     for(UInt32 i = 0; i < inputs.getCount(); ++i)
 287     {
 288         std::string      semantic = inputs[i]->getSemantic();
 289         std::string      sourceId = inputs[i]->getSource  ().id();
 290         UInt32           offset   = inputs[i]->getOffset  ();
 291
 292         SourceMapConstIt smIt     = _sourceMap.find(sourceId);
 293
 294         if(smIt == _sourceMap.end())
 295         {
 296             SWARNING << "ColladaController::readSkin: Could not find "
 297                      << "<source> with id [" << sourceId << "] used by "
 298                      << "<input> [" << i << "] with semantic ["
 299                      << semantic << "]. Ignored." << std::endl;
 300             continue;
 301         }
 302
 303         if(semantic == "JOINT")
 304         {
 305             // which item of the index tuples in <v> hold the joint
 306             jointIdx = offset;
 307         }
 308         else if(semantic == "WEIGHT")
 309         {
 310             weightSrc = smIt->second;
 311         }
 312     }
 313
 314     // test if the file has the "usual" form, and only handle that
 315     //    this means there is an <input> with semantic "JOINT" and
 316     //    one with semantic "WEIGHT"
 317     if(jointIdx          <  inputs.getCount() && weightSrc != NULL &&
 318        inputs.getCount() == 2                                        )
 319     {
 320         GeoVec4fPropertyUnrecPtr jIndexProp  = GeoVec4fProperty::create();
 321         GeoVec4fPropertyUnrecPtr jWeightProp = GeoVec4fProperty::create();
 322
 323         GeoVec4fProperty::StoredFieldType *jIndexPropF  =
 324             jIndexProp ->editFieldPtr();
 325         GeoVec4fProperty::StoredFieldType *jWeightPropF =
 326             jWeightProp->editFieldPtr();
 327
 328         const domListOfUInts &vcount = vweights->getVcount()->getValue();
 329         const domListOfInts  &v      = vweights->getV     ()->getValue();
 330
 331         UInt32 vIdx = 0;
 332
 333         for(UInt32 i = 0; i < vcount.getCount(); ++i)
 334         {
 335             Vec4f jIndex;
 336             Vec4f jWeight;
 337
 338             if(vcount[i] > 4)
 339             {
 340                 SWARNING << "ColladaController::readSkin: Vertex [" << i
 341                          << "] has [" << vcount[i] << "] > 4 weights."
 342                          << std::endl;
 343             }
 344
 345             UInt32 j;
 346
 347             // the current vertex i is influenced by vcount[i] many joints
 348             for(j = 0; j < osgMin<UInt32>(4, vcount[i]); ++j)
 349             {
 350                 jIndex [j] = v[vIdx];
 351                 jWeight[j] = weightSrc->getFloatValue(v[vIdx + 1]);
 352
 353                 vIdx += 2;
 354             }
 355
 356 #if 0
 357             OSG_COLLADA_LOG(("ColladaController::readSkin: vert [%d] "
 358                              "jIndex [%f %f %f %f] jWeight [%f %f %f %f]\n",
 359                              i, jIndex[0], jIndex[1], jIndex[2], jIndex[3],
 360                              jWeight[0], jWeight[1], jWeight[2], jWeight[3]));
 361 #endif
 362
 363             jIndexPropF ->push_back(jIndex );
 364             jWeightPropF->push_back(jWeight);
 365
 366             // skip joint/weight indices we can not store (if any)
 367             for(j = osgMin<UInt32>(4, vcount[i]); j < vcount[i]; ++j)
 368             {
 369                 vIdx += 2;
 370             }
 371         }
 372
 373         OSG_COLLADA_LOG(("ColladaController::readSkin: "
 374                          "jIndexProp.size() [%" PRIUSize "] "
 375                          "jWeightProp.size() [%" PRIUSize "]\n",
 376                          jIndexProp->size(),
 377                          jWeightProp->size()));
 378
 379         // add jIndexProp and jWeightProp to geoInfos
 380         GeoStore::iterator gsIt  = _geoStore.begin();
 381         GeoStore::iterator gsEnd = _geoStore.end  ();
 382
 383         for(UInt32 i = 0; gsIt != gsEnd; ++gsIt, ++i)
 384         {
 385             // add joint index property
 386             UInt16 propSlot = Inherited::findFreePropertyIndex(i);
 387             gsIt->_propStore.resize (
 388                 osgMax<UInt16>(UInt16(gsIt->_propStore .size()), propSlot + 1), PropInfo());
 389             gsIt->_indexStore.resize(
 390                 osgMax<UInt16>(UInt16(gsIt->_indexStore.size()), propSlot + 1), NULL      );
 391
 392             gsIt->_propStore [propSlot]._prop     = jIndexProp;
 393             gsIt->_propStore [propSlot]._semantic = "JOINT_INDEX";
 394             gsIt->_propStore [propSlot]._set      = 0;
 395             gsIt->_indexStore[propSlot]           = gsIt->_indexStore[0];
 396
 397             // add weight property
 398             propSlot = Inherited::findFreePropertyIndex(i);
 399             gsIt->_propStore.resize (
 400                 osgMax<UInt16>(UInt16(gsIt->_propStore .size()), propSlot + 1), PropInfo());
 401             gsIt->_indexStore.resize(
 402                 osgMax<UInt16>(UInt16(gsIt->_indexStore.size()), propSlot + 1), NULL      );
 403
 404             gsIt->_propStore [propSlot]._prop     = jWeightProp;
 405             gsIt->_propStore [propSlot]._semantic = "JOINT_WEIGHT";
 406             gsIt->_propStore [propSlot]._set      = 0;
 407             gsIt->_indexStore[propSlot]           = gsIt->_indexStore[0];
 408         }
 409     }
 410     else
 411     {
 412         SWARNING << "ColladaController::readSkin: Can only handle "
 413                  << "<vertex_weights> with JOINT and WEIGHT <input>s."
 414                  << std::endl;
 415     }
 416 }
 417
 418 void
 419 ColladaController::readBindShapeMatrix(domSkin *skin)
 420 {
 421     domSkin::domBind_shape_matrixRef bsMat = skin->getBind_shape_matrix();
 422
 423     if(bsMat != NULL)
 424     {
 425         _matBindShape.setValue(bsMat->getValue()[ 0], bsMat->getValue()[ 1],
 426                                bsMat->getValue()[ 2], bsMat->getValue()[ 3],
 427                                bsMat->getValue()[ 4], bsMat->getValue()[ 5],
 428                                bsMat->getValue()[ 6], bsMat->getValue()[ 7],
 429                                bsMat->getValue()[ 8], bsMat->getValue()[ 9],
 430                                bsMat->getValue()[10], bsMat->getValue()[11],
 431                                bsMat->getValue()[12], bsMat->getValue()[13],
 432                                bsMat->getValue()[14], bsMat->getValue()[15] );
 433     }
 434     else
 435     {
 436         _matBindShape.setIdentity();
 437     }
 438
 439     if(_matBindShape.equals(Matrix::identity(), Eps) == true)
 440         return;
 441
 442 #if 0
 443     // transform the properties by the bind shape matrix
 444
 445     Matrix matBindShapeIT(_matBindShape);
 446     matBindShapeIT.invert   ();
 447     matBindShapeIT.transpose();
 448
 449     typedef std::set<GeoVectorProperty *> PropertySet;
 450     PropertySet xformedProps;
 451
 452     GeoStore::iterator gsIt  = _geoStore.begin();
 453     GeoStore::iterator gsEnd = _geoStore.end  ();
 454
 455     for(; gsIt != gsEnd; ++gsIt)
 456     {
 457         PropStoreIt psIt  = gsIt->_propStore.begin();
 458         PropStoreIt psEnd = gsIt->_propStore.end  ();
 459
 460         for(; psIt != psEnd; ++psIt)
 461         {
 462             if(psIt->_prop == NULL)
 463                 continue;
 464
 465             // only transform once
 466             if(xformedProps.count(psIt->_prop) > 0)
 467                 continue;
 468
 469             if(psIt->_semantic == "POSITION")
 470             {
 471                 for(UInt32 i = 0; i < psIt->_prop->size(); ++i)
 472                 {
 473                     Pnt4f pnt;
 474
 475                     psIt->_prop->getValue(pnt, i);
 476                     _matBindShape.mult(pnt, pnt);
 477                     psIt->_prop->setValue(pnt, i);
 478                 }
 479
 480                 OSG_COLLADA_LOG(("ColladaController::readBindShapeMatrix: "
 481                                  "Transformed property with semantic [%s]\n",
 482                                  psIt->_semantic.c_str()));
 483             }
 484             else if(psIt->_semantic == "NORMAL")
 485             {
 486                 for(UInt32 i = 0; i < psIt->_prop->size(); ++i)
 487                 {
 488                     Vec4f vec;
 489
 490                     psIt->_prop->getValue(vec, i);
 491                     matBindShapeIT.mult(vec, vec);
 492                     psIt->_prop->setValue(vec, i);
 493                 }
 494
 495                 OSG_COLLADA_LOG(("ColladaController::readBindShapeMatrix: "
 496                                  "Transformed property with semantic [%s]\n",
 497                                  psIt->_semantic.c_str()));
 498             }
 499             else
 500             {
 501                 OSG_COLLADA_LOG(("ColladaController::readBindShapeMatrix: "
 502                                  "Skipped property with semantic [%s]\n",
 503                                  psIt->_semantic.c_str()));
 504             }
 505
 506             xformedProps.insert(psIt->_prop);
 507         }
 508     }
 509 #endif
 510 }
 511
 512 void
 513 ColladaController::resolveJoints(
 514     domSkin        *skin,       ColladaInstanceController *colInstCtrl,
 515     JointInfoStore &jointStore, JointIdMap                &jointIdMap  )
 516 {
 517     domControllerRef      ctrl   = getDOMElementAs<domController>();
 518     domSkin::domJointsRef joints = skin->getJoints();
 519
 520     // find <input>s with handled semantics (JOINT and INV_BIND_MATRIX)
 521     // everything else is ignored/warned about
 522
 523     ColladaSourceRefPtr jointSrc = NULL;
 524     ColladaSourceRefPtr ibmSrc   = NULL;
 525
 526     const domInputLocal_Array &jointInputs = joints->getInput_array();
 527
 528     for(UInt32 i = 0; i < jointInputs.getCount(); ++i)
 529     {
 530         std::string      semantic = jointInputs[i]->getSemantic();
 531         std::string      sourceId = jointInputs[i]->getSource  ().id();
 532
 533         SourceMapConstIt smIt     = _sourceMap.find(sourceId);
 534
 535         if(smIt == _sourceMap.end())
 536         {
 537             SWARNING << "ColladaController::resolveJoints: Could not find "
 538                      << "<source> with id [" << sourceId << "] used by "
 539                      << "<input> [" << i << "] with semantic ["
 540                      << semantic << "]. Ignored." << std::endl;
 541             continue;
 542         }
 543
 544         if(semantic == "JOINT")
 545         {
 546             jointSrc = smIt->second;
 547         }
 548         else if(semantic == "INV_BIND_MATRIX")
 549         {
 550             ibmSrc = smIt->second;
 551         }
 552         else
 553         {
 554             SWARNING << "ColladaController::resolveJoints: Unknown semantic ["
 555                      << semantic << "] on <input> [" << i << "]"
 556                      << std::endl;
 557         }
 558     }
 559
 560     _skeleton = NULL;
 561
 562     // resolve joint names to <node>s and fill jointStore
 563
 564     if(jointSrc != NULL && ibmSrc != NULL)
 565     {
 566         const ColladaSource::NameStore   &jointNames  =
 567             jointSrc->getNameStore  ();
 568         const ColladaSource::MatrixStore &invBindMats =
 569             ibmSrc  ->getMatrixStore();
 570
 571         OSG_ASSERT(jointNames.size() == invBindMats.size());
 572
 573         for(UInt32 i = 0; i < jointNames.size(); ++i)
 574         {
 575             JointInfo jointInfo;
 576             // joint names are relative to the <skeleton> tags in the
 577             // <instance_controller> element
 578
 579             domNode *jointNode = colInstCtrl->findJointNode(jointNames[i]);
 580
 581             if(jointNode == NULL)
 582             {
 583                 SWARNING << "ColladaController::resolveJoints: Could not "
 584                          << "find <node> for joint name ["
 585                          << jointNames[i] << "] - <controller> ["
 586                          << (ctrl->getId() != NULL ? ctrl->getId() : "")
 587                          << "]. Ignored." << std::endl;
 588                 continue;
 589             }
 590
 591             if(jointNode->getType() != NODETYPE_JOINT)
 592             {
 593                 SWARNING << "ColladaController::resolveJoints: <node> for "
 594                          << "joint name [" << jointNames[i] << "] does not "
 595                          << "have node type JOINT. Ignored." << std::endl;
 596                 continue;
 597             }
 598
 599             ColladaNode *colJointNode = getUserDataAs<ColladaNode>(jointNode);
 600             OSG_ASSERT(colJointNode != NULL);
 601
 602             // store skeleton and ensure all joints belong to the same one
 603             if(_skeleton != NULL)
 604             {
 605                 if(_skeleton != colJointNode->getSkeleton())
 606                 {
 607                     SWARNING << "ColladaController::resolveJoints: joint ["
 608                              << i << "] name [" << jointNames[i]
 609                              << "] belongs to differente skeleton. Ignoring."
 610                              << std::endl;
 611                     continue;
 612                 }
 613             }
 614             else
 615             {
 616                 _skeleton = colJointNode->getSkeleton();
 617             }
 618
 619             if(colJointNode->getInstStore().size() > 1)
 620             {
 621                 SWARNING << "ColladaController::resolveJoints: joint ["
 622                          << i << "] name [" << jointNames[i]
 623                          << "] has multiple instances. Using instance 0."
 624                          << std::endl;
 625             }
 626
 627             SkeletonJoint *joint = dynamic_cast<SkeletonJoint *>(
 628                 colJointNode->getBottomNode(0)->getCore());
 629
 630             if(joint->getInvBindMatrix().equals(Matrix::identity(), Eps) == true)
 631             {
 632                 joint->setInvBindMatrix(invBindMats[i]);
 633             }
 634             else if(joint->getInvBindMatrix().equals(invBindMats[i], Eps) == false)
 635             {
 636                 SWARNING << "ColladaController::resolveJoints: joint ["
 637                          << i << "] name [" << jointNames[i]
 638                          << "] already has a different inv bind matrix."
 639                          << std::endl;
 640             }
 641
 642             jointInfo.jointNode     = jointNode;
 643             jointInfo.colJointNode  = colJointNode;
 644             jointInfo.jointId       = joint->getJointId();
 645             jointInfo.invBindMatrix = invBindMats[i];
 646
 647             jointStore.push_back(jointInfo);
 648
 649             // remember joint id mapping
 650             jointIdMap.push_back(joint->getJointId());
 651
 652             OSG_COLLADA_LOG(("ColladaController::resolveJoints: Resolved "
 653                              "joint [%d] name [%s] jointId [%d]\n",
 654                              i, jointNames[i].c_str(), joint->getJointId() ));
 655         }
 656     }
 657     else
 658     {
 659         SWARNING << "ColladaController::resolveJoints: Can only handle "
 660                  << "<joints> with JOINT and INV_BIND_MATRIX <input>s."
 661                  << std::endl;
 662     }
 663 }
 664
 665 void
 666 ColladaController::remapJointIds(
 667     domSkin                   *skin,
 668     ColladaInstanceController *colInstCtrl,
 669     const JointInfoStore      &jointStore,
 670     const JointIdMap          &jointIdMap  )
 671 {
 672     typedef std::set<GeoVectorProperty *> PropertySet;
 673     PropertySet mappedProps;
 674
 675     GeoStore::iterator gsIt  = _geoStore.begin();
 676     GeoStore::iterator gsEnd = _geoStore.end  ();
 677
 678     for(; gsIt != gsEnd; ++gsIt)
 679     {
 680         PropStoreIt psIt  = gsIt->_propStore.begin();
 681         PropStoreIt psEnd = gsIt->_propStore.end  ();
 682
 683         for(; psIt != psEnd; ++psIt)
 684         {
 685             if(psIt->_prop == NULL)
 686                 continue;
 687
 688             if(mappedProps.count(psIt->_prop) > 0)
 689                 continue;
 690
 691             if(psIt->_semantic != "JOINT_INDEX")
 692                 continue;
 693
 694             GeoVec4fPropertyUnrecPtr jIndexProp =
 695                 dynamic_pointer_cast<GeoVec4fProperty>(psIt->_prop);
 696
 697             GeoVec4fProperty::StoredFieldType *jIndexPropF =
 698                 jIndexProp->editFieldPtr();
 699
 700             for(UInt32 i = 0; i < jIndexPropF->size(); ++i)
 701             {
 702                 Vec4f jIdx = (*jIndexPropF)[i];
 703
 704                 jIdx[0] = jointIdMap[UInt32(jIdx[0])];
 705                 jIdx[1] = jointIdMap[UInt32(jIdx[1])];
 706                 jIdx[2] = jointIdMap[UInt32(jIdx[2])];
 707                 jIdx[3] = jointIdMap[UInt32(jIdx[3])];
 708
 709                 (*jIndexPropF)[i] = jIdx;
 710             }
 711
 712             mappedProps.insert(jIndexProp);
 713         }
 714     }
 715 }
 716
 717 Int32
 718 ColladaController::findJoint(
 719     const JointInfoStore &jointStore, domNode *joint)
 720 {
 721     Int32                 retVal = -1;
 722     JointInfoStoreConstIt jIt    = jointStore.begin();
 723     JointInfoStoreConstIt jEnd   = jointStore.end  ();
 724
 725     for(Int32 i = 0; jIt != jEnd; ++jIt, ++i)
 726     {
 727         if(jIt->jointNode == joint)
 728         {
 729             retVal = i;
 730             break;
 731         }
 732     }
 733
 734     return retVal;
 735 }
 736
 737 OSG_END_NAMESPACE
 738
 739 #endif // OSG_WITH_COLLADA