Source/System/Dynamics/Skeleton/OSGSkinnedGeometryBase.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *               Copyright (C) 2000-2013 by the OpenSG Forum                 *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  * contact: dirk@opensg.org, gerrit.voss@vossg.org, carsten_neumann@gmx.net  *
  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 /*****************************************************************************\
  40  *****************************************************************************
  41  **                                                                         **
  42  **                  This file is automatically generated.                  **
  43  **                                                                         **
  44  **          Any changes made to this file WILL be lost when it is          **
  45  **           regenerated, which can become necessary at any time.          **
  46  **                                                                         **
  47  **     Do not change this file, changes should be done in the derived      **
  48  **     class SkinnedGeometry!
  49  **                                                                         **
  50  *****************************************************************************
  51 \*****************************************************************************/
  52
  53 #include <cstdlib>
  54 #include <cstdio>
  55
  56 #ifdef WIN32
  57 #pragma warning(disable: 4355) // turn off 'this' : used in base member initializer list warning
  58 #pragma warning(disable: 4290) // disable exception specification warning
  59 #endif
  60
  61 #include "OSGConfig.h"
  62
  63
  64
  65 #include "OSGSkeleton.h"                // Skeleton Class
  66 #include "OSGSkinningAlgorithm.h"       // SkinningAlgorithm Class
  67
  68 #include "OSGSkinnedGeometryBase.h"
  69 #include "OSGSkinnedGeometry.h"
  70
  71 #include <boost/bind.hpp>
  72
  73 OSG_BEGIN_NAMESPACE
  74
  75 /***************************************************************************\
  76  *                            Description                                  *
  77 \***************************************************************************/
  78
  79 /*! \class OSG::SkinnedGeometry
  80
  81  */
  82
  83 /***************************************************************************\
  84  *                        Field Documentation                              *
  85 \***************************************************************************/
  86
  87 /*! \var Skeleton *      SkinnedGeometryBase::_sfSkeleton
  88     The Skeleton that deforms this geometry.
  89 */
  90
  91 /*! \var Matrix          SkinnedGeometryBase::_sfBindShapeMatrix
  92     Matrix that is applied to the vertices of the mesh before deformation.
  93     It transforms the vertices into bind space.
  94 */
  95
  96 /*! \var Int16           SkinnedGeometryBase::_mfJointIds
  97     List of jointIds that are used by this SkinnedGeometry.
  98 */
  99
 100 /*! \var UInt16          SkinnedGeometryBase::_sfJointIndexProperty
 101     Index of the property that stores the joint indices that influence
 102     a vertex.
 103 */
 104
 105 /*! \var UInt16          SkinnedGeometryBase::_sfJointWeightProperty
 106     Index of the property that stores the joint weights that influence
 107     a vertex.
 108 */
 109
 110 /*! \var UInt32          SkinnedGeometryBase::_sfRenderMode
 111     Mode used to render this skinned geometry, one of the RenderModeE
 112     enums values. Effectively selects the SkinningAlgorithm to use.
 113 */
 114
 115 /*! \var SkinningAlgorithm * SkinnedGeometryBase::_sfSkinningAlgorithm
 116
 117 */
 118
 119
 120 /***************************************************************************\
 121  *                      FieldType/FieldTrait Instantiation                 *
 122 \***************************************************************************/
 123
 124 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
 125 PointerType FieldTraits<SkinnedGeometry *, nsOSG>::_type(
 126     "SkinnedGeometryPtr",
 127     "GeometryPtr",
 128     SkinnedGeometry::getClassType(),
 129     nsOSG);
 130 #endif
 131
 132 OSG_FIELDTRAITS_GETTYPE_NS(SkinnedGeometry *, nsOSG)
 133
 134 OSG_EXPORT_PTR_SFIELD_FULL(PointerSField,
 135                            SkinnedGeometry *,
 136                            nsOSG)
 137
 138 OSG_EXPORT_PTR_MFIELD_FULL(PointerMField,
 139                            SkinnedGeometry *,
 140                            nsOSG)
 141
 142 DataType &FieldTraits<SkinnedGeometry *, nsOSG + 1 >::getType(void)
 143 {
 144     return FieldTraits<SkinnedGeometry *, nsOSG>::getType();
 145 }
 146
 147
 148 OSG_SFIELDTYPE_INST(ParentPointerSField,
 149                     SkinnedGeometry *,
 150                     NoRefCountPolicy,
 151                     nsOSG + 1);
 152
 153 OSG_FIELD_DLLEXPORT_DEF3(ParentPointerSField,
 154                          SkinnedGeometry *,
 155                          NoRefCountPolicy,
 156                          nsOSG + 1)
 157
 158
 159 OSG_MFIELDTYPE_INST(ParentPointerMField,
 160                     SkinnedGeometry *,
 161                     NoRefCountPolicy,
 162                     1);
 163
 164 OSG_FIELD_DLLEXPORT_DEF3(ParentPointerMField,
 165                          SkinnedGeometry *,
 166                          NoRefCountPolicy,
 167                          1)
 168
 169
 170 /***************************************************************************\
 171  *                         Field Description                               *
 172 \***************************************************************************/
 173
 174 void SkinnedGeometryBase::classDescInserter(TypeObject &oType)
 175 {
 176     FieldDescriptionBase *pDesc = NULL;
 177
 178
 179     pDesc = new SFUnrecSkeletonPtr::Description(
 180         SFUnrecSkeletonPtr::getClassType(),
 181         "skeleton",
 182         "The Skeleton that deforms this geometry.\n",
 183         SkeletonFieldId, SkeletonFieldMask,
 184         false,
 185         (Field::SFDefaultFlags | Field::FStdAccess),
 186         static_cast<FieldEditMethodSig>(&SkinnedGeometry::editHandleSkeleton),
 187         static_cast<FieldGetMethodSig >(&SkinnedGeometry::getHandleSkeleton));
 188
 189     oType.addInitialDesc(pDesc);
 190
 191     pDesc = new SFMatrix::Description(
 192         SFMatrix::getClassType(),
 193         "bindShapeMatrix",
 194         "Matrix that is applied to the vertices of the mesh before deformation.\n"
 195         "It transforms the vertices into bind space.\n",
 196         BindShapeMatrixFieldId, BindShapeMatrixFieldMask,
 197         false,
 198         (Field::SFDefaultFlags | Field::FStdAccess),
 199         static_cast<FieldEditMethodSig>(&SkinnedGeometry::editHandleBindShapeMatrix),
 200         static_cast<FieldGetMethodSig >(&SkinnedGeometry::getHandleBindShapeMatrix));
 201
 202     oType.addInitialDesc(pDesc);
 203
 204     pDesc = new MFInt16::Description(
 205         MFInt16::getClassType(),
 206         "jointIds",
 207         "List of jointIds that are used by this SkinnedGeometry.\n",
 208         JointIdsFieldId, JointIdsFieldMask,
 209         false,
 210         (Field::MFDefaultFlags | Field::FStdAccess),
 211         static_cast<FieldEditMethodSig>(&SkinnedGeometry::editHandleJointIds),
 212         static_cast<FieldGetMethodSig >(&SkinnedGeometry::getHandleJointIds));
 213
 214     oType.addInitialDesc(pDesc);
 215
 216     pDesc = new SFUInt16::Description(
 217         SFUInt16::getClassType(),
 218         "jointIndexProperty",
 219         "Index of the property that stores the joint indices that influence\n"
 220         "a vertex.\n",
 221         JointIndexPropertyFieldId, JointIndexPropertyFieldMask,
 222         false,
 223         (Field::SFDefaultFlags | Field::FStdAccess),
 224         static_cast<FieldEditMethodSig>(&SkinnedGeometry::editHandleJointIndexProperty),
 225         static_cast<FieldGetMethodSig >(&SkinnedGeometry::getHandleJointIndexProperty));
 226
 227     oType.addInitialDesc(pDesc);
 228
 229     pDesc = new SFUInt16::Description(
 230         SFUInt16::getClassType(),
 231         "jointWeightProperty",
 232         "Index of the property that stores the joint weights that influence\n"
 233         "a vertex.\n",
 234         JointWeightPropertyFieldId, JointWeightPropertyFieldMask,
 235         false,
 236         (Field::SFDefaultFlags | Field::FStdAccess),
 237         static_cast<FieldEditMethodSig>(&SkinnedGeometry::editHandleJointWeightProperty),
 238         static_cast<FieldGetMethodSig >(&SkinnedGeometry::getHandleJointWeightProperty));
 239
 240     oType.addInitialDesc(pDesc);
 241
 242     pDesc = new SFUInt32::Description(
 243         SFUInt32::getClassType(),
 244         "renderMode",
 245         "Mode used to render this skinned geometry, one of the RenderModeE\n"
 246         "enums values. Effectively selects the SkinningAlgorithm to use.\n",
 247         RenderModeFieldId, RenderModeFieldMask,
 248         false,
 249         (Field::SFDefaultFlags | Field::FStdAccess),
 250         static_cast<FieldEditMethodSig>(&SkinnedGeometry::editHandleRenderMode),
 251         static_cast<FieldGetMethodSig >(&SkinnedGeometry::getHandleRenderMode));
 252
 253     oType.addInitialDesc(pDesc);
 254
 255     pDesc = new SFUnrecChildSkinningAlgorithmPtr::Description(
 256         SFUnrecChildSkinningAlgorithmPtr::getClassType(),
 257         "skinningAlgorithm",
 258         "",
 259         SkinningAlgorithmFieldId, SkinningAlgorithmFieldMask,
 260         false,
 261         (Field::SFDefaultFlags | Field::FStdAccess),
 262         static_cast<FieldEditMethodSig>(&SkinnedGeometry::editHandleSkinningAlgorithm),
 263         static_cast<FieldGetMethodSig >(&SkinnedGeometry::getHandleSkinningAlgorithm));
 264
 265     oType.addInitialDesc(pDesc);
 266 }
 267
 268
 269 SkinnedGeometryBase::TypeObject SkinnedGeometryBase::_type(
 270     SkinnedGeometryBase::getClassname(),
 271     Inherited::getClassname(),
 272     "NULL",
 273     nsOSG, //Namespace
 274     reinterpret_cast<PrototypeCreateF>(&SkinnedGeometryBase::createEmptyLocal),
 275     reinterpret_cast<InitContainerF>(&SkinnedGeometry::initMethod),
 276     reinterpret_cast<ExitContainerF>(&SkinnedGeometry::exitMethod),
 277     reinterpret_cast<InitalInsertDescFunc>(
 278         reinterpret_cast<void *>(&SkinnedGeometry::classDescInserter)),
 279     false,
 280     0,
 281     "<?xml version=\"1.0\"?>\n"
 282     "\n"
 283     "<FieldContainer\n"
 284     "   name=\"SkinnedGeometry\"\n"
 285     "   parent=\"Geometry\"\n"
 286     "   library=\"Dynamics\"\n"
 287     "   pointerfieldtypes=\"both\"\n"
 288     "   structure=\"concrete\"\n"
 289     "   systemcomponent=\"true\"\n"
 290     "   parentsystemcomponent=\"true\"\n"
 291     "   decoratable=\"false\"\n"
 292     "   childFields=\"none\"\n"
 293     "   parentFields=\"both\"\n"
 294     ">\n"
 295     "\n"
 296     "  <Field\n"
 297     "     name=\"skeleton\"\n"
 298     "     type=\"Skeleton\"\n"
 299     "     category=\"pointer\"\n"
 300     "     cardinality=\"single\"\n"
 301     "     visibility=\"external\"\n"
 302     "     access=\"public\"\n"
 303     "     >\n"
 304     "    The Skeleton that deforms this geometry.\n"
 305     "  </Field>\n"
 306     "\n"
 307     "  <Field\n"
 308     "     name=\"bindShapeMatrix\"\n"
 309     "     type=\"Matrix\"\n"
 310     "     category=\"data\"\n"
 311     "     cardinality=\"single\"\n"
 312     "     visibility=\"external\"\n"
 313     "     access=\"public\"\n"
 314     "     >\n"
 315     "    Matrix that is applied to the vertices of the mesh before deformation.\n"
 316     "    It transforms the vertices into bind space.\n"
 317     "  </Field>\n"
 318     "\n"
 319     "  <Field\n"
 320     "     name=\"jointIds\"\n"
 321     "     type=\"Int16\"\n"
 322     "     category=\"data\"\n"
 323     "     cardinality=\"multi\"\n"
 324     "     visibility=\"external\"\n"
 325     "     access=\"public\"\n"
 326     "     >\n"
 327     "    List of jointIds that are used by this SkinnedGeometry.\n"
 328     "  </Field>\n"
 329     "\n"
 330     "  <Field\n"
 331     "     name=\"jointIndexProperty\"\n"
 332     "     type=\"UInt16\"\n"
 333     "     category=\"data\"\n"
 334     "     cardinality=\"single\"\n"
 335     "     visibility=\"external\"\n"
 336     "     access=\"public\"\n"
 337     "     defaultValue=\"TypeTraits&lt;UInt16&gt;::getMax()\"\n"
 338     "     >\n"
 339     "    Index of the property that stores the joint indices that influence\n"
 340     "    a vertex.\n"
 341     "  </Field>\n"
 342     "  \n"
 343     "  <Field\n"
 344     "     name=\"jointWeightProperty\"\n"
 345     "     type=\"UInt16\"\n"
 346     "     category=\"data\"\n"
 347     "     cardinality=\"single\"\n"
 348     "     visibility=\"external\"\n"
 349     "     access=\"public\"\n"
 350     "     defaultValue=\"TypeTraits&lt;UInt16&gt;::getMax()\"\n"
 351     "     >\n"
 352     "    Index of the property that stores the joint weights that influence\n"
 353     "    a vertex.\n"
 354     "  </Field>\n"
 355     "\n"
 356     "  <Field\n"
 357     "     name=\"renderMode\"\n"
 358     "     type=\"UInt32\"\n"
 359     "     category=\"data\"\n"
 360     "     cardinality=\"single\"\n"
 361     "     visibility=\"external\"\n"
 362     "     access=\"public\"\n"
 363     "     defaultValue=\"0\"\n"
 364     "     >\n"
 365     "    Mode used to render this skinned geometry, one of the RenderModeE\n"
 366     "    enums values. Effectively selects the SkinningAlgorithm to use.\n"
 367     "  </Field>\n"
 368     "\n"
 369     "  <Field\n"
 370     "     name=\"skinningAlgorithm\"\n"
 371     "     type=\"SkinningAlgorithm\"\n"
 372     "     category=\"childpointer\"\n"
 373     "     linkParentField=\"Skin\"\n"
 374     "     cardinality=\"single\"\n"
 375     "     visibility=\"external\"\n"
 376     "     access=\"protected\"\n"
 377     "     defaultValue=\"NULL\"\n"
 378     "     >\n"
 379     "  </Field>\n"
 380     "\n"
 381     "</FieldContainer>\n",
 382     ""
 383     );
 384
 385 /*------------------------------ get -----------------------------------*/
 386
 387 FieldContainerType &SkinnedGeometryBase::getType(void)
 388 {
 389     return _type;
 390 }
 391
 392 const FieldContainerType &SkinnedGeometryBase::getType(void) const
 393 {
 394     return _type;
 395 }
 396
 397 UInt32 SkinnedGeometryBase::getContainerSize(void) const
 398 {
 399     return sizeof(SkinnedGeometry);
 400 }
 401
 402 /*------------------------- decorator get ------------------------------*/
 403
 404
 405 //! Get the SkinnedGeometry::_sfSkeleton field.
 406 const SFUnrecSkeletonPtr *SkinnedGeometryBase::getSFSkeleton(void) const
 407 {
 408     return &_sfSkeleton;
 409 }
 410
 411 SFUnrecSkeletonPtr  *SkinnedGeometryBase::editSFSkeleton       (void)
 412 {
 413     editSField(SkeletonFieldMask);
 414
 415     return &_sfSkeleton;
 416 }
 417
 418 //! Get the value of the SkinnedGeometry::_sfSkeleton field.
 419 Skeleton * SkinnedGeometryBase::getSkeleton(void) const
 420 {
 421     return _sfSkeleton.getValue();
 422 }
 423
 424 //! Set the value of the SkinnedGeometry::_sfSkeleton field.
 425 void SkinnedGeometryBase::setSkeleton(Skeleton * const value)
 426 {
 427     editSField(SkeletonFieldMask);
 428
 429     _sfSkeleton.setValue(value);
 430 }
 431
 432
 433 SFMatrix *SkinnedGeometryBase::editSFBindShapeMatrix(void)
 434 {
 435     editSField(BindShapeMatrixFieldMask);
 436
 437     return &_sfBindShapeMatrix;
 438 }
 439
 440 const SFMatrix *SkinnedGeometryBase::getSFBindShapeMatrix(void) const
 441 {
 442     return &_sfBindShapeMatrix;
 443 }
 444
 445
 446 MFInt16 *SkinnedGeometryBase::editMFJointIds(void)
 447 {
 448     editMField(JointIdsFieldMask, _mfJointIds);
 449
 450     return &_mfJointIds;
 451 }
 452
 453 const MFInt16 *SkinnedGeometryBase::getMFJointIds(void) const
 454 {
 455     return &_mfJointIds;
 456 }
 457
 458
 459 SFUInt16 *SkinnedGeometryBase::editSFJointIndexProperty(void)
 460 {
 461     editSField(JointIndexPropertyFieldMask);
 462
 463     return &_sfJointIndexProperty;
 464 }
 465
 466 const SFUInt16 *SkinnedGeometryBase::getSFJointIndexProperty(void) const
 467 {
 468     return &_sfJointIndexProperty;
 469 }
 470
 471
 472 SFUInt16 *SkinnedGeometryBase::editSFJointWeightProperty(void)
 473 {
 474     editSField(JointWeightPropertyFieldMask);
 475
 476     return &_sfJointWeightProperty;
 477 }
 478
 479 const SFUInt16 *SkinnedGeometryBase::getSFJointWeightProperty(void) const
 480 {
 481     return &_sfJointWeightProperty;
 482 }
 483
 484
 485 SFUInt32 *SkinnedGeometryBase::editSFRenderMode(void)
 486 {
 487     editSField(RenderModeFieldMask);
 488
 489     return &_sfRenderMode;
 490 }
 491
 492 const SFUInt32 *SkinnedGeometryBase::getSFRenderMode(void) const
 493 {
 494     return &_sfRenderMode;
 495 }
 496
 497
 498 //! Get the SkinnedGeometry::_sfSkinningAlgorithm field.
 499 const SFUnrecChildSkinningAlgorithmPtr *SkinnedGeometryBase::getSFSkinningAlgorithm(void) const
 500 {
 501     return &_sfSkinningAlgorithm;
 502 }
 503
 504 SFUnrecChildSkinningAlgorithmPtr *SkinnedGeometryBase::editSFSkinningAlgorithm(void)
 505 {
 506     editSField(SkinningAlgorithmFieldMask);
 507
 508     return &_sfSkinningAlgorithm;
 509 }
 510
 511 //! Get the value of the SkinnedGeometry::_sfSkinningAlgorithm field.
 512 SkinningAlgorithm * SkinnedGeometryBase::getSkinningAlgorithm(void) const
 513 {
 514     return _sfSkinningAlgorithm.getValue();
 515 }
 516
 517 //! Set the value of the SkinnedGeometry::_sfSkinningAlgorithm field.
 518 void SkinnedGeometryBase::setSkinningAlgorithm(SkinningAlgorithm * const value)
 519 {
 520     editSField(SkinningAlgorithmFieldMask);
 521
 522     _sfSkinningAlgorithm.setValue(value);
 523 }
 524
 525
 526
 527
 528
 529
 530 /*------------------------------ access -----------------------------------*/
 531
 532 SizeT SkinnedGeometryBase::getBinSize(ConstFieldMaskArg whichField)
 533 {
 534     SizeT returnValue = Inherited::getBinSize(whichField);
 535
 536     if(FieldBits::NoField != (SkeletonFieldMask & whichField))
 537     {
 538         returnValue += _sfSkeleton.getBinSize();
 539     }
 540     if(FieldBits::NoField != (BindShapeMatrixFieldMask & whichField))
 541     {
 542         returnValue += _sfBindShapeMatrix.getBinSize();
 543     }
 544     if(FieldBits::NoField != (JointIdsFieldMask & whichField))
 545     {
 546         returnValue += _mfJointIds.getBinSize();
 547     }
 548     if(FieldBits::NoField != (JointIndexPropertyFieldMask & whichField))
 549     {
 550         returnValue += _sfJointIndexProperty.getBinSize();
 551     }
 552     if(FieldBits::NoField != (JointWeightPropertyFieldMask & whichField))
 553     {
 554         returnValue += _sfJointWeightProperty.getBinSize();
 555     }
 556     if(FieldBits::NoField != (RenderModeFieldMask & whichField))
 557     {
 558         returnValue += _sfRenderMode.getBinSize();
 559     }
 560     if(FieldBits::NoField != (SkinningAlgorithmFieldMask & whichField))
 561     {
 562         returnValue += _sfSkinningAlgorithm.getBinSize();
 563     }
 564
 565     return returnValue;
 566 }
 567
 568 void SkinnedGeometryBase::copyToBin(BinaryDataHandler &pMem,
 569                                   ConstFieldMaskArg  whichField)
 570 {
 571     Inherited::copyToBin(pMem, whichField);
 572
 573     if(FieldBits::NoField != (SkeletonFieldMask & whichField))
 574     {
 575         _sfSkeleton.copyToBin(pMem);
 576     }
 577     if(FieldBits::NoField != (BindShapeMatrixFieldMask & whichField))
 578     {
 579         _sfBindShapeMatrix.copyToBin(pMem);
 580     }
 581     if(FieldBits::NoField != (JointIdsFieldMask & whichField))
 582     {
 583         _mfJointIds.copyToBin(pMem);
 584     }
 585     if(FieldBits::NoField != (JointIndexPropertyFieldMask & whichField))
 586     {
 587         _sfJointIndexProperty.copyToBin(pMem);
 588     }
 589     if(FieldBits::NoField != (JointWeightPropertyFieldMask & whichField))
 590     {
 591         _sfJointWeightProperty.copyToBin(pMem);
 592     }
 593     if(FieldBits::NoField != (RenderModeFieldMask & whichField))
 594     {
 595         _sfRenderMode.copyToBin(pMem);
 596     }
 597     if(FieldBits::NoField != (SkinningAlgorithmFieldMask & whichField))
 598     {
 599         _sfSkinningAlgorithm.copyToBin(pMem);
 600     }
 601 }
 602
 603 void SkinnedGeometryBase::copyFromBin(BinaryDataHandler &pMem,
 604                                     ConstFieldMaskArg  whichField)
 605 {
 606     Inherited::copyFromBin(pMem, whichField);
 607
 608     if(FieldBits::NoField != (SkeletonFieldMask & whichField))
 609     {
 610         editSField(SkeletonFieldMask);
 611         _sfSkeleton.copyFromBin(pMem);
 612     }
 613     if(FieldBits::NoField != (BindShapeMatrixFieldMask & whichField))
 614     {
 615         editSField(BindShapeMatrixFieldMask);
 616         _sfBindShapeMatrix.copyFromBin(pMem);
 617     }
 618     if(FieldBits::NoField != (JointIdsFieldMask & whichField))
 619     {
 620         editMField(JointIdsFieldMask, _mfJointIds);
 621         _mfJointIds.copyFromBin(pMem);
 622     }
 623     if(FieldBits::NoField != (JointIndexPropertyFieldMask & whichField))
 624     {
 625         editSField(JointIndexPropertyFieldMask);
 626         _sfJointIndexProperty.copyFromBin(pMem);
 627     }
 628     if(FieldBits::NoField != (JointWeightPropertyFieldMask & whichField))
 629     {
 630         editSField(JointWeightPropertyFieldMask);
 631         _sfJointWeightProperty.copyFromBin(pMem);
 632     }
 633     if(FieldBits::NoField != (RenderModeFieldMask & whichField))
 634     {
 635         editSField(RenderModeFieldMask);
 636         _sfRenderMode.copyFromBin(pMem);
 637     }
 638     if(FieldBits::NoField != (SkinningAlgorithmFieldMask & whichField))
 639     {
 640         editSField(SkinningAlgorithmFieldMask);
 641         _sfSkinningAlgorithm.copyFromBin(pMem);
 642     }
 643 }
 644
 645 //! create a new instance of the class
 646 SkinnedGeometryTransitPtr SkinnedGeometryBase::createLocal(BitVector bFlags)
 647 {
 648     SkinnedGeometryTransitPtr fc;
 649
 650     if(getClassType().getPrototype() != NULL)
 651     {
 652         FieldContainerTransitPtr tmpPtr =
 653             getClassType().getPrototype()-> shallowCopyLocal(bFlags);
 654
 655         fc = dynamic_pointer_cast<SkinnedGeometry>(tmpPtr);
 656     }
 657
 658     return fc;
 659 }
 660
 661 //! create a new instance of the class, copy the container flags
 662 SkinnedGeometryTransitPtr SkinnedGeometryBase::createDependent(BitVector bFlags)
 663 {
 664     SkinnedGeometryTransitPtr fc;
 665
 666     if(getClassType().getPrototype() != NULL)
 667     {
 668         FieldContainerTransitPtr tmpPtr =
 669             getClassType().getPrototype()-> shallowCopyDependent(bFlags);
 670
 671         fc = dynamic_pointer_cast<SkinnedGeometry>(tmpPtr);
 672     }
 673
 674     return fc;
 675 }
 676
 677 //! create a new instance of the class
 678 SkinnedGeometryTransitPtr SkinnedGeometryBase::create(void)
 679 {
 680     SkinnedGeometryTransitPtr fc;
 681
 682     if(getClassType().getPrototype() != NULL)
 683     {
 684         FieldContainerTransitPtr tmpPtr =
 685             getClassType().getPrototype()-> shallowCopy();
 686
 687         fc = dynamic_pointer_cast<SkinnedGeometry>(tmpPtr);
 688     }
 689
 690     return fc;
 691 }
 692
 693 SkinnedGeometry *SkinnedGeometryBase::createEmptyLocal(BitVector bFlags)
 694 {
 695     SkinnedGeometry *returnValue;
 696
 697     newPtr<SkinnedGeometry>(returnValue, bFlags);
 698
 699     returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
 700
 701     return returnValue;
 702 }
 703
 704 //! create an empty new instance of the class, do not copy the prototype
 705 SkinnedGeometry *SkinnedGeometryBase::createEmpty(void)
 706 {
 707     SkinnedGeometry *returnValue;
 708
 709     newPtr<SkinnedGeometry>(returnValue, Thread::getCurrentLocalFlags());
 710
 711     returnValue->_pFieldFlags->_bNamespaceMask &=
 712         ~Thread::getCurrentLocalFlags();
 713
 714     return returnValue;
 715 }
 716
 717
 718 FieldContainerTransitPtr SkinnedGeometryBase::shallowCopyLocal(
 719     BitVector bFlags) const
 720 {
 721     SkinnedGeometry *tmpPtr;
 722
 723     newPtr(tmpPtr, dynamic_cast<const SkinnedGeometry *>(this), bFlags);
 724
 725     FieldContainerTransitPtr returnValue(tmpPtr);
 726
 727     tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
 728
 729     return returnValue;
 730 }
 731
 732 FieldContainerTransitPtr SkinnedGeometryBase::shallowCopyDependent(
 733     BitVector bFlags) const
 734 {
 735     SkinnedGeometry *tmpPtr;
 736
 737     newPtr(tmpPtr, dynamic_cast<const SkinnedGeometry *>(this), ~bFlags);
 738
 739     FieldContainerTransitPtr returnValue(tmpPtr);
 740
 741     tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
 742
 743     return returnValue;
 744 }
 745
 746 FieldContainerTransitPtr SkinnedGeometryBase::shallowCopy(void) const
 747 {
 748     SkinnedGeometry *tmpPtr;
 749
 750     newPtr(tmpPtr,
 751            dynamic_cast<const SkinnedGeometry *>(this),
 752            Thread::getCurrentLocalFlags());
 753
 754     tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
 755
 756     FieldContainerTransitPtr returnValue(tmpPtr);
 757
 758     return returnValue;
 759 }
 760
 761
 762
 763
 764 /*------------------------- constructors ----------------------------------*/
 765
 766 SkinnedGeometryBase::SkinnedGeometryBase(void) :
 767     Inherited(),
 768     _sfSkeleton               (NULL),
 769     _sfBindShapeMatrix        (),
 770     _mfJointIds               (),
 771     _sfJointIndexProperty     (UInt16(TypeTraits<UInt16>::getMax())),
 772     _sfJointWeightProperty    (UInt16(TypeTraits<UInt16>::getMax())),
 773     _sfRenderMode             (UInt32(0)),
 774     _sfSkinningAlgorithm      (this,
 775                           SkinningAlgorithmFieldId,
 776                           SkinningAlgorithm::SkinFieldId)
 777 {
 778 }
 779
 780 SkinnedGeometryBase::SkinnedGeometryBase(const SkinnedGeometryBase &source) :
 781     Inherited(source),
 782     _sfSkeleton               (NULL),
 783     _sfBindShapeMatrix        (source._sfBindShapeMatrix        ),
 784     _mfJointIds               (source._mfJointIds               ),
 785     _sfJointIndexProperty     (source._sfJointIndexProperty     ),
 786     _sfJointWeightProperty    (source._sfJointWeightProperty    ),
 787     _sfRenderMode             (source._sfRenderMode             ),
 788     _sfSkinningAlgorithm      (this,
 789                           SkinningAlgorithmFieldId,
 790                           SkinningAlgorithm::SkinFieldId)
 791 {
 792 }
 793
 794
 795 /*-------------------------- destructors ----------------------------------*/
 796
 797 SkinnedGeometryBase::~SkinnedGeometryBase(void)
 798 {
 799 }
 800
 801 /*-------------------------------------------------------------------------*/
 802 /* Child linking                                                           */
 803
 804 bool SkinnedGeometryBase::unlinkChild(
 805     FieldContainer * const pChild,
 806     UInt16           const childFieldId)
 807 {
 808     if(childFieldId == SkinningAlgorithmFieldId)
 809     {
 810         SkinningAlgorithm * pTypedChild =
 811             dynamic_cast<SkinningAlgorithm *>(pChild);
 812
 813         if(pTypedChild != NULL)
 814         {
 815             if(_sfSkinningAlgorithm.getValue() == pTypedChild)
 816             {
 817                 editSField(SkinningAlgorithmFieldMask);
 818
 819                 _sfSkinningAlgorithm.setValue(NULL);
 820
 821                 return true;
 822             }
 823
 824             SWARNING << "Parent (["        << this
 825                      << "] id ["           << this->getId()
 826                      << "] type ["         << this->getType().getCName()
 827                      << "] childFieldId [" << childFieldId
 828                      << "]) - Child (["    << pChild
 829                      << "] id ["           << pChild->getId()
 830                      << "] type ["         << pChild->getType().getCName()
 831                      << "]): link inconsistent!"
 832                      << std::endl;
 833
 834             return false;
 835         }
 836
 837         return false;
 838     }
 839
 840
 841     return Inherited::unlinkChild(pChild, childFieldId);
 842 }
 843
 844 void SkinnedGeometryBase::onCreate(const SkinnedGeometry *source)
 845 {
 846     Inherited::onCreate(source);
 847
 848     if(source != NULL)
 849     {
 850         SkinnedGeometry *pThis = static_cast<SkinnedGeometry *>(this);
 851
 852         pThis->setSkeleton(source->getSkeleton());
 853
 854         pThis->setSkinningAlgorithm(source->getSkinningAlgorithm());
 855     }
 856 }
 857
 858 GetFieldHandlePtr SkinnedGeometryBase::getHandleSkeleton        (void) const
 859 {
 860     SFUnrecSkeletonPtr::GetHandlePtr returnValue(
 861         new  SFUnrecSkeletonPtr::GetHandle(
 862              &_sfSkeleton,
 863              this->getType().getFieldDesc(SkeletonFieldId),
 864              const_cast<SkinnedGeometryBase *>(this)));
 865
 866     return returnValue;
 867 }
 868
 869 EditFieldHandlePtr SkinnedGeometryBase::editHandleSkeleton       (void)
 870 {
 871     SFUnrecSkeletonPtr::EditHandlePtr returnValue(
 872         new  SFUnrecSkeletonPtr::EditHandle(
 873              &_sfSkeleton,
 874              this->getType().getFieldDesc(SkeletonFieldId),
 875              this));
 876
 877     returnValue->setSetMethod(
 878         boost::bind(&SkinnedGeometry::setSkeleton,
 879                     static_cast<SkinnedGeometry *>(this), _1));
 880
 881     editSField(SkeletonFieldMask);
 882
 883     return returnValue;
 884 }
 885
 886 GetFieldHandlePtr SkinnedGeometryBase::getHandleBindShapeMatrix (void) const
 887 {
 888     SFMatrix::GetHandlePtr returnValue(
 889         new  SFMatrix::GetHandle(
 890              &_sfBindShapeMatrix,
 891              this->getType().getFieldDesc(BindShapeMatrixFieldId),
 892              const_cast<SkinnedGeometryBase *>(this)));
 893
 894     return returnValue;
 895 }
 896
 897 EditFieldHandlePtr SkinnedGeometryBase::editHandleBindShapeMatrix(void)
 898 {
 899     SFMatrix::EditHandlePtr returnValue(
 900         new  SFMatrix::EditHandle(
 901              &_sfBindShapeMatrix,
 902              this->getType().getFieldDesc(BindShapeMatrixFieldId),
 903              this));
 904
 905
 906     editSField(BindShapeMatrixFieldMask);
 907
 908     return returnValue;
 909 }
 910
 911 GetFieldHandlePtr SkinnedGeometryBase::getHandleJointIds        (void) const
 912 {
 913     MFInt16::GetHandlePtr returnValue(
 914         new  MFInt16::GetHandle(
 915              &_mfJointIds,
 916              this->getType().getFieldDesc(JointIdsFieldId),
 917              const_cast<SkinnedGeometryBase *>(this)));
 918
 919     return returnValue;
 920 }
 921
 922 EditFieldHandlePtr SkinnedGeometryBase::editHandleJointIds       (void)
 923 {
 924     MFInt16::EditHandlePtr returnValue(
 925         new  MFInt16::EditHandle(
 926              &_mfJointIds,
 927              this->getType().getFieldDesc(JointIdsFieldId),
 928              this));
 929
 930
 931     editMField(JointIdsFieldMask, _mfJointIds);
 932
 933     return returnValue;
 934 }
 935
 936 GetFieldHandlePtr SkinnedGeometryBase::getHandleJointIndexProperty (void) const
 937 {
 938     SFUInt16::GetHandlePtr returnValue(
 939         new  SFUInt16::GetHandle(
 940              &_sfJointIndexProperty,
 941              this->getType().getFieldDesc(JointIndexPropertyFieldId),
 942              const_cast<SkinnedGeometryBase *>(this)));
 943
 944     return returnValue;
 945 }
 946
 947 EditFieldHandlePtr SkinnedGeometryBase::editHandleJointIndexProperty(void)
 948 {
 949     SFUInt16::EditHandlePtr returnValue(
 950         new  SFUInt16::EditHandle(
 951              &_sfJointIndexProperty,
 952              this->getType().getFieldDesc(JointIndexPropertyFieldId),
 953              this));
 954
 955
 956     editSField(JointIndexPropertyFieldMask);
 957
 958     return returnValue;
 959 }
 960
 961 GetFieldHandlePtr SkinnedGeometryBase::getHandleJointWeightProperty (void) const
 962 {
 963     SFUInt16::GetHandlePtr returnValue(
 964         new  SFUInt16::GetHandle(
 965              &_sfJointWeightProperty,
 966              this->getType().getFieldDesc(JointWeightPropertyFieldId),
 967              const_cast<SkinnedGeometryBase *>(this)));
 968
 969     return returnValue;
 970 }
 971
 972 EditFieldHandlePtr SkinnedGeometryBase::editHandleJointWeightProperty(void)
 973 {
 974     SFUInt16::EditHandlePtr returnValue(
 975         new  SFUInt16::EditHandle(
 976              &_sfJointWeightProperty,
 977              this->getType().getFieldDesc(JointWeightPropertyFieldId),
 978              this));
 979
 980
 981     editSField(JointWeightPropertyFieldMask);
 982
 983     return returnValue;
 984 }
 985
 986 GetFieldHandlePtr SkinnedGeometryBase::getHandleRenderMode      (void) const
 987 {
 988     SFUInt32::GetHandlePtr returnValue(
 989         new  SFUInt32::GetHandle(
 990              &_sfRenderMode,
 991              this->getType().getFieldDesc(RenderModeFieldId),
 992              const_cast<SkinnedGeometryBase *>(this)));
 993
 994     return returnValue;
 995 }
 996
 997 EditFieldHandlePtr SkinnedGeometryBase::editHandleRenderMode     (void)
 998 {
 999     SFUInt32::EditHandlePtr returnValue(
1000         new  SFUInt32::EditHandle(
1001              &_sfRenderMode,
1002              this->getType().getFieldDesc(RenderModeFieldId),
1003              this));
1004
1005
1006     editSField(RenderModeFieldMask);
1007
1008     return returnValue;
1009 }
1010
1011 GetFieldHandlePtr SkinnedGeometryBase::getHandleSkinningAlgorithm (void) const
1012 {
1013     SFUnrecChildSkinningAlgorithmPtr::GetHandlePtr returnValue(
1014         new  SFUnrecChildSkinningAlgorithmPtr::GetHandle(
1015              &_sfSkinningAlgorithm,
1016              this->getType().getFieldDesc(SkinningAlgorithmFieldId),
1017              const_cast<SkinnedGeometryBase *>(this)));
1018
1019     return returnValue;
1020 }
1021
1022 EditFieldHandlePtr SkinnedGeometryBase::editHandleSkinningAlgorithm(void)
1023 {
1024     SFUnrecChildSkinningAlgorithmPtr::EditHandlePtr returnValue(
1025         new  SFUnrecChildSkinningAlgorithmPtr::EditHandle(
1026              &_sfSkinningAlgorithm,
1027              this->getType().getFieldDesc(SkinningAlgorithmFieldId),
1028              this));
1029
1030     returnValue->setSetMethod(
1031         boost::bind(&SkinnedGeometry::setSkinningAlgorithm,
1032                     static_cast<SkinnedGeometry *>(this), _1));
1033
1034     editSField(SkinningAlgorithmFieldMask);
1035
1036     return returnValue;
1037 }
1038
1039
1040 #ifdef OSG_MT_CPTR_ASPECT
1041 void SkinnedGeometryBase::execSyncV(      FieldContainer    &oFrom,
1042                                         ConstFieldMaskArg  whichField,
1043                                         AspectOffsetStore &oOffsets,
1044                                         ConstFieldMaskArg  syncMode,
1045                                   const UInt32             uiSyncInfo)
1046 {
1047     SkinnedGeometry *pThis = static_cast<SkinnedGeometry *>(this);
1048
1049     pThis->execSync(static_cast<SkinnedGeometry *>(&oFrom),
1050                     whichField,
1051                     oOffsets,
1052                     syncMode,
1053                     uiSyncInfo);
1054 }
1055 #endif
1056
1057
1058 #ifdef OSG_MT_CPTR_ASPECT
1059 FieldContainer *SkinnedGeometryBase::createAspectCopy(
1060     const FieldContainer *pRefAspect) const
1061 {
1062     SkinnedGeometry *returnValue;
1063
1064     newAspectCopy(returnValue,
1065                   dynamic_cast<const SkinnedGeometry *>(pRefAspect),
1066                   dynamic_cast<const SkinnedGeometry *>(this));
1067
1068     return returnValue;
1069 }
1070 #endif
1071
1072 void SkinnedGeometryBase::resolveLinks(void)
1073 {
1074     Inherited::resolveLinks();
1075
1076     static_cast<SkinnedGeometry *>(this)->setSkeleton(NULL);
1077
1078     static_cast<SkinnedGeometry *>(this)->setSkinningAlgorithm(NULL);
1079
1080 #ifdef OSG_MT_CPTR_ASPECT
1081     AspectOffsetStore oOffsets;
1082
1083     _pAspectStore->fillOffsetArray(oOffsets, this);
1084 #endif
1085
1086 #ifdef OSG_MT_CPTR_ASPECT
1087     _mfJointIds.terminateShare(Thread::getCurrentAspect(),
1088                                       oOffsets);
1089 #endif
1090 }
1091
1092
1093 OSG_END_NAMESPACE