Source/System/State/Base/OSGStateOverride.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 #include <cstdlib>
  40 #include <cstdio>
  41
  42 #include "OSGConfig.h"
  43
  44 #include "OSGBaseFunctions.h"
  45 #include "OSGFieldContainer.h"
  46 #include "OSGStateOverride.h"
  47 #include "OSGShaderProgramChunk.h"
  48 #include "OSGShaderProgramVariableChunk.h"
  49 #include "OSGSimpleSHLChunk.h"
  50
  51 OSG_USING_NAMESPACE
  52
  53 /*! \class OSG::StateOverride
  54  */
  55
  56 /*-------------------------------------------------------------------------*/
  57 /*                            Constructors                                 */
  58
  59 StateOverride::StateOverride(void) :
  60     _vChunks       (    ),
  61     _pShader       (NULL),
  62     _pShaderVar    (NULL),
  63     _vProgChunks   (    ),
  64     _vProgIds      (    ),
  65     _vProgVarChunks(    ),
  66     _vProgVarIds   (    ),
  67     _uiSortKey     (   0),
  68     _uiKeyGen      (   0),
  69     _uiKeyMask     (   0)
  70 {
  71 }
  72
  73 /*-------------------------------------------------------------------------*/
  74 /*                             Destructor                                  */
  75
  76 StateOverride::~StateOverride(void)
  77 {
  78 }
  79
  80 void StateOverride::rebuildSortKey(void)
  81 {
  82     OSG_ASSERT(false);
  83 }
  84
  85 void StateOverride::addOverride(UInt32 uiSlot, ShaderProgramChunk *pChunk)
  86 {
  87     if(pChunk == NULL)
  88     {
  89         return;
  90     }
  91
  92     ShaderProgramChunk::MFVertexShaderType::const_iterator sIt  =
  93         pChunk->getMFVertexShader()->begin();
  94
  95     ShaderProgramChunk::MFVertexShaderType::const_iterator sEnd =
  96         pChunk->getMFVertexShader()->end();
  97
  98
  99     for(; sIt != sEnd; ++sIt)
 100     {
 101         UInt16    uiProgId = (*sIt)->getProgramId();
 102
 103         IdStoreIt iIt      = std::lower_bound(_vProgIds.begin(),
 104                                               _vProgIds.end  (),
 105                                                uiProgId        );
 106
 107         if(iIt == _vProgIds.end())
 108         {
 109             _vProgIds.push_back(uiProgId);
 110         }
 111         else if(*iIt != (*sIt)->getProgramId())
 112         {
 113             _vProgIds.insert(iIt, uiProgId);
 114         }
 115     }
 116
 117
 118     sIt  = pChunk->getMFGeometryShader()->begin();
 119     sEnd = pChunk->getMFGeometryShader()->end  ();
 120
 121     for(; sIt != sEnd; ++sIt)
 122     {
 123         UInt16    uiProgId = (*sIt)->getProgramId();
 124
 125         IdStoreIt iIt      = std::lower_bound(_vProgIds.begin(),
 126                                               _vProgIds.end  (),
 127                                                uiProgId        );
 128
 129         if(iIt == _vProgIds.end())
 130         {
 131             _vProgIds.push_back(uiProgId);
 132         }
 133         else if(*iIt != (*sIt)->getProgramId())
 134         {
 135             _vProgIds.insert(iIt, uiProgId);
 136         }
 137     }
 138
 139     sIt  = pChunk->getMFFragmentShader()->begin();
 140     sEnd = pChunk->getMFFragmentShader()->end  ();
 141
 142     for(; sIt != sEnd; ++sIt)
 143     {
 144         UInt16    uiProgId = (*sIt)->getProgramId();
 145
 146         IdStoreIt iIt      = std::lower_bound(_vProgIds.begin(),
 147                                               _vProgIds.end  (),
 148                                                uiProgId        );
 149
 150         if(iIt == _vProgIds.end())
 151         {
 152             _vProgIds.push_back(uiProgId);
 153         }
 154         else if(*iIt != (*sIt)->getProgramId())
 155         {
 156             _vProgIds.insert(iIt, uiProgId);
 157         }
 158     }
 159
 160     _vProgChunks.push_back(pChunk);
 161
 162     _pShader = NULL;
 163 }
 164
 165 void StateOverride::addOverride(UInt32                      uiSlot,
 166                                 ShaderProgramVariableChunk *pChunk)
 167 {
 168     if(pChunk == NULL)
 169     {
 170         return;
 171     }
 172
 173     UInt16    uiVarId = pChunk->getVariableId();
 174
 175     IdStoreIt iIt      = std::lower_bound(_vProgVarIds.begin(),
 176                                           _vProgVarIds.end  (),
 177                                            uiVarId            );
 178
 179     if(iIt == _vProgVarIds.end())
 180     {
 181         _vProgVarIds.push_back(uiVarId);
 182     }
 183     else if(*iIt != uiVarId)
 184     {
 185         _vProgVarIds.insert(iIt, uiVarId);
 186     }
 187
 188     _vProgVarChunks.push_back(pChunk);
 189
 190     _pShaderVar = NULL;
 191 }
 192
 193 void StateOverride::addOverride(UInt32          uiSlot,
 194                                 SimpleSHLChunk *pChunk)
 195 {
 196     insertOverride(uiSlot, pChunk);
 197 }
 198
 199 void StateOverride::insertOverride(UInt32      uiSlot,
 200                                    StateChunk *pChunk)
 201 {
 202     ChunkElement newElem(uiSlot, pChunk);
 203
 204     ChunkStoreIt cIt = std::lower_bound(_vChunks.begin(),
 205                                         _vChunks.end  (),
 206                                          newElem        );
 207
 208     if(cIt == _vChunks.end())
 209     {
 210         _vChunks.insert(cIt, newElem);
 211     }
 212     else
 213     {
 214         if(cIt->first == uiSlot)
 215         {
 216             cIt->second = pChunk;
 217         }
 218         else
 219         {
 220             _vChunks.insert(cIt, newElem);
 221         }
 222     }
 223
 224     if(pChunk == NULL)
 225     {
 226         return;
 227     }
 228
 229     UInt32 uiKey1 =  _uiKeyGen & Key1Mask;
 230     UInt32 uiKey2 = (_uiKeyGen & Key2Mask) >> 10;
 231     UInt32 uiKey3 = (_uiKeyGen & Key3Mask) >> 20;
 232
 233     if(uiKey1 != InvalidKey && uiKey1 == uiSlot)
 234     {
 235         uiKey1 =
 236             (pChunk->getIgnore() == false) ? pChunk->getChunkId() : 0;
 237
 238         _uiKeyMask &= ~Key1Mask;
 239     }
 240     else
 241     {
 242         uiKey1 = 0;
 243     }
 244
 245     if(uiKey2 != InvalidKey && uiKey2 == uiSlot)
 246     {
 247         uiKey2 =
 248             (pChunk->getIgnore() == false) ? pChunk->getChunkId() : 0;
 249
 250         _uiKeyMask &= ~Key2Mask;
 251     }
 252     else
 253     {
 254         uiKey2 = 0;
 255     }
 256
 257     if(uiKey3 != InvalidKey && uiKey3 == uiSlot)
 258     {
 259         uiKey3 =
 260             (pChunk->getIgnore() == false) ? pChunk->getChunkId() : 0;
 261
 262         _uiKeyMask &= ~Key3Mask;
 263     }
 264     else
 265     {
 266         uiKey3 = 0;
 267     }
 268
 269     _uiSortKey =
 270         (uiKey1 & Key1Mask)        |
 271         ((uiKey2 & Key1Mask) << 10) |
 272         ((uiKey3 & Key1Mask) << 20);
 273 }
 274
 275 void StateOverride::addOverride(UInt32 uiSlot, StateChunk *pChunk)
 276 {
 277     ShaderProgramChunk *pSPChunk = dynamic_cast<ShaderProgramChunk *>(pChunk);
 278
 279     if(pSPChunk == NULL)
 280     {
 281         ShaderProgramVariableChunk *pSPVChunk =
 282             dynamic_cast<ShaderProgramVariableChunk *>(pChunk);
 283
 284         if(pSPVChunk == NULL)
 285         {
 286             insertOverride(uiSlot, pChunk);
 287         }
 288         else
 289         {
 290             this->addOverride(uiSlot, pSPVChunk);
 291         }
 292     }
 293     else
 294     {
 295         this->addOverride(uiSlot, pSPChunk);
 296     }
 297 }
 298
 299 void StateOverride::subOverride(UInt32 uiSlot, ShaderProgramChunk *pChunk)
 300 {
 301     if(pChunk == NULL)
 302     {
 303         return;
 304     }
 305
 306     ShaderProgramChunk::MFVertexShaderType::const_iterator sIt  =
 307         pChunk->getMFVertexShader()->begin();
 308
 309     ShaderProgramChunk::MFVertexShaderType::const_iterator sEnd =
 310         pChunk->getMFVertexShader()->end();
 311
 312
 313     for(; sIt != sEnd; ++sIt)
 314     {
 315         UInt16    uiProgId = (*sIt)->getProgramId();
 316
 317         std::pair<IdStoreIt, IdStoreIt> pairIt
 318             = std::equal_range(_vProgIds.begin(),
 319                                _vProgIds.end  (),
 320                                uiProgId         );
 321
 322         if(pairIt.first != pairIt.second)
 323         {
 324             _vProgIds.erase(pairIt.first);
 325         }
 326     }
 327
 328     sIt  = pChunk->getMFGeometryShader()->begin();
 329     sEnd = pChunk->getMFGeometryShader()->end  ();
 330
 331     for(; sIt != sEnd; ++sIt)
 332     {
 333         UInt16    uiProgId = (*sIt)->getProgramId();
 334
 335         std::pair<IdStoreIt, IdStoreIt> pairIt
 336             = std::equal_range(_vProgIds.begin(),
 337                                _vProgIds.end  (),
 338                                uiProgId         );
 339
 340         if(pairIt.first != pairIt.second)
 341         {
 342             _vProgIds.erase(pairIt.first);
 343         }
 344     }
 345
 346     sIt  = pChunk->getMFFragmentShader()->begin();
 347     sEnd = pChunk->getMFFragmentShader()->end  ();
 348
 349     for(; sIt != sEnd; ++sIt)
 350     {
 351         UInt16    uiProgId = (*sIt)->getProgramId();
 352
 353         std::pair<IdStoreIt, IdStoreIt> pairIt
 354             = std::equal_range(_vProgIds.begin(),
 355                                _vProgIds.end  (),
 356                                uiProgId         );
 357
 358         if(pairIt.first != pairIt.second)
 359         {
 360             _vProgIds.erase(pairIt.first);
 361         }
 362     }
 363
 364     ProgramChunkStore::iterator sIt2
 365         = std::find(_vProgChunks.begin(), _vProgChunks.end(), pChunk);
 366
 367     if(sIt2 != _vProgChunks.end())
 368         _vProgChunks.erase(sIt2);
 369 }
 370
 371 void StateOverride::subOverride(UInt32                      uiSlot,
 372                                 ShaderProgramVariableChunk *pChunk)
 373 {
 374     if(pChunk == NULL)
 375     {
 376         return;
 377     }
 378
 379     UInt16    uiVarId = pChunk->getVariableId();
 380
 381     std::pair<IdStoreIt, IdStoreIt> pairIt
 382             = std::equal_range(_vProgVarIds.begin(),
 383                                _vProgVarIds.end  (),
 384                                uiVarId             );
 385
 386     if(pairIt.first != pairIt.second)
 387     {
 388         _vProgVarIds.erase(pairIt.first);
 389     }
 390
 391     ProgramVarChunkStore::iterator sIt2
 392         = std::find(_vProgVarChunks.begin(), _vProgVarChunks.end(), pChunk);
 393
 394     if(sIt2 != _vProgVarChunks.end())
 395         _vProgVarChunks.erase(sIt2);
 396 }
 397
 398 void StateOverride::subOverride(UInt32          uiSlot,
 399                                 SimpleSHLChunk *pChunk)
 400 {
 401     eraseOverride(uiSlot, pChunk);
 402 }
 403
 404 void StateOverride::eraseOverride(UInt32      uiSlot,
 405                                   StateChunk *pChunk)
 406 {
 407     ChunkElement newElem(uiSlot, pChunk);
 408
 409     std::pair<ChunkStoreIt, ChunkStoreIt> pairIt
 410         = std::equal_range(_vChunks.begin(),
 411                            _vChunks.end  (),
 412                             newElem        );
 413
 414     for(; pairIt.first != pairIt.second; ++pairIt.first)
 415     {
 416         if(pairIt.first->first == uiSlot)
 417         {
 418             _vChunks.erase(pairIt.first);
 419             break;
 420         }
 421     }
 422 }
 423
 424 void StateOverride::subOverride(UInt32 uiSlot, StateChunk *pChunk)
 425 {
 426     ShaderProgramChunk *pSPChunk = dynamic_cast<ShaderProgramChunk *>(pChunk);
 427
 428     if(pSPChunk == NULL)
 429     {
 430         ShaderProgramVariableChunk *pSPVChunk =
 431             dynamic_cast<ShaderProgramVariableChunk *>(pChunk);
 432
 433         if(pSPVChunk == NULL)
 434         {
 435             eraseOverride(uiSlot, pChunk);
 436         }
 437         else
 438         {
 439             this->subOverride(uiSlot, pSPVChunk);
 440         }
 441     }
 442     else
 443     {
 444         this->subOverride(uiSlot, pSPChunk);
 445     }
 446 }