Source/Base/FieldContainer/Node/OSGNode.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *           Copyright (C) 2003 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 //---------------------------------------------------------------------------
  40 //  Includes
  41 //---------------------------------------------------------------------------
  42
  43 #include <cstdlib>
  44 #include <cstdio>
  45
  46 #include "OSGConfig.h"
  47
  48 #include "OSGLog.h"
  49 #include "OSGNode.h"
  50 #include "OSGNodeCore.h"
  51
  52 #include "OSGTypeBasePredicates.h"
  53 #include "OSGReflexiveContainerTypePredicates.h"
  54
  55 #include "boost/bind.hpp"
  56
  57 #ifdef WIN32 // turn of 'this' : used in base member initializer lits warning
  58 #pragma warning(disable:4355)
  59 #endif
  60
  61 OSG_BEGIN_NAMESPACE
  62
  63 /***************************************************************************\
  64  *                            Description                                  *
  65 \***************************************************************************/
  66
  67 /*! \class OSG::Node
  68     Node describe the hierarchical tree structure of the scenegraph. Every Node
  69     can have at most one parent and one core (something derived from
  70     NodeCore), but an arbitrary number of children.
  71  */
  72
  73 /***************************************************************************\
  74  *                         Field Description                               *
  75 \***************************************************************************/
  76
  77 /*! \var BoxVolume   Node::_sfVolume
  78     The bounding volume of this node. It contains all the nodes children and
  79     is described in this nodes coordinate system.
  80  */
  81
  82 /*! \var UInt32          Node::_sfTravMask
  83     The traversal mask is used to selectively exclude subtrees of the scenegraph
  84     from traversal operations (e.g. GraphOps, RenderAction). Only if
  85     the bitwise AND of the operation's and node's mask is non-zero the node
  86     (and it's subtree) considered.
  87  */
  88
  89 /*! \var NodeParentPtr   Node::_sfParent
  90     The node's single parent.
  91  */
  92
  93 /*! \var NodePtr         Node::_mfChildren
  94     The node's children.
  95  */
  96
  97 /*! \var NodeCorePtr     Node::_sfCore
  98  */
  99
 100 void Node::classDescInserter(TypeObject &oType)
 101 {
 102     FieldDescriptionBase *pDesc = NULL;
 103
 104     pDesc = new SFBoxVolume::Description(
 105         SFBoxVolume::getClassType(),
 106         "volume",
 107         "Bounding volume for the node.",
 108         OSG_RC_FIELD_DESC(Node::Volume),
 109         false,
 110         Field::SFDefaultFlags,
 111         static_cast<FieldEditMethodSig>(&Node::editHandleVolume),
 112         static_cast<FieldGetMethodSig >(&Node::getHandleVolume ));
 113
 114     oType.addInitialDesc(pDesc);
 115
 116
 117     pDesc = new SFUInt32::Description(
 118         SFUInt32::getClassType(),
 119         "travMask",
 120         "Traversal mask for the node.",
 121         OSG_RC_FIELD_DESC(Node::TravMask),
 122         false,
 123         Field::SFDefaultFlags,
 124         static_cast<FieldEditMethodSig>(&Node::editHandleTravMask),
 125         static_cast<FieldGetMethodSig >(&Node::getHandleTravMask ));
 126
 127     oType.addInitialDesc(pDesc);
 128
 129
 130     pDesc = new SFParentNodePtr::Description(
 131         SFParentNodePtr::getClassType(),
 132         "parent",
 133         "This node's parent.",
 134         OSG_RC_FIELD_DESC(Node::Parent),
 135         true,
 136         Field::SFDefaultFlags,
 137         static_cast<FieldEditMethodSig>(&Node::invalidEditField),
 138         static_cast<FieldGetMethodSig >(&Node::getHandleParent ));
 139
 140     oType.addInitialDesc(pDesc);
 141
 142
 143     pDesc = new SFUnrecChildNodeCorePtr::Description(
 144         SFUnrecChildNodeCorePtr::getClassType(),
 145         "core",
 146         "The core to use for this node.",
 147         OSG_RC_FIELD_DESC(Node::Core),
 148         false,
 149         (Field::SFDefaultFlags | Field::FStdAccess),
 150         static_cast<FieldEditMethodSig>(&Node::editHandleCore),
 151         static_cast<FieldGetMethodSig >(&Node::getHandleCore ));
 152
 153     oType.addInitialDesc(pDesc);
 154
 155
 156     pDesc = new MFUnrecChildNodePtr::Description(
 157         MFUnrecChildNodePtr::getClassType(),
 158         "children",
 159         "A list of our children in the scene graph.",
 160         OSG_RC_FIELD_DESC(Node::Children),
 161         false,
 162         (Field::MFDefaultFlags | Field::FNullCheckAccess),
 163         static_cast<FieldEditMethodSig>(&Node::editHandleChildren),
 164         static_cast<FieldGetMethodSig >(&Node::getHandleChildren));
 165
 166     oType.addInitialDesc(pDesc);
 167 }
 168
 169 Node::TypeObject Node::_type(
 170     Node     ::getClassname(),
 171     Inherited::getClassname(),
 172     "Node",
 173     0,
 174     reinterpret_cast<PrototypeCreateF>(&Node::createEmptyLocal),
 175     NULL,
 176     NULL,
 177     reinterpret_cast<InitalInsertDescFunc>(
 178         reinterpret_cast<void *>(&Node::classDescInserter)),
 179     false,
 180     0);
 181
 182
 183 OSG_FIELD_CONTAINER_DEF(Node)
 184
 185
 186
 187 /*-------------------------------------------------------------------------*/
 188 /*                             Children                                    */
 189
 190 void Node::addChild(Node * const childP)
 191 {
 192     if(childP != NULL)
 193     {
 194         // do the ref early, to prevent destroys on getParent(a)->addChild(a)
 195
 196         editMField(ChildrenFieldMask, _mfChildren);
 197
 198         _mfChildren.push_back(childP);
 199     }
 200 }
 201
 202 void Node::addChild(NodeTransitPtr childP)
 203 {
 204     if(childP != NULL)
 205     {
 206         editMField(ChildrenFieldMask, _mfChildren);
 207
 208         NodeUnrecPtr tmpChild = childP;
 209
 210         _mfChildren.push_back(tmpChild);
 211     }
 212 }
 213
 214 /*! Insert child node into child list.
 215 * Upon completion, getChild(childIndex) will return the new child.
 216 * (ie. child is at childIndex pos in list)
 217 * All other children after childIndex are moved back in list.
 218 * If childP is Null, does nothing.
 219 *
 220 * \warning childP is not ranged checked.  Out of range values will have undefined behavior.
 221 * \param childIndex  The location in the list to put the new child.
 222 * \param childP  Pointer to the child to insert.
 223 */
 224 void Node::insertChild(UInt32 childIndex, Node * const childP)
 225 {
 226     OSG_ASSERT((childIndex <= getNChildren()) && "Child index out of range");
 227
 228     if(childP != NULL)
 229     {
 230
 231         editMField(ChildrenFieldMask, _mfChildren);
 232
 233         MFUnrecChildNodePtr::iterator childIt = _mfChildren.begin_nc();
 234
 235         childIt += childIndex;
 236
 237         _mfChildren.insert(childIt, childP);
 238     }
 239 }
 240
 241 void Node::replaceChild(UInt32 childIndex, Node * const childP)
 242 {
 243     const Node *pThis = this;
 244
 245     if(childP     != NULL                           &&
 246        childIndex <  pThis->_mfChildren.size()      &&
 247        childP     != pThis->_mfChildren[childIndex]  )
 248     {
 249         editMField(ChildrenFieldMask, _mfChildren);
 250
 251         _mfChildren.replace(childIndex, childP);
 252     }
 253 }
 254
 255 //! return true on success, false on child not found
 256
 257 bool Node::replaceChildBy(Node * const childP,
 258                           Node * const newChildP)
 259 {
 260     if(newChildP != NULL && childP != newChildP)
 261     {
 262         Int32 childIdx = findChild(childP);
 263
 264         if(childIdx != -1)
 265         {
 266             // do the ref early, to prevent destroys on
 267             editMField(ChildrenFieldMask, _mfChildren);
 268
 269             _mfChildren.replace(childIdx, newChildP);
 270
 271             return true;
 272         }
 273     }
 274
 275     return false;
 276 }
 277
 278 Int32 Node::findChild(Node * const childP) const
 279 {
 280     UInt32 index;
 281
 282     for(index = 0; index < _mfChildren.size(); index++)
 283     {
 284         if( _mfChildren[index] == childP)
 285             break;
 286     }
 287
 288     if(index < _mfChildren.size())
 289     {
 290         return index;
 291     }
 292     else
 293     {
 294         return -1;
 295     }
 296 }
 297
 298 void Node::subChild(Node * const childP)
 299 {
 300     Int32 childIdx = findChild(childP);
 301
 302     if(childIdx != -1)
 303     {
 304         editMField(ChildrenFieldMask, _mfChildren);
 305
 306 //        MFUnrecChildNodePtr::iterator childIt = _mfChildren.begin_nc();
 307
 308 //        childIt += childIdx;
 309
 310         _mfChildren.erase(childIdx);
 311     }
 312     else
 313     {
 314         SWARNING << "Node(" << this << ")::subChild: " << childP
 315                  << " is not one of my children!" << std::endl;
 316     }
 317 }
 318
 319 void Node::subChild(UInt32 childIndex)
 320 {
 321     if(childIndex < _mfChildren.size())
 322     {
 323         editMField(ChildrenFieldMask, _mfChildren);
 324
 325 //        MFUnrecChildNodePtr::iterator childIt = _mfChildren.begin_nc();
 326
 327 //        childIt += childIndex;
 328
 329         _mfChildren.erase(childIndex);
 330     }
 331 }
 332
 333 void Node::clearChildren(void)
 334 {
 335     editMField(ChildrenFieldMask, _mfChildren);
 336
 337     _mfChildren.clear();
 338 }
 339
 340 SizeT Node::getBinSize(ConstFieldMaskArg whichField)
 341 {
 342     SizeT returnValue = Inherited::getBinSize(whichField);
 343
 344     if(FieldBits::NoField != (VolumeFieldMask & whichField))
 345     {
 346         returnValue += _sfVolume.getBinSize();
 347     }
 348
 349     if(FieldBits::NoField != (TravMaskFieldMask & whichField))
 350     {
 351         returnValue += _sfTravMask.getBinSize();
 352     }
 353
 354     if(FieldBits::NoField != (ParentFieldMask & whichField))
 355     {
 356         returnValue += _sfParent.getBinSize();
 357     }
 358
 359     if(FieldBits::NoField != (ChildrenFieldMask & whichField))
 360     {
 361         returnValue += _mfChildren.getBinSize();
 362     }
 363
 364     if(FieldBits::NoField != (CoreFieldMask & whichField))
 365     {
 366         returnValue += _sfCore.getBinSize();
 367     }
 368
 369     return returnValue;
 370 }
 371
 372 void Node::copyToBin(BinaryDataHandler &pMem,
 373                      ConstFieldMaskArg  whichField)
 374 {
 375     Inherited::copyToBin(pMem, whichField);
 376
 377     if(FieldBits::NoField != (VolumeFieldMask & whichField))
 378     {
 379         _sfVolume.copyToBin(pMem);
 380     }
 381
 382     if(FieldBits::NoField != (TravMaskFieldMask & whichField))
 383     {
 384         _sfTravMask.copyToBin(pMem);
 385     }
 386
 387     if(FieldBits::NoField != (ParentFieldMask & whichField))
 388     {
 389         _sfParent.copyToBin(pMem);
 390     }
 391
 392     if(FieldBits::NoField != (ChildrenFieldMask & whichField))
 393     {
 394         _mfChildren.copyToBin(pMem);
 395     }
 396
 397     if(FieldBits::NoField != (CoreFieldMask & whichField))
 398     {
 399         _sfCore.copyToBin(pMem);
 400     }
 401 }
 402
 403 void Node::copyFromBin(BinaryDataHandler &pMem,
 404                        ConstFieldMaskArg  whichField)
 405 {
 406     Inherited::copyFromBin(pMem, whichField);
 407
 408     if(FieldBits::NoField != (VolumeFieldMask & whichField))
 409     {
 410         _sfVolume.copyFromBin(pMem);
 411     }
 412
 413     if(FieldBits::NoField != (TravMaskFieldMask & whichField))
 414     {
 415         _sfTravMask.copyFromBin(pMem);
 416     }
 417
 418     if(FieldBits::NoField != (ParentFieldMask & whichField))
 419     {
 420         _sfParent.copyFromBin(pMem);
 421     }
 422
 423     if(FieldBits::NoField != (ChildrenFieldMask & whichField))
 424     {
 425         _mfChildren.copyFromBin(pMem);
 426     }
 427
 428     if(FieldBits::NoField != (CoreFieldMask & whichField))
 429     {
 430         _sfCore.copyFromBin(pMem);
 431     }
 432 }
 433
 434 /*-------------------------------------------------------------------------*/
 435 /*                           Get Transformation                            */
 436
 437 Matrix Node::getToWorld(void)
 438 {
 439     Matrix tmp;
 440
 441     getToWorld(tmp);
 442
 443     return tmp;
 444 }
 445
 446 void Node::getToWorld(Matrix &result)
 447 {
 448     if(getParent() != NULL)
 449     {
 450         getParent()->getToWorld(result);
 451     }
 452     else
 453     {
 454         result.setIdentity();
 455     }
 456
 457     if(getCore() != NULL)
 458         getCore()->accumulateMatrix(result);
 459 }
 460
 461 /*-------------------------------------------------------------------------*/
 462 /*                           Volume                                        */
 463
 464 void Node::getWorldVolume(BoxVolume &result)
 465 {
 466     Matrix m;
 467
 468     if(getParent() != NULL)
 469     {
 470         getParent()->getToWorld(m);
 471     }
 472     else
 473     {
 474         m.setIdentity();
 475     }
 476
 477     updateVolume();
 478
 479     result = getVolume();
 480     result.transform(m);
 481 }
 482
 483 void Node::updateVolume(void)
 484 {
 485     // still valid or static, nothing to do
 486     if(_sfVolume.getValue().isValid () == true   ||
 487        _sfVolume.getValue().isStatic() == true   ||
 488        getTravMask()                   == 0x0000   )
 489     {
 490         return;
 491     }
 492
 493     // be careful to not change the real volume. If two threads
 494     // are updating the same aspect this will lead to chaos
 495
 496     BoxVolume vol = _sfVolume.getValue();
 497
 498     MFUnrecChildNodePtr::const_iterator cIt  =
 499         this->getMFChildren()->begin();
 500     MFUnrecChildNodePtr::const_iterator cEnd =
 501         this->getMFChildren()->end();
 502
 503     vol.setEmpty();
 504
 505     for(; cIt != cEnd; ++cIt)
 506     {
 507         if(*cIt != NULL && (*cIt)->getTravMask())
 508         {
 509             (*cIt)->updateVolume();
 510             vol.extendBy((*cIt)->getVolume());
 511         }
 512     }
 513
 514     // test for null core. Shouldn't happen, but just in case...
 515     if(getCore() != NULL)
 516     {
 517         getCore()->adjustVolume(vol);
 518     }
 519
 520     // don't propagate the static flag from children
 521     vol.setStatic(false);
 522
 523     editSField(VolumeFieldMask);
 524
 525     _sfVolume.setValue(vol);
 526 }
 527
 528 /*-------------------------------------------------------------------------*/
 529 /*                            Constructors                                 */
 530
 531 Node::Node(void) :
 532      Inherited (                            ),
 533     _sfVolume  (                            ),
 534     _sfParent  (NULL                        ),
 535     _mfChildren(this,
 536                 ChildrenFieldId,
 537                 Node::ParentFieldId         ),
 538     _sfCore    (NULL,
 539                 this,
 540                 CoreFieldId,
 541                 NodeCore::ParentsFieldId    ),
 542     _sfTravMask(TypeTraits<UInt32>::getMax())
 543 #ifdef OSG_1_COMPAT
 544    ,_occlusionMask(0)
 545 #endif
 546 {
 547 }
 548
 549 Node::Node(const Node &source) :
 550      Inherited    (source                   ),
 551     _sfVolume     (                         ),
 552
 553     _sfParent     (NULL                     ),
 554     _mfChildren   (this,
 555                    ChildrenFieldId,
 556                    Node::ParentFieldId      ),
 557
 558     _sfCore       (NULL,
 559                    this,
 560                    CoreFieldId,
 561                    NodeCore::ParentsFieldId ),
 562
 563     _sfTravMask   (source._sfTravMask       )
 564 #ifdef OSG_1_COMPAT
 565    ,_occlusionMask(source._occlusionMask)
 566 #endif
 567 {
 568 }
 569 /*-------------------------------------------------------------------------*/
 570 /*                             Destructor                                  */
 571
 572 Node::~Node(void)
 573 {
 574 }
 575
 576 bool Node::linkParent  (FieldContainer * const pParent,
 577                         UInt16           const childFieldId,
 578                         UInt16           const parentFieldId)
 579 {
 580     if(parentFieldId == ParentFieldId)
 581     {
 582         Node *pTypedParent = dynamic_cast<Node *>(pParent);
 583
 584         if(pTypedParent != NULL)
 585         {
 586             Node *pOldParent      = _sfParent.getValue         ();
 587
 588             if(pOldParent != NULL)
 589             {
 590                 pOldParent->unlinkChild(this, ChildrenFieldId);
 591             }
 592
 593             editSField(ParentFieldMask);
 594
 595             _sfParent.setValue(pTypedParent, childFieldId);
 596
 597             return true;
 598         }
 599
 600         return false;
 601     }
 602
 603     return Inherited::linkParent(pParent, childFieldId, parentFieldId);
 604 }
 605
 606 bool Node::unlinkParent(FieldContainer * const pParent,
 607                         UInt16           const parentFieldId)
 608 {
 609     if(parentFieldId == ParentFieldId)
 610     {
 611         Node *pTypedParent = dynamic_cast<Node *>(pParent);
 612
 613         if(pTypedParent != NULL)
 614         {
 615             if(_sfParent.getValue() == pTypedParent)
 616             {
 617                 editSField(ParentFieldMask);
 618
 619                 _sfParent.setValue(NULL, 0xFFFF);
 620
 621                 return true;
 622             }
 623
 624             SWARNING << "Child (["          << this
 625                      << "] id ["            << this->getId()
 626                      << "] type ["          << this->getType().getCName()
 627                      << "] parentFieldId [" << parentFieldId
 628                      << "]) - Parent (["    << pParent
 629                      << "] id ["            << pParent->getId()
 630                      << "] type ["          << pParent->getType().getCName()
 631                      << "]): link inconsistent!"
 632                      << std::endl;
 633         }
 634
 635         return false;
 636     }
 637
 638     return Inherited::unlinkParent(pParent, parentFieldId);
 639 }
 640
 641 bool Node::unlinkChild (FieldContainer * const pChild,
 642                         UInt16           const childFieldId )
 643 {
 644     if(childFieldId == ChildrenFieldId)
 645     {
 646         Node *pTypedChild = dynamic_cast<Node *>(pChild);
 647
 648         if(pTypedChild != NULL)
 649         {
 650             Int32 iChildIdx = _mfChildren.findIndex(pTypedChild);
 651
 652             if(iChildIdx != -1)
 653             {
 654                 editMField(ParentFieldMask, _mfChildren);
 655
 656                 _mfChildren.erase(iChildIdx);
 657
 658                 return true;
 659             }
 660
 661             SWARNING << "Parent (["        << this
 662                      << "] id ["           << this->getId()
 663                      << "] type ["         << this->getType().getCName()
 664                      << "] childFieldId [" << childFieldId
 665                      << "]) - Child (["    << pChild
 666                      << "] id ["           << pChild->getId()
 667                      << "] type ["         << pChild->getType().getCName()
 668                      << "]): link inconsistent!"
 669                      << std::endl;
 670
 671             return false;
 672         }
 673
 674         return false;
 675     }
 676
 677     if(childFieldId == CoreFieldId)
 678     {
 679         NodeCore *pTypedChild = dynamic_cast<NodeCore *>(pChild);
 680
 681         if(pTypedChild != NULL)
 682         {
 683             if(_sfCore.getValue() == pTypedChild)
 684             {
 685                 editSField(CoreFieldMask);
 686
 687                 _sfCore.setValue(NULL);
 688
 689                 return true;
 690             }
 691
 692             SWARNING << "Parent (["        << this
 693                      << "] id ["           << this->getId()
 694                      << "] type ["         << this->getType().getCName()
 695                      << "] childFieldId [" << childFieldId
 696                      << "]) - Child (["    << pChild
 697                      << "] id ["           << pChild->getId()
 698                      << "] type ["         << pChild->getType().getCName()
 699                      << "]): link inconsistent!"
 700                      << std::endl;
 701
 702             return false;
 703         }
 704
 705         return false;
 706     }
 707
 708     return Inherited::unlinkChild(pChild, childFieldId);
 709 }
 710
 711 void Node::invalidateVolume(void)
 712 {
 713     BoxVolume &vol = _sfVolume.getValue();
 714
 715     if(vol.isInvalidated() == false && vol.isStatic() == false)
 716     {
 717         editSField(VolumeFieldMask);
 718
 719         vol.invalidate();
 720
 721         if(getParent() != NULL)
 722         {
 723             getParent()->invalidateVolume();
 724         }
 725
 726     }
 727 }
 728
 729 void Node::changed(ConstFieldMaskArg whichField,
 730                    UInt32            origin,
 731                    BitVector         details    )
 732 {
 733     Inherited::changed(whichField, origin, details);
 734
 735     if(whichField & (CoreFieldMask | ChildrenFieldMask))
 736     {
 737         invalidateVolume();
 738     }
 739
 740     if(whichField & TravMaskFieldMask)
 741     {
 742         if(getParent() != NULL)
 743         {
 744             getParent()->invalidateVolume();
 745         }
 746         else
 747         {
 748             invalidateVolume();
 749         }
 750     }
 751 }
 752
 753 void Node::dump(      UInt32    uiIndent,
 754                 const BitVector bvFlags ) const
 755 {
 756     UInt32 i;
 757
 758     indentLog(uiIndent, PLOG);
 759
 760     PLOG << "Node"
 761          << "("
 762          << this->getId()
 763          << ") : "
 764          << _mfChildren.size()
 765          << " children | "
 766 //         << _attachmentMap.getValue().size()
 767          << " attachments | "
 768          << "Parent : ";
 769
 770     if(_sfParent.getValue() != NULL)
 771     {
 772         PLOG << _sfParent.getValue()->getId() << " | ";
 773     }
 774     else
 775     {
 776         PLOG << "NULL | ";
 777     }
 778
 779     PLOG << std::hex << this << std::dec << std::endl;
 780
 781     indentLog(uiIndent, PLOG);
 782
 783     PLOG << "[" << std::endl;
 784
 785     indentLog(uiIndent + 4, PLOG);
 786
 787     PLOG << "Box : " << _sfVolume.getValue() << std::endl;
 788
 789     if(_sfCore.getValue() != NULL)
 790     {
 791         _sfCore.getValue()->dump(uiIndent + 4, bvFlags);
 792     }
 793     else
 794     {
 795         indentLog(uiIndent + 4, PLOG);
 796         PLOG << "Core : " << "NULL" << std::endl;
 797     }
 798
 799     Inherited::dump(uiIndent + 4, bvFlags);
 800
 801     indentLog(uiIndent, PLOG);
 802     PLOG << "]" << std::endl;
 803
 804     indentLog(uiIndent, PLOG);
 805
 806     PLOG << "{" << std::endl;
 807
 808     for(i = 0; i < _mfChildren.size(); i++)
 809     {
 810         _mfChildren[i]->dump(uiIndent + 4, bvFlags);
 811         PLOG << std::endl;
 812     }
 813
 814
 815     indentLog(uiIndent, PLOG);
 816
 817     PLOG << "}" << std::endl;
 818 }
 819
 820 /*-------------------------------------------------------------------------*/
 821 /*                             Assignment                                  */
 822
 823 SFBoxVolume *Node::editSFVolume(void)
 824 {
 825     editSField(VolumeFieldMask);
 826
 827     return &_sfVolume;
 828 }
 829
 830 const SFBoxVolume *Node::getSFVolume(void) const
 831 {
 832     return &_sfVolume;
 833 }
 834
 835 SFUInt32 *Node::editSFTravMask(void)
 836 {
 837     editSField(TravMaskFieldMask);
 838
 839     return &_sfTravMask;
 840 }
 841
 842 const SFUInt32 *Node::getSFTravMask(void) const
 843 {
 844     return &_sfTravMask;
 845 }
 846
 847 const SFParentNodePtr *Node::getSFParent(void) const
 848 {
 849     return &_sfParent;
 850 }
 851
 852 const SFUnrecChildNodeCorePtr *Node::getSFCore(void) const
 853 {
 854     return &_sfCore;
 855 }
 856
 857 const MFUnrecChildNodePtr *Node::getMFChildren(void) const
 858 {
 859     return &_mfChildren;
 860 }
 861
 862 #ifdef OSG_MT_CPTR_ASPECT
 863 FieldContainer *Node::createAspectCopy(const FieldContainer *pRefAspect) const
 864 {
 865     Node *returnValue = NULL;
 866
 867     newAspectCopy(returnValue,
 868                   dynamic_cast<const Node *>(pRefAspect),
 869                   dynamic_cast<const Node *>(this));
 870
 871     return returnValue;
 872 }
 873 #endif
 874
 875 #ifdef OSG_MT_CPTR_ASPECT
 876 void Node::execSyncV(       FieldContainer    &oFrom,
 877                             ConstFieldMaskArg  whichField,
 878                             AspectOffsetStore &oOffsets,
 879                             ConstFieldMaskArg  syncMode  ,
 880                       const UInt32             uiSyncInfo)
 881 {
 882     this->execSync(static_cast<Node *>(&oFrom),
 883                    whichField,
 884                    oOffsets,
 885                    syncMode,
 886                    uiSyncInfo);
 887 }
 888 #endif
 889
 890 EditFieldHandlePtr Node::editHandleVolume(void)
 891 {
 892     SFBoxVolume::EditHandlePtr returnValue(
 893         new  SFBoxVolume::EditHandle(
 894              &_sfVolume,
 895              this->getType().getFieldDesc(VolumeFieldId),
 896              this));
 897
 898     editSField(VolumeFieldMask);
 899
 900     return returnValue;
 901 }
 902
 903 GetFieldHandlePtr  Node::getHandleVolume(void) const
 904 {
 905     SFBoxVolume::GetHandlePtr returnValue(
 906         new  SFBoxVolume::GetHandle(
 907              &_sfVolume,
 908              this->getType().getFieldDesc(VolumeFieldId),
 909              const_cast<Node *>(this)));
 910
 911     return returnValue;
 912 }
 913
 914 EditFieldHandlePtr Node::editHandleTravMask(void)
 915 {
 916     SFUInt32::EditHandlePtr returnValue(
 917         new  SFUInt32::EditHandle(
 918              &_sfTravMask,
 919              this->getType().getFieldDesc(TravMaskFieldId),
 920              this));
 921
 922     editSField(TravMaskFieldMask);
 923
 924     return returnValue;
 925 }
 926
 927 GetFieldHandlePtr Node::getHandleTravMask(void) const
 928 {
 929     SFUInt32::GetHandlePtr returnValue(
 930         new  SFUInt32::GetHandle(
 931              &_sfTravMask,
 932              this->getType().getFieldDesc(TravMaskFieldId),
 933              const_cast<Node *>(this)));
 934
 935     return returnValue;
 936 }
 937
 938 GetFieldHandlePtr Node::getHandleParent(void) const
 939 {
 940     SFParentNodePtr::GetHandlePtr returnValue(
 941         new SFParentNodePtr::GetHandle(
 942              &_sfParent,
 943              this->getType().getFieldDesc(ParentFieldId),
 944              const_cast<Node *>(this)));
 945
 946     return returnValue;
 947 }
 948
 949 EditFieldHandlePtr Node::editHandleCore(void)
 950 {
 951     SFUnrecChildNodeCorePtr::EditHandlePtr returnValue(
 952         new SFUnrecChildNodeCorePtr::EditHandle(
 953              &_sfCore,
 954              this->getType().getFieldDesc(CoreFieldId),
 955              this));
 956
 957     typedef void (Node::*SetCoreF)(NodeCore * const);
 958
 959     SetCoreF fFunc = &Node::setCore;
 960
 961     returnValue->setSetMethod(boost::bind(fFunc, this, _1));
 962
 963     editSField(CoreFieldMask);
 964
 965     return returnValue;
 966 }
 967
 968 GetFieldHandlePtr Node::getHandleCore(void) const
 969 {
 970     SFUnrecChildNodeCorePtr::GetHandlePtr returnValue(
 971         new SFUnrecChildNodeCorePtr::GetHandle(
 972              &_sfCore,
 973              this->getType().getFieldDesc(CoreFieldId),
 974              const_cast<Node *>(this)));
 975
 976     return returnValue;
 977 }
 978
 979 EditFieldHandlePtr Node::editHandleChildren(void)
 980 {
 981     MFUnrecChildNodePtr::EditHandlePtr returnValue(
 982         new  MFUnrecChildNodePtr::EditHandle(
 983              &_mfChildren,
 984              this->getType().getFieldDesc(ChildrenFieldId),
 985              this));
 986
 987     typedef void (Node::*AddChildF)(Node * const);
 988
 989     AddChildF fFunc = &Node::addChild;
 990
 991     returnValue->setAddMethod(boost::bind(fFunc, this, _1));
 992
 993     editMField(ChildrenFieldMask, _mfChildren);
 994
 995     return returnValue;
 996 }
 997
 998 GetFieldHandlePtr  Node::getHandleChildren(void) const
 999 {
1000     MFUnrecChildNodePtr::GetHandlePtr returnValue(
1001         new  MFUnrecChildNodePtr::GetHandle(
1002              &_mfChildren,
1003              this->getType().getFieldDesc(ChildrenFieldId),
1004              const_cast<Node *>(this)));
1005
1006     return returnValue;
1007 }
1008
1009 void Node::resolveLinks(void)
1010 {
1011     Inherited::resolveLinks();
1012
1013     editSField(CoreFieldMask);
1014     _sfCore.setValue(NULL);
1015
1016     editMField(ChildrenFieldMask, _mfChildren);
1017     _mfChildren.clear();
1018 }
1019
1020 /*---------------------------------------------------------------------*/
1021 /*! \name Node cloning                                                 */
1022 /*! \{                                                                 */
1023
1024 /*! Clones the scene starting at \a rootNode. By default FieldContainers,
1025     especially NodeCores, are shared, only if a container's type name is in
1026     \a cloneTypeNames or if it belonfs to a group in \a cloneGroupNames it is
1027     cloned. If a container's type is in \a ignoreTypeNames or belongs to a
1028     group in \a ignoreGroupNames it is ignored altogether.
1029
1030     \param[in] rootNode Root of the scene to clone.
1031     \param[in] cloneTypeNames List of type names that are cloned.
1032     \param[in] ignoreTypeNames List of type names that are ignored.
1033     \param[in] cloneGroupNames List of group names that are cloned.
1034     \param[in] ignoreGroupNames LIst of group names that are ignored.
1035     \return The root Node of the cloned scene.
1036
1037     \ingroup GrpBaseFieldContainerNodes
1038     \relatesalso Node
1039  */
1040
1041 NodeTransitPtr cloneTree(const OSG::Node                *rootNode,
1042                          const std::vector<std::string> &cloneTypeNames,
1043                          const std::vector<std::string> &ignoreTypeNames,
1044                          const std::vector<std::string> &cloneGroupNames,
1045                          const std::vector<std::string> &ignoreGroupNames)
1046 {
1047     std::vector<const ReflexiveContainerType *> cloneTypes;
1048     std::vector<const ReflexiveContainerType *> ignoreTypes;
1049     std::vector<UInt16>                         cloneGroupIds;
1050     std::vector<UInt16>                         ignoreGroupIds;
1051
1052     appendTypesVector (cloneTypeNames,   cloneTypes    );
1053     appendTypesVector (ignoreTypeNames,  ignoreTypes   );
1054     appendGroupsVector(cloneGroupNames,  cloneGroupIds );
1055     appendGroupsVector(ignoreGroupNames, ignoreGroupIds);
1056
1057     return cloneTree(rootNode, cloneTypes,    ignoreTypes,
1058                                cloneGroupIds, ignoreGroupIds);
1059 }
1060
1061 /*! Clones the scene starting at \a rootNode. By default FieldContainers,
1062     especially NodeCores, are shared, only if a container's group id is in
1063     \a cloneGroupIds it is cloned. If a container's group id is in
1064     \a ignoreGroupIds it is ignored altogether.
1065
1066     \param[in] rootNode Root of the scene to clone.
1067     \param[in] cloneGroupIds List of group ids, whose members are cloned.
1068     \param[in] ignoreGroupIds List of group ids, whose members are ignored.
1069     \return The root Node of the cloned scene.
1070
1071     \ingroup GrpBaseFieldContainerNodes
1072     \relatesalso Node
1073  */
1074
1075 NodeTransitPtr cloneTree(const OSG::Node                *rootNode,
1076                          const std::vector<OSG::UInt16> &cloneGroupIds,
1077                          const std::vector<OSG::UInt16> &ignoreGroupIds)
1078 {
1079     std::vector<const ReflexiveContainerType *> cloneTypes;
1080     std::vector<const ReflexiveContainerType *> ignoreTypes;
1081
1082     return cloneTree(rootNode, cloneTypes,    ignoreTypes,
1083                                cloneGroupIds, ignoreGroupIds);
1084 }
1085
1086 /*! Clones the scene starting at \a rootNode. By default FieldContainers,
1087     especially NodeCores, are shared, only if a container's type name is in
1088     \a cloneTypesString it is cloned. If a container's type is in
1089     \a ignoreTypesString it is ignored altogether.
1090
1091     \param[in] rootNode Root of the scene to clone.
1092     \param[in] cloneTypesString Comma separated string of type names that are
1093         cloned instead of shared.
1094     \param[in] ignoreTypesString Comma separated string of type names that are
1095         ignored.
1096     \return The root Node of the cloned scene.
1097
1098     \ingroup GrpBaseFieldContainerNodes
1099     \relatesalso Node
1100  */
1101
1102 NodeTransitPtr cloneTree(const OSG::Node       *rootNode,
1103                          const std::string     &cloneTypesString,
1104                          const std::string     &ignoreTypesString)
1105 {
1106     std::vector<const ReflexiveContainerType *> cloneTypes;
1107     std::vector<const ReflexiveContainerType *> ignoreTypes;
1108     std::vector<UInt16>                         cloneGroupIds;
1109     std::vector<UInt16>                         ignoreGroupIds;
1110
1111     appendTypesString(cloneTypesString,  cloneTypes);
1112     appendTypesString(ignoreTypesString, ignoreTypes);
1113
1114     return cloneTree(rootNode, cloneTypes,    ignoreTypes,
1115                                cloneGroupIds, ignoreGroupIds);
1116 }
1117
1118 /*! Clones the scene starting at \a rootNode. By default FieldContainers,
1119     especially NodeCores, are shared, only if a container's type is in
1120     \a cloneTypes of belongs to a group in \a cloneGroupIds it is cloned.
1121     If a container's type is in \a ignoreTypes or belongs to a group in
1122     \a ignoreGroupIds it is ignored altogether.
1123
1124     \param[in] rootNode Root of the scene to clone.
1125     \param[in] cloneTypes List of types to clone instead of share.
1126     \param[in] ignoreTypes List of types to ignore.
1127     \param[in] cloneGroupIds List of group ids, whose members are cloned.
1128     \param[in] ignoreGroupIds List of group ids, whose members are ignored.
1129     \return The root Node of the cloned scene.
1130
1131     \ingroup GrpBaseFieldContainerNodes
1132     \relatesalso Node
1133  */
1134
1135 NodeTransitPtr cloneTree(
1136     const OSG::Node                                        *rootNode,
1137     const std::vector<const OSG::ReflexiveContainerType *> &cloneTypes,
1138     const std::vector<const OSG::ReflexiveContainerType *> &ignoreTypes,
1139     const std::vector<OSG::UInt16>                         &cloneGroupIds,
1140     const std::vector<OSG::UInt16>                         &ignoreGroupIds)
1141 {
1142     NodeUnrecPtr rootClone(NULL);
1143
1144     if(rootNode != NULL)
1145     {
1146         NodeUnrecPtr  childClone;
1147         NodeCore     *core       = rootNode->getCore();
1148
1149         rootClone = Node::create();
1150         rootClone->setTravMask(rootNode->getTravMask());
1151
1152         cloneAttachments(rootNode,      rootClone,
1153                          cloneTypes,    ignoreTypes,
1154                          cloneGroupIds, ignoreGroupIds);
1155
1156         if(core != NULL)
1157         {
1158                   NodeCoreUnrecPtr    coreClone  = NULL;
1159             const FieldContainerType &coreType   = core->getType();
1160
1161             // test if core type should NOT be ignored
1162             if(!TypePredicates::typeInGroupIds(
1163                     ignoreGroupIds.begin(),
1164                     ignoreGroupIds.end(), coreType) &&
1165                !TypePredicates::typeDerivedFrom(
1166                     ignoreTypes.begin(),
1167                     ignoreTypes.end(),    coreType)   )
1168             {
1169                 // test if core should cloned
1170                 if(TypePredicates::typeInGroupIds (
1171                        cloneGroupIds.begin(),
1172                        cloneGroupIds.end(), coreType) ||
1173                    TypePredicates::typeDerivedFrom(
1174                        cloneTypes.begin(),
1175                        cloneTypes.end(),    coreType)   )
1176                 {
1177                     // clone core
1178                     coreClone =
1179                         dynamic_pointer_cast<NodeCore>(
1180                             deepClone(core,
1181                                       cloneTypes,    ignoreTypes,
1182                                       cloneGroupIds, ignoreGroupIds));
1183                 }
1184                 else
1185                 {
1186                     // share core
1187                     coreClone = core;
1188                 }
1189             }
1190
1191             rootClone->setCore(coreClone);
1192         }
1193
1194         for(UInt32 i = 0; i < rootNode->getNChildren(); ++i)
1195         {
1196             childClone = cloneTree(rootNode->getChild(i),
1197                                    cloneTypes,    ignoreTypes,
1198                                    cloneGroupIds, ignoreGroupIds);
1199
1200             rootClone->addChild(childClone);
1201         }
1202     }
1203
1204     return NodeTransitPtr(rootClone);
1205 }
1206
1207 /*! Clones the scene starting at \a rootNode. By default FieldContainers,
1208     especially NodeCores, are cloned, only if a container's type name is in
1209     \a shareTypeNames or if it belonfs to a group in \a shareGroupNames it is
1210     shared. If a container's type is in \a ignoreTypeNames or belongs to a
1211     group in \a ignoreGroupNames it is ignored altogether.
1212
1213     \param[in] rootNode Root of the scene to clone.
1214     \param[in] shareTypeNames List of type names that are shared.
1215     \param[in] ignoreTypeNames List of type names that are ignored.
1216     \param[in] shareGroupNames List of group names that are shared.
1217     \param[in] ignoreGroupNames LIst of group names that are ignored.
1218     \return The root Node of the cloned scene.
1219
1220     \ingroup GrpBaseFieldContainerNodes
1221     \relatesalso Node
1222  */
1223
1224 NodeTransitPtr deepCloneTree(const OSG::Node                *rootNode,
1225                              const std::vector<std::string> &shareTypeNames,
1226                              const std::vector<std::string> &ignoreTypeNames,
1227                              const std::vector<std::string> &shareGroupNames,
1228                              const std::vector<std::string> &ignoreGroupNames)
1229 {
1230     std::vector<const ReflexiveContainerType *> shareTypes;
1231     std::vector<const ReflexiveContainerType *> ignoreTypes;
1232     std::vector<UInt16>                         shareGroupIds;
1233     std::vector<UInt16>                         ignoreGroupIds;
1234
1235     appendTypesVector (shareTypeNames,   shareTypes    );
1236     appendTypesVector (ignoreTypeNames,  ignoreTypes   );
1237     appendGroupsVector(shareGroupNames,  shareGroupIds );
1238     appendGroupsVector(ignoreGroupNames, ignoreGroupIds);
1239
1240     return deepCloneTree(rootNode, shareTypes,    ignoreTypes,
1241                                    shareGroupIds, ignoreGroupIds);
1242 }
1243
1244 /*! Clones the scene starting at \a rootNode. By default FieldContainers,
1245     especially NodeCores, are cloned, only if a container's group id is in
1246     \a shareGroupIds it is shared. If a container's group id is in
1247     \a ignoreGroupIds it is ignored altogether.
1248
1249     \param[in] rootNode Root of the scene to clone.
1250     \param[in] shareGroupIds List of group ids, whose members are shared.
1251     \param[in] ignoreGroupIds List of group ids, whose members are ignored.
1252     \return The root Node of the cloned scene.
1253
1254     \ingroup GrpBaseFieldContainerNodes
1255     \relatesalso Node
1256  */
1257
1258 NodeTransitPtr deepCloneTree(const OSG::Node                *rootNode,
1259                              const std::vector<OSG::UInt16> &shareGroupIds,
1260                              const std::vector<OSG::UInt16> &ignoreGroupIds)
1261 {
1262     std::vector<const ReflexiveContainerType *> shareTypes;
1263     std::vector<const ReflexiveContainerType *> ignoreTypes;
1264
1265     return deepCloneTree(rootNode, shareTypes,    ignoreTypes,
1266                                    shareGroupIds, ignoreGroupIds);
1267 }
1268
1269 /*! Clones the scene starting at \a rootNode. By default FieldContainers,
1270     especially NodeCores, are cloned, only if a container's type name is in
1271     \a shareTypesString it is shared. If a container's type is in
1272     \a ignoreTypesString it is ignored altogether.
1273
1274     \param[in] rootNode Root of the scene to clone.
1275     \param[in] shareTypesString Comma separated string of type names that are
1276         shared instead of cloned.
1277     \param[in] ignoreTypesString Comma separated string of type names that are
1278         ignored.
1279     \return The root Node of the cloned scene.
1280
1281     \ingroup GrpBaseFieldContainerNodes
1282     \relatesalso Node
1283  */
1284
1285 NodeTransitPtr deepCloneTree(const Node            *rootNode,
1286                              const std::string     &shareTypesString,
1287                              const std::string     &ignoreTypesString)
1288 {
1289     std::vector<const ReflexiveContainerType *> shareTypes;
1290     std::vector<const ReflexiveContainerType *> ignoreTypes;
1291     std::vector<UInt16>                         shareGroupIds;
1292     std::vector<UInt16>                         ignoreGroupIds;
1293
1294     appendTypesString(shareTypesString,  shareTypes);
1295     appendTypesString(ignoreTypesString, ignoreTypes);
1296
1297     return deepCloneTree(rootNode, shareTypes,    ignoreTypes,
1298                                    shareGroupIds, ignoreGroupIds);
1299 }
1300
1301 /*! Clones the scene starting at \a rootNode. By default FieldContainers,
1302     especially NodeCores, are cloned, only if a container's type is in
1303     \a shareTypes of belongs to a group in \a shareGroupIds it is shared.
1304     If a container's type is in \a ignoreTypes or belongs to a group in
1305     \a ignoreGroupIds it is ignored altogether.
1306
1307     \param[in] rootNode Root of the scene to clone.
1308     \param[in] shareTypes List of types to share instead of clone.
1309     \param[in] ignoreTypes List of types to ignore.
1310     \param[in] shareGroupIds List of group ids, whose members are shared.
1311     \param[in] ignoreGroupIds List of group ids, whose members are ignored.
1312     \return The root Node of the cloned scene.
1313
1314     \ingroup GrpBaseFieldContainerNodes
1315     \relatesalso Node
1316  */
1317
1318 NodeTransitPtr deepCloneTree(
1319     const OSG::Node                                        *rootNode,
1320     const std::vector<const OSG::ReflexiveContainerType *> &shareTypes,
1321     const std::vector<const OSG::ReflexiveContainerType *> &ignoreTypes,
1322     const std::vector<OSG::UInt16>                         &shareGroupIds,
1323     const std::vector<OSG::UInt16>                         &ignoreGroupIds)
1324 {
1325     NodeUnrecPtr rootClone(NULL);
1326
1327     if(rootNode != NULL)
1328     {
1329         NodeUnrecPtr  childClone;
1330         NodeCore     *core       = rootNode->getCore();
1331
1332         rootClone = Node::create();
1333         rootClone->setTravMask(rootNode->getTravMask());
1334
1335         deepCloneAttachments(rootNode,      rootClone,
1336                              shareTypes,    ignoreTypes,
1337                              shareGroupIds, ignoreGroupIds);
1338
1339         if(core != NULL)
1340         {
1341                   NodeCoreUnrecPtr    coreClone(NULL);
1342             const FieldContainerType &coreType   = core->getType();
1343
1344             // test if core type should NOT be ignored
1345             if(!TypePredicates::typeInGroupIds (
1346                     ignoreGroupIds.begin(),
1347                     ignoreGroupIds.end(), coreType) &&
1348                !TypePredicates::typeDerivedFrom(
1349                     ignoreTypes.begin(),
1350                     ignoreTypes.end(),    coreType)   )
1351             {
1352                 // test if core should be shared
1353                 if(TypePredicates::typeInGroupIds (
1354                        shareGroupIds.begin(),
1355                        shareGroupIds.end(), coreType) ||
1356                    TypePredicates::typeDerivedFrom(
1357                        shareTypes.begin(),
1358                        shareTypes.end(),    coreType)   )
1359                 {
1360                     // share core
1361                     coreClone = core;
1362                 }
1363                 else
1364                 {
1365                     // clone core
1366                     coreClone =
1367                         dynamic_pointer_cast<NodeCore>(
1368                             deepClone(core,
1369                                       shareTypes,    ignoreTypes,
1370                                       shareGroupIds, ignoreGroupIds));
1371                 }
1372             }
1373
1374             rootClone->setCore(coreClone);
1375         }
1376
1377         for(UInt32 i = 0; i < rootNode->getNChildren(); ++i)
1378         {
1379             childClone = deepCloneTree(rootNode->getChild(i),
1380                                        shareTypes,    ignoreTypes,
1381                                        shareGroupIds, ignoreGroupIds);
1382
1383             rootClone->addChild(childClone);
1384         }
1385     }
1386
1387     return NodeTransitPtr(rootClone);
1388 }
1389
1390 /*! \}                                                                 */
1391 /*---------------------------------------------------------------------*/
1392
1393 OSG_END_NAMESPACE