Source/System/NodeCores/Groups/Base/OSGChunkOverrideGroup.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *               Copyright (C) 2000-2006 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 "OSGChunkOverrideGroup.h"
  49 #include "OSGRenderAction.h"
  50 #include "OSGChunkBlock.h"
  51 #include "OSGStateChunk.h"
  52
  53 OSG_BEGIN_NAMESPACE
  54
  55 // Documentation for this class is emitted in the
  56 // OSGChunkOverrideGroupBase.cpp file.
  57 // To modify it, please change the .fcd file (OSGChunkOverrideGroup.fcd) and
  58 // regenerate the base file.
  59
  60 /***************************************************************************\
  61  *                           Class variables                               *
  62 \***************************************************************************/
  63
  64 /***************************************************************************\
  65  *                           Class methods                                 *
  66 \***************************************************************************/
  67
  68 void ChunkOverrideGroup::classDescInserter(TypeObject &oType)
  69 {
  70     Inherited::classDescInserter(oType);
  71 }
  72
  73 void ChunkOverrideGroup::initMethod(InitPhase ePhase)
  74 {
  75     Inherited::initMethod(ePhase);
  76
  77     if(ePhase == TypeObject::SystemPost)
  78     {
  79         RenderAction::registerEnterDefault(
  80             ChunkOverrideGroup::getClassType(),
  81             reinterpret_cast<Action::Callback>(
  82                 &ChunkOverrideGroup::renderEnter));
  83
  84         RenderAction::registerLeaveDefault(
  85             ChunkOverrideGroup::getClassType(),
  86             reinterpret_cast<Action::Callback>(
  87                 &ChunkOverrideGroup::renderLeave));
  88     }
  89 }
  90
  91
  92 /***************************************************************************\
  93  *                           Instance methods                              *
  94 \***************************************************************************/
  95
  96 /*-------------------------------------------------------------------------*\
  97  -  private                                                                 -
  98 \*-------------------------------------------------------------------------*/
  99
 100 /*----------------------- constructors & destructors ----------------------*/
 101
 102 ChunkOverrideGroup::ChunkOverrideGroup(void) :
 103     Inherited()
 104 {
 105 }
 106
 107 ChunkOverrideGroup::ChunkOverrideGroup(const ChunkOverrideGroup &source) :
 108     Inherited(source)
 109 {
 110 }
 111
 112 ChunkOverrideGroup::~ChunkOverrideGroup(void)
 113 {
 114 }
 115
 116 /*----------------------------- class specific ----------------------------*/
 117
 118 bool ChunkOverrideGroup::addChunk(StateChunk *chunk,
 119                                   Int32       slot)
 120 {
 121     ChunkBlockUnrecPtr pBlock = this->finalize(0x0000);
 122
 123     if(pBlock == NULL)
 124     {
 125         pBlock = ChunkBlock::create();
 126
 127         this->addChunkBlock(pBlock, 0x0000);
 128     }
 129
 130     return pBlock->addChunk(chunk, slot);
 131 }
 132
 133 bool ChunkOverrideGroup::subChunk(StateChunk *chunk,
 134                                   Int32       slot)
 135 {
 136     if(chunk == NULL)
 137         return false;
 138
 139     ChunkBlock *pBlock = this->finalize(0x0000);
 140
 141     if(pBlock != NULL)
 142     {
 143         return pBlock->subChunk(chunk, slot);
 144     }
 145
 146     return false;
 147 }
 148
 149 Int32 ChunkOverrideGroup::find(StateChunk *chunk)
 150 {
 151     ChunkBlock *pBlock = this->finalize(0x0000);
 152
 153     if(pBlock != NULL)
 154     {
 155         return pBlock->find(chunk);
 156     }
 157
 158     return -1;
 159 }
 160
 161 StateChunk *ChunkOverrideGroup::find(const StateChunkClass &type,
 162                                            Int32            slot)
 163 {
 164     ChunkBlock *pBlock = this->finalize(0x0000);
 165
 166     if(pBlock != NULL)
 167     {
 168         return pBlock->find(type, slot);
 169     }
 170
 171     return NULL;
 172 }
 173
 174 /*-------------------------------------------------------------------------*/
 175 /* Binary access                                                           */
 176
 177 void ChunkOverrideGroup::addChunkBlock(ChunkBlock       * const pBlock,
 178                                        ChunkBlockMapKey         key)
 179 {
 180     Inherited::addElement(pBlock, key);
 181 }
 182
 183
 184 void ChunkOverrideGroup::subChunkBlock(ChunkBlockMapKey key)
 185 {
 186     Inherited::subElement(key);
 187 }
 188
 189 const SFChunkBlockPtrMap *ChunkOverrideGroup::getSFChunkBlockStore(void) const
 190 {
 191     return Inherited::getMapCacheField();
 192 }
 193
 194 void ChunkOverrideGroup::changed(ConstFieldMaskArg whichField,
 195                                  UInt32            origin,
 196                                  BitVector         details)
 197 {
 198     Inherited::changed(whichField, origin, details);
 199 }
 200
 201 void ChunkOverrideGroup::dump(      UInt32    ,
 202                               const BitVector ) const
 203 {
 204     SLOG << "Dump ChunkOverrideGroup NI" << std::endl;
 205 }
 206
 207 Action::ResultE ChunkOverrideGroup::renderEnter(Action *action)
 208 {
 209     RenderAction *pAction = dynamic_cast<RenderAction *>(action);
 210
 211     if(pAction != NULL)
 212     {
 213         pAction->pushState();
 214
 215         ChunkBlock *pBlock = this->finalize(pAction->getRenderProperties());
 216
 217         if(pBlock == NULL)
 218             return Inherited::renderEnter(action);
 219
 220         MFUnrecStateChunkPtr::const_iterator chIt   = pBlock->beginChunks();
 221         MFUnrecStateChunkPtr::const_iterator chEnd  = pBlock->endChunks  ();
 222         UInt32                               uiSlot = 0;
 223
 224         while(chIt != chEnd)
 225         {
 226             if(*chIt != NULL && (*chIt)->getIgnore() == false)
 227             {
 228                 if (getSubOverride())
 229                 {
 230                     pAction->subOverride(uiSlot, *chIt);
 231                 }
 232                 else
 233                 {
 234                     pAction->addOverride(uiSlot, *chIt);
 235                 }
 236             }
 237
 238             ++uiSlot;
 239             ++chIt;
 240         }
 241     }
 242
 243     return Inherited::renderEnter(action);
 244 }
 245
 246 Action::ResultE ChunkOverrideGroup::renderLeave(Action *action)
 247 {
 248     RenderAction *pAction =
 249         dynamic_cast<RenderAction *>(action);
 250
 251     if(pAction != NULL)
 252     {
 253         pAction->popState();
 254     }
 255
 256
 257     return Inherited::renderLeave(action);
 258 }
 259
 260 OSG_END_NAMESPACE