Source/System/Material/Base/OSGChunkMaterial.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 "OSGState.h"
  51 #include "OSGMaterialDrawable.h"
  52
  53 #include "OSGChunkMaterial.h"
  54 #include "OSGChunkBlock.h"
  55
  56 OSG_USING_NAMESPACE
  57
  58 // Documentation for this class is emited in the
  59 // OSGChunkMaterialBase.cpp file.
  60 // To modify it, please change the .fcd file (OSGChunkMaterial.fcd) and
  61 // regenerate the base file.
  62
  63 /***************************************************************************\
  64  *                           Class methods                                 *
  65 \***************************************************************************/
  66
  67 /*-------------------------------------------------------------------------*\
  68  -  private                                                                -
  69 \*-------------------------------------------------------------------------*/
  70
  71 void ChunkMaterial::initMethod(InitPhase ePhase)
  72 {
  73     Inherited::initMethod(ePhase);
  74 }
  75
  76 /***************************************************************************\
  77  *                           Instance methods                              *
  78 \***************************************************************************/
  79
  80 /*------------- constructors & destructors --------------------------------*/
  81
  82 ChunkMaterial::ChunkMaterial(void) :
  83     Inherited()
  84 {
  85 }
  86
  87 ChunkMaterial::ChunkMaterial(const ChunkMaterial &source) :
  88     Inherited(source)
  89 {
  90 }
  91
  92 ChunkMaterial::~ChunkMaterial(void)
  93 {
  94 }
  95
  96 void ChunkMaterial::pushToChunks(StateChunk * const value)
  97 {
  98     if(value == NULL)
  99         return;
 100
 101     editMField(ChunksFieldMask, _mfChunks);
 102
 103     _mfChunks.push_back(value);
 104 }
 105
 106 #if 0
 107 void ChunkMaterial::assignChunks   (const MFUnrecStateChunkPtr &value)
 108 {
 109     MFUnrecStateChunkPtr::const_iterator elemIt  =
 110         value.begin();
 111     MFUnrecStateChunkPtr::const_iterator elemEnd =
 112         value.end  ();
 113
 114     static_cast<ChunkMaterial *>(this)->clearChunks();
 115
 116     while(elemIt != elemEnd)
 117     {
 118         this->pushToChunks(*elemIt);
 119
 120         ++elemIt;
 121     }
 122 }
 123 #endif
 124
 125 void ChunkMaterial::removeFromChunks(UInt32 uiIndex)
 126 {
 127     if(uiIndex < _mfChunks.size())
 128     {
 129         editMField(ChunksFieldMask, _mfChunks);
 130
 131 /*
 132         MFUnrecStateChunkPtr::iterator fieldIt = _mfChunks.begin_nc();
 133
 134         fieldIt += uiIndex;
 135  */
 136
 137         _mfChunks.erase(uiIndex);
 138
 139         if(uiIndex < _mfSlots.size())
 140         {
 141             editMField(SlotsFieldMask,  _mfSlots );
 142
 143             MFInt32::iterator slotIt  = _mfSlots.begin();
 144
 145             slotIt  += uiIndex;
 146
 147             _mfSlots.erase(slotIt);
 148         }
 149     }
 150 }
 151
 152 void ChunkMaterial::removeFromChunksByObj(StateChunk * const value)
 153 {
 154     Int32 iElemIdx = _mfChunks.findIndex(value);
 155
 156     if(iElemIdx != -1)
 157     {
 158         editMField(ChunksFieldMask, _mfChunks);
 159
 160 /*
 161         MFUnrecStateChunkPtr::iterator fieldIt = _mfChunks.begin_nc();
 162
 163         fieldIt += iElemIdx;
 164  */
 165
 166         _mfChunks.erase(iElemIdx);
 167
 168         if(iElemIdx < Int32(_mfSlots.size()))
 169         {
 170             editMField(SlotsFieldMask,  _mfSlots );
 171
 172             MFInt32::iterator slotIt  = _mfSlots.begin();
 173
 174             slotIt  += iElemIdx;
 175
 176             _mfSlots.erase(slotIt);
 177         }
 178     }
 179 }
 180
 181 void ChunkMaterial::replaceChunk(UInt32                       uiIndex,
 182                                  StateChunk           * const value  )
 183 {
 184     if(uiIndex < _mfChunks.size() && value != NULL)
 185     {
 186         editMField(ChunksFieldMask, _mfChunks);
 187
 188         _mfChunks.replace(uiIndex, value);
 189     }
 190 }
 191
 192
 193 void ChunkMaterial::changed(ConstFieldMaskArg whichField,
 194                             UInt32            origin,
 195                             BitVector         details)
 196 {
 197     Inherited::changed(whichField, origin, details);
 198 }
 199
 200
 201 /*-------------------------- your_category---------------------------------*/
 202
 203 /*! Add the given chunk to the material. It is possible to specify
 204   which slot this chunk should be associated with. See \ref StateChunkClass
 205   for a general description of the slots concept. The default slot is
 206   State::AutoSlotReplace.
 207  */
 208
 209 bool ChunkMaterial::addChunk(StateChunk *chunk, Int32 slot)
 210 {
 211     if(chunk == NULL)
 212         return false;
 213
 214     if(slot != State::AutoSlotReplace)
 215     {
 216         editMField(SlotsFieldMask, _mfSlots);
 217
 218         while(_mfSlots.size() < _mfChunks.size())
 219             _mfSlots.push_back(State::AutoSlotReplace);
 220     }
 221
 222     editMField(ChunksFieldMask, _mfChunks);
 223
 224     _mfChunks.push_back(chunk);
 225
 226     if(slot != State::AutoSlotReplace)
 227     {
 228         editMField(SlotsFieldMask, _mfSlots);
 229
 230         _mfSlots.push_back(slot);
 231     }
 232
 233     return true;
 234 }
 235
 236 /*! Remove the given chunk from the material. If the slot is not
 237 State::AutoSlotReplace, only the given slot will be searched and
 238 removed if found. Returns true if the chunk couldn't be found. */
 239
 240 bool ChunkMaterial::subChunk(StateChunk *chunk, Int32 slot)
 241 {
 242     UInt32 i;
 243
 244     const ChunkMaterial *pThis = this;
 245
 246     for(i = 0; i < _mfChunks.size(); ++i)
 247     {
 248         if(pThis->_mfChunks[i] == chunk &&
 249            ((i < _mfSlots.size() && pThis->_mfSlots[i] == slot) ||
 250             slot == State::AutoSlotReplace))
 251         {
 252             editMField(ChunksFieldMask, _mfChunks);
 253
 254             _mfChunks.erase(i);
 255
 256             if(i < _mfSlots.size())
 257             {
 258                 editMField(SlotsFieldMask, _mfSlots);
 259
 260                 _mfSlots.erase(_mfSlots.begin() + i);
 261             }
 262
 263             return false;
 264         }
 265     }
 266
 267     SWARNING << "ChunkMaterial::subChunk(" << this << ") has no chunk "
 268              << chunk << " with slot " << slot << std::endl;
 269
 270     return true;
 271 }
 272
 273 /*! Add the given chunk to the material at a certain index. It is possible to
 274     specify which slot this chunk should be associated with.
 275     See \ref StateChunkClass for a general description of the slots concept.
 276     The default slot is State::AutoSlotReplace. */
 277
 278 bool ChunkMaterial::insertChunk(StateChunk *chunk, UInt32 chunkIndex, Int32 slot)
 279 {
 280     if(chunk == NULL)
 281         return false;
 282
 283     // push back chunk
 284     if(chunkIndex >= _mfChunks.size())
 285         return addChunk(chunk, slot);
 286
 287     if(slot != State::AutoSlotReplace)
 288     {
 289         editMField(SlotsFieldMask, _mfSlots);
 290
 291         while(_mfSlots.size() < chunkIndex+1)
 292             _mfSlots.push_back(State::AutoSlotReplace);
 293
 294         _mfSlots.insert(_mfSlots.begin()+chunkIndex, slot);
 295     }
 296     else
 297     {
 298         if(_mfSlots.size() > chunkIndex)
 299         {
 300             editMField(SlotsFieldMask, _mfSlots);
 301
 302             _mfSlots.insert(_mfSlots.begin()+chunkIndex, slot);
 303         }
 304     }
 305
 306     editMField(ChunksFieldMask, _mfChunks);
 307
 308     _mfChunks.insert(_mfChunks.begin_nc() + chunkIndex, chunk);
 309
 310     return true;
 311 }
 312
 313 /*! Retrieve slot information from the given chunk. Returns false if the
 314     chunk couldn't be found. */
 315
 316 bool ChunkMaterial::getChunkSlot(StateChunk *chunk, Int32 &slot) const
 317 {
 318     if(chunk == NULL)
 319         return false;
 320
 321     Int32 chunkIndex = this->find(chunk);
 322
 323     if(chunkIndex < 0)
 324         return false;
 325
 326     if(Int32(_mfSlots.size()) <= chunkIndex)
 327         slot = State::AutoSlotReplace;
 328     else
 329         slot = _mfSlots[chunkIndex];
 330
 331     return true;
 332 }
 333
 334 /*! Update slot information for the given chunk. Returns false if the
 335     chunk couldn't be found. */
 336
 337 bool ChunkMaterial::setChunkSlot(StateChunk *chunk, Int32 slot)
 338 {
 339     if(chunk == NULL)
 340         return false;
 341
 342     Int32 chunkIndex = this->find(chunk);
 343
 344     if(chunkIndex < 0)
 345         return false;
 346
 347     editMField(SlotsFieldMask, _mfSlots);
 348
 349     while(Int32(_mfSlots.size()) <= chunkIndex)
 350         _mfSlots.push_back(State::AutoSlotReplace);
 351
 352     _mfSlots[chunkIndex] = slot;
 353
 354     return true;
 355 }
 356
 357 /*! Search the list of chunks for the given chunk. Returns its index, -1
 358   if the chunk is not used in the material.
 359 */
 360
 361 Int32 ChunkMaterial::find(StateChunk *chunk) const
 362 {
 363     UInt32 i;
 364
 365     for(i = 0; i < _mfChunks.size(); ++i)
 366     {
 367         if(_mfChunks[i] == chunk)
 368             return i;
 369     }
 370
 371     return -1;
 372 }
 373
 374 /*! Search the list of chunks for a chunk of the given type and the given
 375   slot. If slot is State::AutoSlotReplace, all slots are searched and the
 376   first found chunk is returned.
 377   For searching a specific chunk with a AutoSlotReplace slot,
 378   the slot parameter is interpreted as a index.
 379  */
 380
 381 StateChunk *ChunkMaterial::find(const FieldContainerType &type,
 382                                       Int32               slot) const
 383 {
 384     UInt32 index = 0;
 385
 386     for(UInt32 i = 0; i < _mfChunks.size(); ++i)
 387     {
 388         StateChunk *p = _mfChunks[i];
 389
 390         Int32 s = State::AutoSlotReplace;
 391
 392         if(i < getMFSlots()->size())
 393             s = getSlots(i);
 394
 395         if(s == State::AutoSlotReplace)
 396             s = index;
 397
 398         if(p->getType() == type)
 399         {
 400             if(slot == State::AutoSlotReplace || slot == s)
 401                 return (p);
 402
 403             ++index;
 404         }
 405     }
 406
 407     return NULL;
 408 }
 409
 410 #if 0
 411 bool ChunkMaterial::operator==(const ChunkMaterial &other) const
 412 {
 413     return Inherited::operator==(other);
 414 }
 415 #endif
 416
 417 void ChunkMaterial::clearChunks(void)
 418 {
 419     editMField(ChunksFieldMask, _mfChunks);
 420     editMField(SlotsFieldMask,  _mfSlots );
 421
 422     _mfChunks.clear();
 423     _mfSlots .clear();
 424 }
 425
 426 void ChunkMaterial::fill(ChunkBlock *pBlock)
 427 {
 428     if(pBlock == NULL)
 429         return;
 430
 431     pBlock->clearChunks();
 432
 433     const MFUnrecStateChunkPtr *chunks = this->getMFChunks();
 434     const MFInt32              *slots  = this->getMFSlots ();
 435
 436     for(SizeT i = 0; i < chunks->size(); ++i)
 437     {
 438         int slot = i < slots->size() ?
 439             (*slots)[i] :
 440             State::AutoSlotReplace;
 441
 442         StateChunk *chunk = (*chunks)[i];
 443
 444         if(chunk != NULL)
 445             pBlock->addChunk(chunk, slot);
 446     }
 447
 448 }
 449
 450 /*! Add chunks to the given state. Needed for ordering in the drived
 451   materials.
 452 */
 453
 454 void ChunkMaterial::addChunks(State *state) const
 455 {
 456     UInt32 i;
 457
 458     for(i = 0; i < _mfChunks.size(); ++i)
 459     {
 460         state->addChunk(_mfChunks[i],
 461                         (i < _mfSlots.size()) ? _mfSlots[i]
 462                                                 : State::AutoSlotReplace);
 463     }
 464 }
 465
 466 /*! Rebuild the internal State. Just collects the chunks in the State.
 467  */
 468
 469 void ChunkMaterial::rebuildState(void)
 470 {
 471     FDEBUG(("ChunkMat::rebuild state\n"));
 472
 473     if(_pState != NULL)
 474     {
 475         _pState->clearChunks();
 476     }
 477     else
 478     {
 479         _pState = State::createLocal();
 480
 481         _pState->setDefaultSortKey(this->getId());
 482
 483     }
 484
 485     _pState->setCoreGLChunkLimit(_sfCoreGLChunkLimit.getValue());
 486     _pState->setTransparencyMode(_sfTransparencyMode.getValue());
 487
 488     addChunks(_pState);
 489 }
 490
 491 /*! Check if the Material (i.e. any of its chunks) is transparent..
 492  */
 493
 494 bool ChunkMaterial::isTransparent(void) const
 495 {
 496     Int32 tm = getTransparencyMode();
 497
 498     if(tm != Material::TransparencyAutoDetection)
 499     {
 500         return (tm == Material::TransparencyForceTransparent);
 501     }
 502
 503     bool             returnValue = false;
 504
 505     MFChunksType::const_iterator chunksIt  = _mfChunks.begin();
 506     MFChunksType::const_iterator chunksEnd = _mfChunks.end  ();
 507
 508     for(; chunksIt != chunksEnd && returnValue == false; ++chunksIt)
 509     {
 510         returnValue = (*chunksIt)->isTransparent();
 511     }
 512
 513     return returnValue;
 514 }
 515
 516 /*------------------------------- dump ----------------------------------*/
 517
 518 void ChunkMaterial::dump(      UInt32    OSG_CHECK_ARG(uiIndent),
 519                          const BitVector OSG_CHECK_ARG(bvFlags )) const
 520 {
 521     SLOG << "ChunkMaterial at " << this << std::endl;
 522     SLOG << "Chunks: " << std::endl;
 523
 524     UInt32 i;
 525
 526     for(i = 0; i < _mfChunks.size(); ++i)
 527     {
 528         SLOG << _mfChunks[i] << " "
 529              << static_cast<Int32>((i < _mfSlots.size())
 530                                    ? _mfSlots[i]
 531                                    :   State::AutoSlotReplace)
 532              << std::endl;
 533     }
 534 }