Source/System/State/Base/OSGState.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 "OSGGL.h"
  49
  50 #include "OSGStateChunk.h"
  51
  52 #include "OSGState.h"
  53
  54 #include "OSGTextureBaseChunk.h"
  55 #include "OSGMaterialChunk.h"
  56 #include "OSGShaderExecutableChunk.h"
  57 #include "OSGShaderExecutableVarChunk.h"
  58 #include "OSGLightChunk.h"
  59 #include "OSGMaterial.h"
  60
  61 OSG_USING_NAMESPACE
  62
  63 // Documentation for this class is emited in the
  64 // OSGStateBase.cpp file.
  65 // To modify it, please change the .fcd file (OSGState.fcd) and
  66 // regenerate the base file.
  67
  68 /***************************************************************************\
  69  *                           Class variables                               *
  70 \***************************************************************************/
  71
  72 /***************************************************************************\
  73  *                           Class methods                                 *
  74 \***************************************************************************/
  75
  76 /*-------------------------------------------------------------------------*\
  77  -  private                                                                -
  78 \*-------------------------------------------------------------------------*/
  79
  80 void State::initMethod(InitPhase ePhase)
  81 {
  82     Inherited::initMethod(ePhase);
  83 }
  84
  85 /***************************************************************************\
  86  *                           Instance methods                              *
  87 \***************************************************************************/
  88
  89 /*-------------------------------------------------------------------------*\
  90  -  public                                                                 -
  91 \*-------------------------------------------------------------------------*/
  92
  93 void State::onCreateAspect(const State *createAspect,
  94                            const State *source      )
  95 {
  96     Inherited::onCreateAspect(createAspect, source);
  97
  98     UInt32 uiTId  = TextureBaseChunk        ::getStaticClassId() & 0x000003FF;
  99     UInt32 uiShId = ShaderExecutableChunk   ::getStaticClassId() & 0x000003FF;
 100     UInt32 uiMId  = ShaderExecutableVarChunk::getStaticClassId() & 0x000003FF;
 101
 102     _uiKeyGen = ( (uiShId) | (uiTId << 10) | (uiMId      << 20) );
 103
 104 /*
 105     fprintf(stderr, "CreateKeyGen (%p | %p | %p) from %d %d -> %08x\n",
 106             this,
 107             createAspect,
 108             source,
 109             TextureChunk ::getStaticClassId(),
 110             MaterialChunk::getStaticClassId(),
 111             _uiKeyGen);
 112 */
 113 }
 114
 115 /*------------- constructors & destructors --------------------------------*/
 116
 117 State::State(void) :
 118      Inherited         (                              ),
 119     _uiDefaultSortKey  (0                             ),
 120     _uiSortKey         (0                             ),
 121     _uiKeyGen          (0                             ),
 122 #if defined(OSG_OGL_COREONLY)
 123     _uiCoreGLChunkLimit(LightChunk::getStaticClassId())
 124 #else
 125     _uiCoreGLChunkLimit(4096                          ) // Arbitrary high value
 126 #endif
 127 {
 128 }
 129
 130 State::State(const State &source) :
 131      Inherited         (                        source),
 132     _uiDefaultSortKey  (                             0),
 133     _uiSortKey         (                             0),
 134     _uiKeyGen          (                             0),
 135 #if defined(OSG_OGL_COREONLY)
 136     _uiCoreGLChunkLimit(LightChunk::getStaticClassId())
 137 #else
 138     _uiCoreGLChunkLimit(4096                          ) // Arbitrary high value
 139 #endif
 140 {
 141 }
 142
 143 State::~State(void)
 144 {
 145 }
 146
 147 void State::rebuildSortKey(void)
 148 {
 149     UInt32 uiKey1 =  _uiKeyGen & Key1Mask;
 150     UInt32 uiKey2 = (_uiKeyGen & Key2Mask) >> 10;
 151     UInt32 uiKey3 = (_uiKeyGen & Key3Mask) >> 20;
 152
 153     UInt32 uiSizeChunks = _mfChunks.size32();
 154
 155 //    fprintf(stderr, "Got Keys %d %d %d\n", uiKey1, uiKey2, uiKey3);
 156
 157     const State *pThis = this;
 158
 159     if(uiKey1 != InvalidKey && uiKey1 < uiSizeChunks)
 160     {
 161         uiKey1 =
 162             (pThis->_mfChunks[uiKey1]              != NULL  &&
 163              pThis->_mfChunks[uiKey1]->getIgnore() == false   ) ?
 164
 165             pThis->_mfChunks[uiKey1]->getChunkId() : 0;
 166     }
 167     else
 168     {
 169         uiKey1 = 0x00000000;
 170     }
 171
 172     if(uiKey2 != InvalidKey && uiKey2 < uiSizeChunks)
 173     {
 174         uiKey2 =
 175             (pThis->_mfChunks[uiKey2]              != NULL  &&
 176              pThis->_mfChunks[uiKey2]->getIgnore() == false   ) ?
 177
 178             pThis->_mfChunks[uiKey2]->getChunkId() : 0;
 179     }
 180     else
 181     {
 182         uiKey2 = 0x00000000;
 183     }
 184
 185     if(uiKey3 != InvalidKey && uiKey3 < uiSizeChunks)
 186     {
 187         uiKey3 =
 188             (pThis->_mfChunks[uiKey3]              != NULL  &&
 189              pThis->_mfChunks[uiKey3]->getIgnore() == false   ) ?
 190
 191             pThis->_mfChunks[uiKey3]->getChunkId() : 0;
 192     }
 193     else
 194     {
 195         uiKey3 = 0x00000000;
 196     }
 197
 198     _uiSortKey =
 199          (uiKey1 & Key1Mask)        |
 200         ((uiKey2 & Key1Mask) << 10) |
 201         ((uiKey3 & Key1Mask) << 20);
 202
 203     if(_uiSortKey == 0x00000000)
 204     {
 205         _uiSortKey = _uiDefaultSortKey;
 206     }
 207
 208 /*
 209     fprintf(stderr, "Use Sort Key : %08x %08x %08x %08x -> %08x\n",
 210              uiKey1,
 211              uiKey2,
 212              uiKey3,
 213             _uiDefaultSortKey,
 214             _uiSortKey);
 215  */
 216 }
 217
 218 void State::changed(ConstFieldMaskArg whichField,
 219                     UInt32            origin,
 220                     BitVector         details)
 221 {
 222     Inherited::changed(whichField, origin, details);
 223
 224     rebuildSortKey();
 225 }
 226
 227 /*------------------------------- dump ----------------------------------*/
 228
 229 void State::dump(     UInt32    OSG_CHECK_ARG(uiIndent),
 230                  const BitVector OSG_CHECK_ARG(bvFlags)) const
 231 {
 232     std::cerr << "State at " << this << std::endl;
 233
 234     MFChunksType::const_iterator it;
 235     UInt32 cind;
 236
 237     for(it = _mfChunks.begin(), cind = 0; it != _mfChunks.end(); ++it, ++cind)
 238     {
 239         std::cerr << "[" << cind << "]["
 240                   << StateChunkClass::getName(cind) << "]\t";
 241
 242         if(*it == NULL)
 243         {
 244             std::cerr << "NullChunk" << std::endl;
 245         }
 246         else
 247         {
 248             std::cerr << *it << std::endl;
 249         }
 250     }
 251 }
 252
 253 /*-------------------- OpenGL State Management --------------------------*/
 254
 255 /*! Activate (i.e. call all their OpenGL commands) the current set of
 256     StateChunks. Activate will simply overwrite whatever was set before.
 257 */
 258
 259 void State::activate(DrawEnv *pEnv) const
 260 {
 261     MFChunksType::const_iterator cIt    = _mfChunks.begin();
 262     MFChunksType::const_iterator cEnd   = _mfChunks.end  ();
 263     Int32                        ind    = 0;
 264     UInt32                       cind   = osgMin(State::SkipNumChunks,
 265                                                  _mfChunks.size32()  );
 266     UInt32 const                 climit = _uiCoreGLChunkLimit;
 267
 268     OSG_SKIP_IT(cIt, cind);
 269
 270     for(; (cIt != cEnd) && (cind < climit); ++cIt, ++cind)
 271     {
 272         if(*cIt != NULL && (*cIt)->getIgnore() == false)
 273         {
 274             (*cIt)->activate(pEnv, UInt32(ind));
 275         }
 276
 277         if(++ind >= StateChunkClass::getNumSlots(cind))
 278             ind = 0;
 279     }
 280 }
 281
 282
 283 /*! Switch to this state from the given old State. The chunks will try to
 284     optimize the transition.
 285 */
 286
 287 void State::changeFrom(DrawEnv *pEnv, State *pOld) const
 288 {
 289     MFChunksType::const_iterator cIt    = _mfChunks.begin();
 290     MFChunksType::const_iterator cEnd   = _mfChunks.end  ();
 291     Int32                        ind    = 0;
 292     UInt32                       i;
 293     UInt32                       cind   = osgMin(State::SkipNumChunks,
 294                                                  _mfChunks.size32()  );
 295     UInt32 const                 climit = _uiCoreGLChunkLimit;
 296
 297     OSG_SKIP_IT(cIt, cind);
 298
 299     for(; (cIt != cEnd) && (cind < climit); ++cIt, ++cind)
 300     {
 301         StateChunk *o = pOld->getChunk(cind);
 302         StateChunk *n = *cIt;
 303
 304         if(n != NULL && n->getIgnore() == false)
 305         {
 306             if(o != NULL && o->getIgnore() == false)
 307             {
 308                 n->changeFrom(pEnv, o, UInt32(ind));
 309             }
 310             else
 311             {
 312                 n->activate(pEnv, UInt32(ind));
 313             }
 314         }
 315         else if(o != NULL && o->getIgnore() == false)
 316         {
 317             o->deactivate(pEnv, UInt32(ind));
 318         }
 319
 320         if(++ind >= StateChunkClass::getNumSlots(cind))
 321             ind = 0;
 322     }
 323
 324     if(ind >= StateChunkClass::getNumSlots(cind))
 325         ind = 0;
 326
 327     for(i = cind; (i < pOld->getMFChunks()->size()) && (i < climit); ++i)
 328     {
 329         StateChunk *o = pOld->getChunk(i);
 330
 331         if(o != NULL && o->getIgnore() == false)
 332         {
 333             o->deactivate(pEnv, UInt32(ind));
 334         }
 335
 336         if(++ind >= StateChunkClass::getNumSlots(i))
 337         {
 338             ind = 0;
 339         }
 340     }
 341 }
 342
 343
 344 /*! Deactivate the current set of StateChunks, i.e. switch everything back to
 345     the default state for the OpenGL state covered by the given chunks.
 346 */
 347
 348 void State::deactivate(DrawEnv *pEnv) const
 349 {
 350     MFChunksType::const_iterator cIt    = _mfChunks.begin();
 351     MFChunksType::const_iterator cEnd   = _mfChunks.end  ();
 352     Int32                        ind    = 0;
 353     UInt32                       cind   = osgMin(State::SkipNumChunks,
 354                                                  _mfChunks.size32()  );
 355     UInt32 const                 climit = _uiCoreGLChunkLimit;
 356
 357     OSG_SKIP_IT(cIt, cind);
 358
 359     for(; (cIt != cEnd) && (cind < climit); ++cIt, ++cind)
 360     {
 361         if(*cIt != NULL && (*cIt)->getIgnore() == false)
 362             (*cIt)->deactivate(pEnv, UInt32(ind));
 363
 364         if(++ind >= StateChunkClass::getNumSlots(cind))
 365             ind = 0;
 366     }
 367 }
 368
 369 /*---------------------------- Access -----------------------------------*/
 370
 371 /*! Add the given chunk to the State. The index defines the behaviour,
 372     especially for multi-slot chunks.
 373
 374     If it is set to AutoSlotReplace (the default), addChunk will try to find an
 375     empty slot for the chunk class, if it doesn't find one the last one will be
 376     replaced with the new entry. This is also useful for chunk classes with
 377     only a single slot, as it will override an old instance of the chunk class,
 378     which is usually the desired behaviour.
 379
 380     If it is set to AutoSlot, the new chunk will only be added to the State if
 381     there is a free slot. If there is no free slot true will be returned, in
 382     all other cases it will be false.
 383
 384     If the index is explicitly given (i.e. it is >=0) the chunk will be set
 385     into the given slot, possibly overwriting an old entry. If the index is
 386     larger than the number of slots for the given chunck class true will be
 387     returned.
 388 */
 389
 390 bool State::addChunk(StateChunk *chunk, Int32 index)
 391 {
 392     if(index > 0 && index > chunk->getClass()->getNumSlots())
 393     {
 394         SWARNING << "addChunk: index "
 395                  << index
 396                  << " > Numslots "
 397                  << chunk->getClass()->getNumSlots()
 398                  << ",  ignored!"
 399                  << std::endl;
 400         return true;
 401     }
 402
 403     UInt32 cindex =  chunk->getClassId();
 404     UInt32 csize  = _mfChunks.size32();
 405
 406     const State *pThis = this;
 407
 408     // special case: find empty slot automatically
 409     if(index == AutoSlot || index == AutoSlotReplace)
 410     {
 411         UInt8 nslots = chunk->getClass()->getNumSlots();
 412         UInt8 ci;
 413
 414         for(ci = cindex; ci < cindex + nslots && ci < csize; ++ci)
 415         {
 416             if(pThis->_mfChunks[ci] == NULL)
 417             {
 418                 break;
 419             }
 420         }
 421
 422         if(ci >= cindex + nslots)    // no free slot found
 423         {
 424             if(index == AutoSlot)
 425             {
 426                 SWARNING << "addChunk: no free slot found for "
 427                          << chunk->getClass()->getName()
 428                          << " class, ignored!" << std::endl;
 429                 return true;
 430             }
 431             // use last slot
 432             --ci;
 433         }
 434
 435         cindex = ci;
 436     }
 437     else
 438     {
 439         cindex += index;
 440     }
 441
 442     editMField(ChunksFieldMask, _mfChunks);
 443
 444     // add the chunk to the state at cindex
 445     if(cindex >= csize)
 446     {
 447         UInt32 oldsize = csize;
 448         UInt32 newsize = cindex + 1;
 449
 450         _mfChunks.resize(newsize);
 451
 452         for(UInt32 i = oldsize; i < newsize; i++)
 453         {
 454             _mfChunks.replace(i, NULL);
 455         }
 456     }
 457
 458     _mfChunks.replace(cindex, chunk);
 459
 460     return false;
 461 }
 462
 463 /*! Remove the given chunk from the State. Returns false if successful, true if
 464     the chunk wasn't found.
 465 */
 466
 467 bool State::subChunk(StateChunk *chunk)
 468 {
 469     if(chunk == NULL)
 470         return true;
 471
 472     UInt32 cindex =  chunk->getClassId();
 473     UInt32 csize  = _mfChunks.size32();
 474
 475     // special case: find it in the slots
 476     UInt8 nslots = chunk->getClass()->getNumSlots();
 477     UInt8 ci;
 478
 479     const State *pThis = this;
 480
 481     for(ci = cindex; ci < cindex + nslots && ci < csize; ci++)
 482     {
 483         if(pThis->_mfChunks[ci] == chunk)
 484         {
 485             break;
 486         }
 487     }
 488
 489     if(ci >= cindex + nslots)    // chunk not found
 490     {
 491         SWARNING << "subChunk: chunk "
 492                  << chunk
 493                  << " of class "
 494                  << chunk->getClass()->getName()
 495                  << " not found!"
 496                  << std::endl;
 497         return true;
 498     }
 499
 500     editMField(ChunksFieldMask, _mfChunks);
 501
 502     // remove the chunk from the state
 503
 504     _mfChunks.replace(ci, NULL);
 505
 506     return false;
 507 }
 508
 509
 510 /*! Remove the chunk defined by the class id and the slot index from the State.
 511     Returns false if successful, true if the chunk wasn't found.
 512 */
 513
 514 bool State::subChunk(UInt32 classid, Int32 index)
 515 {
 516     if(index < 0 || index > StateChunkClass::getNumSlots(classid))
 517     {
 518         SWARNING << "subChunk: index " << index << " > Numslots "
 519                  << StateChunkClass::getNumSlots(classid)
 520                  << ",  ignored!" << std::endl;
 521         return true;
 522     }
 523
 524     const State *pThis = this;
 525
 526     if(pThis->_mfChunks[classid + index] == NULL)
 527         return true;
 528
 529     editMField(ChunksFieldMask, _mfChunks);
 530
 531     // remove the chunk from the state
 532
 533     _mfChunks.replace(classid + index, NULL);
 534
 535     return false;
 536 }
 537
 538 /*! Remove all chunks from the state
 539 */
 540
 541 void State::clearChunks(void)
 542 {
 543     editMField(ChunksFieldMask, _mfChunks);
 544
 545     MFChunksType::iterator chunksIt  = _mfChunks.begin_nc();
 546     MFChunksType::iterator chunksEnd = _mfChunks.end_nc  ();
 547
 548     for(; chunksIt != chunksEnd; ++chunksIt)
 549     {
 550         _mfChunks.replace(chunksIt, NULL);
 551     }
 552 }
 553
 554 bool State::isTransparent(void) const
 555 {
 556     Int32 tm = getTransparencyMode();
 557
 558     if(tm != Material::TransparencyAutoDetection)
 559     {
 560         return (tm == Material::TransparencyForceTransparent);
 561     }
 562
 563     bool returnValue = false;
 564
 565     MFChunksType::const_iterator chunksIt  = _mfChunks.begin();
 566     MFChunksType::const_iterator chunksEnd = _mfChunks.end();
 567
 568     for(; chunksIt != chunksEnd && returnValue == false; ++chunksIt)
 569     {
 570         if((*chunksIt) != NULL)
 571             returnValue =(*chunksIt)->isTransparent();
 572     }
 573
 574     return returnValue;
 575 }
 576
 577 /*-------------------------- comparison -----------------------------------*/
 578
 579
 580 /*! Calculate the switch cost for the whole state, which is the sum of the
 581 switch cost of all its chunks. Right now it's always 0.
 582 */
 583
 584 Real32 State::switchCost(State *OSG_CHECK_ARG(state))
 585 {
 586     return 0;
 587 }
 588
 589 bool State::operator < (const State &other) const
 590 {
 591     return this < &other;
 592 }
 593
 594 /*! Compare the two states. Not implemented yet, always false.
 595 */
 596
 597 bool State::operator == (const State &OSG_CHECK_ARG(other)) const
 598 {
 599     return false;
 600 }
 601
 602 bool State::operator != (const State &other) const
 603 {
 604     return ! (*this == other);
 605 }
 606
 607 void State::resolveLinks(void)
 608 {
 609     clearChunks();
 610
 611     Inherited::resolveLinks();
 612 }