Source/System/State/Shader/Chunks/OSGShaderProgramVariableChunk.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 "OSGShaderProgramVariableChunk.h"
  49
  50 #include "OSGShaderVariables.h"
  51
  52 OSG_BEGIN_NAMESPACE
  53
  54 // Documentation for this class is emitted in the
  55 // OSGShaderProgramVariableChunkBase.cpp file.
  56 // To modify it, please change the .fcd file
  57 // (OSGShaderProgramVariableChunk.fcd) and regenerate the base file.
  58
  59 /***************************************************************************\
  60  *                           Class variables                               *
  61 \***************************************************************************/
  62
  63 StateChunkClass ShaderProgramVariableChunk::_class("ShaderProgramVariable",
  64                                                    1,
  65                                                    5);
  66
  67 volatile UInt16 ShaderProgramVariableChunk::_uiChunkCounter = 1;
  68
  69 ShaderProgramVariableChunk::VarIdPool *
  70     ShaderProgramVariableChunk::_pVarIdPool = NULL;
  71
  72 template<> inline
  73 void SimpleReusePool<Int32,
  74                      ShaderProgramVariableChunk::VariableIdPoolTag,
  75                      SingleLockPolicy                >::initializeValue(void)
  76 {
  77     _currentValue = 1;
  78 }
  79
  80 /***************************************************************************\
  81  *                           Class methods                                 *
  82 \***************************************************************************/
  83
  84 void ShaderProgramVariableChunk::initMethod(InitPhase ePhase)
  85 {
  86     Inherited::initMethod(ePhase);
  87
  88     if(ePhase == TypeObject::SystemPost)
  89     {
  90     }
  91 }
  92
  93
  94 /***************************************************************************\
  95  *                           Instance methods                              *
  96 \***************************************************************************/
  97
  98 /*-------------------------------------------------------------------------*\
  99  -  private                                                                 -
 100 \*-------------------------------------------------------------------------*/
 101
 102 /*----------------------- constructors & destructors ----------------------*/
 103
 104 ShaderProgramVariableChunk::ShaderProgramVariableChunk(void) :
 105      Inherited( ),
 106     _uiVarId  (0),
 107     _uiChunkId(0)
 108 {
 109 }
 110
 111 ShaderProgramVariableChunk::ShaderProgramVariableChunk(
 112     const ShaderProgramVariableChunk &source) :
 113
 114      Inherited(source),
 115     _uiVarId  (0     ),
 116     _uiChunkId(0     )
 117 {
 118 }
 119
 120 ShaderProgramVariableChunk::~ShaderProgramVariableChunk(void)
 121 {
 122 }
 123
 124 void ShaderProgramVariableChunk::onCreate(
 125     const ShaderProgramVariableChunk *source)
 126 {
 127     Inherited::onCreate(source);
 128
 129     if(GlobalSystemState == Startup)
 130     {
 131         _pVarIdPool = new VarIdPool;
 132
 133         return;
 134     }
 135
 136     _uiChunkId = _uiChunkCounter++;
 137     _uiVarId   = _pVarIdPool->create();
 138
 139     markFieldsClusterLocal(ParentsFieldMask);
 140 }
 141
 142 void ShaderProgramVariableChunk::onCreateAspect(
 143     const ShaderProgramVariableChunk *createAspect,
 144     const ShaderProgramVariableChunk *source      )
 145 {
 146     Inherited::onCreateAspect(createAspect, source);
 147
 148     _uiChunkId = createAspect->_uiChunkId;
 149     _uiVarId   = createAspect->_uiVarId;
 150
 151     markFieldsClusterLocal(ParentsFieldMask);
 152 }
 153
 154 void ShaderProgramVariableChunk::onDestroy(UInt32 uiId)
 155 {
 156     Inherited::onDestroy(uiId);
 157
 158     if(GlobalSystemState == OSG::Running)
 159     {
 160         _pVarIdPool->release(_uiVarId);
 161     }
 162     else if(GlobalSystemState == OSG::Shutdown)
 163     {
 164         delete _pVarIdPool;
 165
 166         _pVarIdPool = NULL;
 167     }
 168 }
 169
 170 const StateChunkClass *ShaderProgramVariableChunk::getClass(void) const
 171 {
 172     return &_class;
 173 }
 174
 175 UInt16 ShaderProgramVariableChunk::getChunkId(void)
 176 {
 177     return _uiChunkId;
 178 }
 179
 180 /*----------------------------- class specific ----------------------------*/
 181
 182 void ShaderProgramVariableChunk::changed(ConstFieldMaskArg whichField,
 183                                          UInt32            origin,
 184                                          BitVector         details)
 185 {
 186     if(0x0000 != (whichField & VariablesFieldMask))
 187     {
 188         ShaderProgramVariables *pVars = _sfVariables.getValue();
 189
 190         if(pVars != NULL)
 191         {
 192             if(details == 0x0001)
 193             {
 194                 MFParentFieldContainerPtr::const_iterator parentsIt  =
 195                     this->_mfParents.begin();
 196
 197                 MFParentFieldContainerPtr::const_iterator parentsEnd =
 198                     this->_mfParents.end();
 199
 200                 for(; parentsIt != parentsEnd; ++parentsIt)
 201                 {
 202                     (*parentsIt)->changed(
 203                         TypeTraits<BitVector>::One <<
 204                                                parentsIt.getParentFieldPos(),
 205                         ChangedOrigin::Child,
 206                         VariablesFieldMask);
 207
 208                 }
 209             }
 210         }
 211     }
 212
 213     Inherited::changed(whichField, origin, details);
 214 }
 215
 216
 217 void ShaderProgramVariableChunk::addParent(
 218     FieldContainer * const pParent,
 219     UInt16                 uiParentFieldId)
 220 {
 221     editMField(ParentsFieldMask, _mfParents);
 222
 223     OSG_ASSERT(pParent != NULL);
 224
 225     _mfParents.push_back(pParent, uiParentFieldId);
 226 }
 227
 228 void ShaderProgramVariableChunk::subParent(FieldContainer * const pParent)
 229 {
 230     Int32 iParentIdx = _mfParents.findIndex(pParent);
 231
 232     if(iParentIdx != -1)
 233     {
 234         editMField(ParentsFieldMask, _mfParents);
 235
 236         _mfParents.erase(iParentIdx);
 237     }
 238 }
 239
 240 void ShaderProgramVariableChunk::dump(      UInt32    ,
 241                                       const BitVector ) const
 242 {
 243     SLOG << "Dump ShaderProgramVariableChunk NI" << std::endl;
 244 }
 245
 246 bool ShaderProgramVariableChunk::subUniformVariable(const Char8 *name)
 247 {
 248     if(_sfVariables.getValue() != NULL)
 249     {
 250         return _sfVariables.getValue()->subUniformVariable(name, NULL, NULL);
 251     }
 252     else
 253     {
 254         return false;
 255     }
 256 }
 257
 258 bool ShaderProgramVariableChunk::subUniformBlock(const Char8 *name)
 259 {
 260     if(_sfVariables.getValue() != NULL)
 261     {
 262         return _sfVariables.getValue()->subUniformBlock(name, NULL, NULL);
 263     }
 264     else
 265     {
 266         return false;
 267     }
 268 }
 269
 270 bool ShaderProgramVariableChunk::subShaderStorageBlock(const Char8 *name)
 271 {
 272     if(_sfVariables.getValue() != NULL)
 273     {
 274         return _sfVariables.getValue()->subShaderStorageBlock(name, NULL, NULL);
 275     }
 276     else
 277     {
 278         return false;
 279     }
 280 }
 281
 282 void ShaderProgramVariableChunk::clearUniformVariables(void)
 283 {
 284     if(_sfVariables.getValue() == NULL)
 285     {
 286         _sfVariables.getValue()->clearUniformVariables();
 287     }
 288 }
 289
 290 void ShaderProgramVariableChunk::activate(DrawEnv *pEnv, UInt32)
 291 {
 292     SFATAL << "ShaderProgramVariableChunk::activate" << std::endl;
 293 }
 294
 295 void ShaderProgramVariableChunk::changeFrom(DrawEnv    *pEnv,
 296                                             StateChunk *pOther,
 297                                             UInt32            )
 298 {
 299     SFATAL << "ShaderProgramVariableChunk::changeFrom" << std::endl;
 300 }
 301
 302 void ShaderProgramVariableChunk::deactivate(DrawEnv*, UInt32)
 303 {
 304     SFATAL << "ShaderProgramVariableChunk::deactivate" << std::endl;
 305 }
 306
 307 void ShaderProgramVariableChunk::resolveLinks(void)
 308 {
 309     MFChangedFunctorCallback::iterator       cfIt =
 310         _mfDestroyedFunctors.begin();
 311     MFChangedFunctorCallback::const_iterator cfEnd=
 312         _mfDestroyedFunctors.end();
 313
 314     for(; cfIt != cfEnd; ++cfIt)
 315     {
 316         if(cfIt->_func)
 317             (cfIt->_func)(this, 0x0000, ChangedOrigin::External);
 318     }
 319
 320     clearDestroyedFunctors();
 321
 322     Inherited::resolveLinks();
 323 }
 324
 325 OSG_END_NAMESPACE