Source/System/State/Base/OSGStateChunk.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright(C) 2000-2002 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 "OSGStateChunk.h"
  49 #include "OSGLog.h"
  50
  51
  52 OSG_BEGIN_NAMESPACE
  53
  54 /*! \ingroup GrpSystemStateBase
  55     \nohierarchy
  56  */
  57 struct StateChunkClassCompare
  58 {
  59     bool operator()(const StateChunkClass *lhs,
  60                     const StateChunkClass *rhs)
  61     {
  62         return lhs->getPriority() < rhs->getPriority();
  63     }
  64 };
  65
  66 OSG_END_NAMESPACE
  67
  68 OSG_USING_NAMESPACE
  69
  70 // Documentation for this class is emited in the
  71 // OSGStateChunkBase.cpp file.
  72 // To modify it, please change the .fcd file (OSGStateChunk.fcd) and
  73 // regenerate the base file.
  74
  75 /***************************************************************************\
  76  *                               Types                                     *
  77 \***************************************************************************/
  78
  79 /*! \class OSG::StateChunkClass
  80
  81 See \ref StateChunkClass for the
  82 conceptual background.
  83
  84 */
  85
  86 /*! \var OSG::StateChunkClass::_classId
  87     The numerical ID associated with each StateChunkClass. It is used to
  88     uniquely identify and quickly compare the class.
  89
  90     \dev The classId is consecutive in the number of slots allocated to the
  91     chunk class, i.e. if a class has id 4 and 4 chunks, the next registered
  92     class will get id 8. The classId is used as an index into the OSG::State's
  93     chunk vector, which necessitates this behaviour. \enddev
  94 */
  95
  96 std::vector<StateChunkClass *> *StateChunkClass::_classes     = NULL;
  97 std::vector<StateChunkClass *> *StateChunkClass::_initClasses = NULL;
  98
  99 /*! The global vector of known StateChunkClasses' number of concurrently
 100     active slots. Use StateChunkClass::getNumSlots with the Class's ID to access
 101     it.
 102
 103     \dev See the OSG::StateChunkClass::_classId for details. \enddev
 104 */
 105
 106 std::vector<UInt32                     > *StateChunkClass::_numslots   = NULL;
 107
 108
 109 bool StateChunkClass::terminate(void)
 110 {
 111     delete _classes;
 112     delete _initClasses;
 113     delete _numslots;
 114
 115     return true;
 116 }
 117
 118 bool StateChunkClass::initialize(void)
 119 {
 120     std::stable_sort(_initClasses->begin    (),
 121                      _initClasses->end      (),
 122                       StateChunkClassCompare());
 123
 124     _classes  = new std::vector<StateChunkClass *>;
 125     _numslots = new std::vector<     UInt32      >;
 126
 127     for(UInt32 i = 0; i < _initClasses->size(); ++i)
 128     {
 129         (*_initClasses)[i]->_classId = UInt32(_classes->size());
 130
 131         for(UInt32 j = 0; j < (*_initClasses)[i]->_numSlots; ++j)
 132         {
 133             _classes ->push_back((*_initClasses)[i]);
 134             _numslots->push_back((*_initClasses)[i]->_numSlots);
 135         }
 136     }
 137
 138     for(UInt32 i = 0; i < _classes->size(); ++i)
 139     {
 140         FDEBUG_GV(("[%d/%d][%d] %s %d %d\n",
 141                    i,
 142                    StateChunkClass::getUsedSlots(),
 143                    (*_classes)[i]->_classId,
 144                    (*_classes)[i]->_className.c_str(),
 145                    (*_classes)[i]->_priority,
 146                    (*_classes)[i]->_numSlots));
 147     }
 148
 149     return true;
 150 }
 151
 152 OSG_BEGIN_NAMESPACE
 153
 154 StateChunkClass::StateChunkClassInit StateChunkClass::InitHelper;
 155
 156 OSG_END_NAMESPACE
 157
 158 /*! Constructor. The name is mandatory, the number of concurrently active slots
 159     is optional, default is 1.
 160 */
 161
 162 StateChunkClass::StateChunkClass(const Char8  *name,
 163                                        UInt32  numslots,
 164                                        UInt32  priority) :
 165     _classId  (       0),
 166     _numSlots (numslots),
 167     _priority (priority),
 168     _className(    name)
 169 {
 170     if(!_initClasses)
 171     {
 172         _initClasses = new std::vector<StateChunkClass *>;
 173
 174         addPostFactoryExitFunction(&StateChunkClass::terminate);
 175     }
 176
 177     _initClasses->push_back(this);
 178 }
 179
 180 const Char8 *StateChunkClass::getName(void) const
 181 {
 182     return _className.c_str();
 183 }
 184
 185 Int32 StateChunkClass::getNumSlots(void) const
 186 {
 187     return(*_numslots)[_classId];
 188 }
 189
 190 /*! Access the name for the class whose id is index.
 191 */
 192
 193 const Char8 *StateChunkClass::getName(UInt32 index)
 194 {
 195     if(index >=(*_classes).size())
 196             return "<Unknown StatChunkClass!>";
 197
 198     return(*_classes)[index]->_className.c_str();
 199 }
 200
 201
 202 /*! \var OSG::StateChunkClass::iterator
 203
 204     Iterator type to access the chunk class list.
 205 */
 206
 207 /*! Iterator to allow access to all known StateChunkClasses.
 208 */
 209
 210 StateChunkClass::iterator StateChunkClass::begin(void)
 211 {
 212     return _classes->begin();
 213 }
 214
 215 /*! Iterator to allow access to all known StateChunkClasses.
 216 */
 217
 218 StateChunkClass::iterator StateChunkClass::end(void)
 219 {
 220     return _classes->end();
 221 }
 222
 223
 224 /***************************************************************************\
 225  *                           Class variables                               *
 226 \***************************************************************************/
 227
 228 /***************************************************************************\
 229  *                           Class methods                                 *
 230 \***************************************************************************/
 231
 232 void StateChunk::initMethod(InitPhase ePhase)
 233 {
 234     Inherited::initMethod(ePhase);
 235 }
 236
 237 /***************************************************************************\
 238  *                           Instance methods                              *
 239 \***************************************************************************/
 240
 241 /*-------------------------------------------------------------------------*\
 242  -  public                                                                 -
 243 \*-------------------------------------------------------------------------*/
 244
 245
 246 /*------------- constructors & destructors --------------------------------*/
 247
 248 StateChunk::StateChunk(void) :
 249     Inherited()
 250 {
 251 }
 252
 253 StateChunk::StateChunk(const StateChunk &source) :
 254     Inherited(source)
 255 {
 256 }
 257
 258 StateChunk::~StateChunk(void)
 259 {
 260 }
 261
 262 UInt16 StateChunk::getChunkId(void)
 263 {
 264     return 0;
 265 }
 266
 267 /*------------------------------- Sync -----------------------------------*/
 268
 269 void StateChunk::changed(ConstFieldMaskArg whichField,
 270                          UInt32            origin,
 271                          BitVector         details)
 272 {
 273     Inherited::changed(whichField, origin, details);
 274 }
 275
 276 /*------------------------------ Output ----------------------------------*/
 277
 278 void StateChunk::dump(      UInt32    OSG_CHECK_ARG(uiIndent),
 279                       const BitVector OSG_CHECK_ARG(bvFlags )) const
 280 {
 281     SLOG << "Dump StateChunk NI" << std::endl;
 282 }
 283
 284
 285 /*------------------------------ State ------------------------------------*/
 286
 287 #ifndef OSG_DISABLE_DEPRECATED
 288 void StateChunk::update(DrawEnv *)
 289 {
 290 }
 291 #endif
 292
 293 /*! Check if the chunk is transparent, i.e. needs to be rendered after the
 294     opaque objects.
 295  */
 296
 297 bool StateChunk::isTransparent(void) const
 298 {
 299     return false;
 300 }
 301
 302 void StateChunk::updateObjectDependencies(DrawEnv    *pEnv,
 303                                           UInt32      index)
 304 {
 305 }
 306
 307 /*---------------------- Chunk Class Access -------------------------------*/
 308
 309 const StateChunkClass *StateChunk::getClass(void) const
 310 {
 311     return NULL;
 312 }
 313
 314 /*-------------------------- Comparison -----------------------------------*/
 315
 316 /*! Calculate how expensive it is to switch from one instance of the chunk
 317     class to another. In most cases not implemented yet, will return 0.
 318  */
 319
 320 Real32 StateChunk::switchCost(StateChunk *OSG_CHECK_ARG(chunk))
 321 {
 322     return 0;
 323 }
 324
 325 bool StateChunk::operator <(const StateChunk &other) const
 326 {
 327     return this < &other;
 328 }
 329
 330 /*! Compare two chunks. In most cases not implemented yet, will return false.
 331  */
 332
 333 bool StateChunk::operator ==(const StateChunk &OSG_CHECK_ARG(other)) const
 334 {
 335     return false;
 336 }
 337
 338 bool StateChunk::operator !=(const StateChunk &other) const
 339 {
 340     return !(*this == other);
 341 }