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