Source/System/State/Shader/Chunks/OSGShaderProgramChunkBase.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *               Copyright (C) 2000-2013 by the OpenSG Forum                 *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  * contact: dirk@opensg.org, gerrit.voss@vossg.org, carsten_neumann@gmx.net  *
  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  *****************************************************************************
  41  **                                                                         **
  42  **                  This file is automatically generated.                  **
  43  **                                                                         **
  44  **          Any changes made to this file WILL be lost when it is          **
  45  **           regenerated, which can become necessary at any time.          **
  46  **                                                                         **
  47  **     Do not change this file, changes should be done in the derived      **
  48  **     class ShaderProgramChunk!
  49  **                                                                         **
  50  *****************************************************************************
  51 \*****************************************************************************/
  52
  53 #include <cstdlib>
  54 #include <cstdio>
  55
  56 #ifdef WIN32
  57 #pragma warning(disable: 4355) // turn off 'this' : used in base member initializer list warning
  58 #pragma warning(disable: 4290) // disable exception specification warning
  59 #endif
  60
  61 #include "OSGConfig.h"
  62
  63
  64 #include "OSGGL.h"                        // GeometryInputType default header
  65 #include "OSGGL.h"                        // GeometryOutputType default header
  66
  67 #include "OSGShaderProgram.h"           // VertexShader Class
  68
  69 #include "OSGShaderProgramChunkBase.h"
  70 #include "OSGShaderProgramChunk.h"
  71
  72 #include <boost/bind.hpp>
  73
  74 OSG_BEGIN_NAMESPACE
  75
  76 /***************************************************************************\
  77  *                            Description                                  *
  78 \***************************************************************************/
  79
  80 /*! \class OSG::ShaderProgramChunk
  81
  82  */
  83
  84 /***************************************************************************\
  85  *                        Field Documentation                              *
  86 \***************************************************************************/
  87
  88 /*! \var ShaderProgram * ShaderProgramChunkBase::_mfVertexShader
  89     fragment program object
  90 */
  91
  92 /*! \var ShaderProgram * ShaderProgramChunkBase::_mfTessControlShader
  93     fragment program object
  94 */
  95
  96 /*! \var ShaderProgram * ShaderProgramChunkBase::_mfTessEvaluationShader
  97     fragment program object
  98 */
  99
 100 /*! \var ShaderProgram * ShaderProgramChunkBase::_mfGeometryShader
 101     fragment program object
 102 */
 103
 104 /*! \var ShaderProgram * ShaderProgramChunkBase::_mfFragmentShader
 105     fragment program object
 106 */
 107
 108 /*! \var UInt32          ShaderProgramChunkBase::_sfGeometryVerticesOut
 109
 110 */
 111
 112 /*! \var GLenum          ShaderProgramChunkBase::_sfGeometryInputType
 113
 114 */
 115
 116 /*! \var GLenum          ShaderProgramChunkBase::_sfGeometryOutputType
 117
 118 */
 119
 120
 121 /***************************************************************************\
 122  *                      FieldType/FieldTrait Instantiation                 *
 123 \***************************************************************************/
 124
 125 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
 126 PointerType FieldTraits<ShaderProgramChunk *, nsOSG>::_type(
 127     "ShaderProgramChunkPtr",
 128     "StateChunkPtr",
 129     ShaderProgramChunk::getClassType(),
 130     nsOSG);
 131 #endif
 132
 133 OSG_FIELDTRAITS_GETTYPE_NS(ShaderProgramChunk *, nsOSG)
 134
 135 OSG_EXPORT_PTR_SFIELD_FULL(PointerSField,
 136                            ShaderProgramChunk *,
 137                            nsOSG)
 138
 139 OSG_EXPORT_PTR_MFIELD_FULL(PointerMField,
 140                            ShaderProgramChunk *,
 141                            nsOSG)
 142
 143 /***************************************************************************\
 144  *                         Field Description                               *
 145 \***************************************************************************/
 146
 147 void ShaderProgramChunkBase::classDescInserter(TypeObject &oType)
 148 {
 149     FieldDescriptionBase *pDesc = NULL;
 150
 151
 152     pDesc = new MFUnrecShaderProgramPtr::Description(
 153         MFUnrecShaderProgramPtr::getClassType(),
 154         "vertexShader",
 155         "fragment program object\n",
 156         VertexShaderFieldId, VertexShaderFieldMask,
 157         false,
 158         (Field::MFDefaultFlags | Field::FStdAccess),
 159         static_cast<FieldEditMethodSig>(&ShaderProgramChunk::editHandleVertexShader),
 160         static_cast<FieldGetMethodSig >(&ShaderProgramChunk::getHandleVertexShader));
 161
 162     oType.addInitialDesc(pDesc);
 163
 164     pDesc = new MFUnrecShaderProgramPtr::Description(
 165         MFUnrecShaderProgramPtr::getClassType(),
 166         "tessControlShader",
 167         "fragment program object\n",
 168         TessControlShaderFieldId, TessControlShaderFieldMask,
 169         false,
 170         (Field::MFDefaultFlags | Field::FStdAccess),
 171         static_cast<FieldEditMethodSig>(&ShaderProgramChunk::editHandleTessControlShader),
 172         static_cast<FieldGetMethodSig >(&ShaderProgramChunk::getHandleTessControlShader));
 173
 174     oType.addInitialDesc(pDesc);
 175
 176     pDesc = new MFUnrecShaderProgramPtr::Description(
 177         MFUnrecShaderProgramPtr::getClassType(),
 178         "tessEvaluationShader",
 179         "fragment program object\n",
 180         TessEvaluationShaderFieldId, TessEvaluationShaderFieldMask,
 181         false,
 182         (Field::MFDefaultFlags | Field::FStdAccess),
 183         static_cast<FieldEditMethodSig>(&ShaderProgramChunk::editHandleTessEvaluationShader),
 184         static_cast<FieldGetMethodSig >(&ShaderProgramChunk::getHandleTessEvaluationShader));
 185
 186     oType.addInitialDesc(pDesc);
 187
 188     pDesc = new MFUnrecShaderProgramPtr::Description(
 189         MFUnrecShaderProgramPtr::getClassType(),
 190         "geometryShader",
 191         "fragment program object\n",
 192         GeometryShaderFieldId, GeometryShaderFieldMask,
 193         false,
 194         (Field::MFDefaultFlags | Field::FStdAccess),
 195         static_cast<FieldEditMethodSig>(&ShaderProgramChunk::editHandleGeometryShader),
 196         static_cast<FieldGetMethodSig >(&ShaderProgramChunk::getHandleGeometryShader));
 197
 198     oType.addInitialDesc(pDesc);
 199
 200     pDesc = new MFUnrecShaderProgramPtr::Description(
 201         MFUnrecShaderProgramPtr::getClassType(),
 202         "fragmentShader",
 203         "fragment program object\n",
 204         FragmentShaderFieldId, FragmentShaderFieldMask,
 205         false,
 206         (Field::MFDefaultFlags | Field::FStdAccess),
 207         static_cast<FieldEditMethodSig>(&ShaderProgramChunk::editHandleFragmentShader),
 208         static_cast<FieldGetMethodSig >(&ShaderProgramChunk::getHandleFragmentShader));
 209
 210     oType.addInitialDesc(pDesc);
 211
 212     pDesc = new SFUInt32::Description(
 213         SFUInt32::getClassType(),
 214         "geometryVerticesOut",
 215         "",
 216         GeometryVerticesOutFieldId, GeometryVerticesOutFieldMask,
 217         false,
 218         (Field::SFDefaultFlags | Field::FStdAccess),
 219         static_cast<FieldEditMethodSig>(&ShaderProgramChunk::editHandleGeometryVerticesOut),
 220         static_cast<FieldGetMethodSig >(&ShaderProgramChunk::getHandleGeometryVerticesOut));
 221
 222     oType.addInitialDesc(pDesc);
 223
 224     pDesc = new SFGLenum::Description(
 225         SFGLenum::getClassType(),
 226         "geometryInputType",
 227         "",
 228         GeometryInputTypeFieldId, GeometryInputTypeFieldMask,
 229         false,
 230         (Field::SFDefaultFlags | Field::FStdAccess),
 231         static_cast<FieldEditMethodSig>(&ShaderProgramChunk::editHandleGeometryInputType),
 232         static_cast<FieldGetMethodSig >(&ShaderProgramChunk::getHandleGeometryInputType));
 233
 234     oType.addInitialDesc(pDesc);
 235
 236     pDesc = new SFGLenum::Description(
 237         SFGLenum::getClassType(),
 238         "geometryOutputType",
 239         "",
 240         GeometryOutputTypeFieldId, GeometryOutputTypeFieldMask,
 241         false,
 242         (Field::SFDefaultFlags | Field::FStdAccess),
 243         static_cast<FieldEditMethodSig>(&ShaderProgramChunk::editHandleGeometryOutputType),
 244         static_cast<FieldGetMethodSig >(&ShaderProgramChunk::getHandleGeometryOutputType));
 245
 246     oType.addInitialDesc(pDesc);
 247 }
 248
 249
 250 ShaderProgramChunkBase::TypeObject ShaderProgramChunkBase::_type(
 251     ShaderProgramChunkBase::getClassname(),
 252     Inherited::getClassname(),
 253     "NULL",
 254     nsOSG, //Namespace
 255     reinterpret_cast<PrototypeCreateF>(&ShaderProgramChunkBase::createEmptyLocal),
 256     reinterpret_cast<InitContainerF>(&ShaderProgramChunk::initMethod),
 257     reinterpret_cast<ExitContainerF>(&ShaderProgramChunk::exitMethod),
 258     reinterpret_cast<InitalInsertDescFunc>(
 259         reinterpret_cast<void *>(&ShaderProgramChunk::classDescInserter)),
 260     false,
 261     0,
 262     "<?xml version=\"1.0\"?>\n"
 263     "\n"
 264     "<FieldContainer\n"
 265     "   name=\"ShaderProgramChunk\"\n"
 266     "   parent=\"StateChunk\"\n"
 267     "   library=\"System\"\n"
 268     "   pointerfieldtypes=\"both\"\n"
 269     "   structure=\"concrete\"\n"
 270     "   systemcomponent=\"true\"\n"
 271     "   parentsystemcomponent=\"true\"\n"
 272     "   decoratable=\"false\"\n"
 273     "   useLocalIncludes=\"false\"\n"
 274     "   docGroupBase=\"GrpSystemShader\"\n"
 275     "   >\n"
 276     "  <Field\n"
 277     "\t name=\"vertexShader\"\n"
 278     "\t type=\"ShaderProgram\"\n"
 279     "\t cardinality=\"multi\"\n"
 280     "\t visibility=\"external\"\n"
 281     "\t access=\"public\"\n"
 282     "     category=\"pointer\"\n"
 283     "\n"
 284     "     pushToFieldAs=\"addVertexShader\"\n"
 285     "     removeFromMFieldIndexAs=\"subVertexShader\"\n"
 286     "     clearFieldAs=\"clearVertexShaders\"        \n"
 287     "\t >\n"
 288     "\tfragment program object\n"
 289     "  </Field>\n"
 290     "  <Field\n"
 291     "\t name=\"tessControlShader\"\n"
 292     "\t type=\"ShaderProgram\"\n"
 293     "\t cardinality=\"multi\"\n"
 294     "\t visibility=\"external\"\n"
 295     "\t access=\"public\"\n"
 296     "     category=\"pointer\"\n"
 297     "\n"
 298     "     pushToFieldAs=\"addTessControlShader\"\n"
 299     "     removeFromMFieldIndexAs=\"subTessControlShader\"\n"
 300     "     clearFieldAs=\"clearTessControlShaders\"        \n"
 301     "\t >\n"
 302     "\tfragment program object\n"
 303     "  </Field>\n"
 304     "  <Field\n"
 305     "\t name=\"tessEvaluationShader\"\n"
 306     "\t type=\"ShaderProgram\"\n"
 307     "\t cardinality=\"multi\"\n"
 308     "\t visibility=\"external\"\n"
 309     "\t access=\"public\"\n"
 310     "     category=\"pointer\"\n"
 311     "\n"
 312     "     pushToFieldAs=\"addTessEvaluationShader\"\n"
 313     "     removeFromMFieldIndexAs=\"subTessEvaluationShader\"\n"
 314     "     clearFieldAs=\"clearTessEvaluationShaders\"        \n"
 315     "\t >\n"
 316     "\tfragment program object\n"
 317     "  </Field>\n"
 318     "  <Field\n"
 319     "\t name=\"geometryShader\"\n"
 320     "\t type=\"ShaderProgram\"\n"
 321     "\t cardinality=\"multi\"\n"
 322     "\t visibility=\"external\"\n"
 323     "\t access=\"public\"\n"
 324     "     category=\"pointer\"\n"
 325     "\n"
 326     "     pushToFieldAs=\"addGeometryShader\"\n"
 327     "     removeFromMFieldIndexAs=\"subGeometryShader\"\n"
 328     "     clearFieldAs=\"clearGeometryShaders\"        \n"
 329     "\t >\n"
 330     "\tfragment program object\n"
 331     "  </Field>\n"
 332     "  <Field\n"
 333     "\t name=\"fragmentShader\"\n"
 334     "\t type=\"ShaderProgram\"\n"
 335     "\t cardinality=\"multi\"\n"
 336     "\t visibility=\"external\"\n"
 337     "\t access=\"public\"\n"
 338     "     category=\"pointer\"\n"
 339     "\n"
 340     "     pushToFieldAs=\"addFragmentShader\"\n"
 341     "     removeFromMFieldIndexAs=\"subFragmentShader\"\n"
 342     "     clearFieldAs=\"clearFragmentShaders\"        \n"
 343     "\t >\n"
 344     "\tfragment program object\n"
 345     "  </Field>\n"
 346     "\n"
 347     "  <Field\n"
 348     "\t name=\"geometryVerticesOut\"\n"
 349     "\t type=\"UInt32\"\n"
 350     "\t cardinality=\"single\"\n"
 351     "\t visibility=\"external\"\n"
 352     "\t defaultValue=\"0\"\n"
 353     "\t >\n"
 354     "  </Field>\n"
 355     "  <Field\n"
 356     "\t name=\"geometryInputType\"\n"
 357     "\t type=\"GLenum\"\n"
 358     "\t cardinality=\"single\"\n"
 359     "\t visibility=\"external\"\n"
 360     "\t defaultValue=\"GL_TRIANGLES\"\n"
 361     "\t defaultHeader=\"&quot;OSGGL.h&quot;\"\n"
 362     "\t >\n"
 363     "  </Field>\n"
 364     "  <Field\n"
 365     "\t name=\"geometryOutputType\"\n"
 366     "\t type=\"GLenum\"\n"
 367     "\t cardinality=\"single\"\n"
 368     "\t visibility=\"external\"\n"
 369     "\t defaultValue=\"GL_TRIANGLE_STRIP\"\n"
 370     "\t defaultHeader=\"&quot;OSGGL.h&quot;\"\n"
 371     "\t >\n"
 372     "  </Field>\n"
 373     "\n"
 374     "</FieldContainer>\n",
 375     ""
 376     );
 377
 378 /*------------------------------ get -----------------------------------*/
 379
 380 FieldContainerType &ShaderProgramChunkBase::getType(void)
 381 {
 382     return _type;
 383 }
 384
 385 const FieldContainerType &ShaderProgramChunkBase::getType(void) const
 386 {
 387     return _type;
 388 }
 389
 390 UInt32 ShaderProgramChunkBase::getContainerSize(void) const
 391 {
 392     return sizeof(ShaderProgramChunk);
 393 }
 394
 395 /*------------------------- decorator get ------------------------------*/
 396
 397
 398 //! Get the ShaderProgramChunk::_mfVertexShader field.
 399 const MFUnrecShaderProgramPtr *ShaderProgramChunkBase::getMFVertexShader(void) const
 400 {
 401     return &_mfVertexShader;
 402 }
 403
 404 MFUnrecShaderProgramPtr *ShaderProgramChunkBase::editMFVertexShader   (void)
 405 {
 406     editMField(VertexShaderFieldMask, _mfVertexShader);
 407
 408     return &_mfVertexShader;
 409 }
 410 ShaderProgram * ShaderProgramChunkBase::getVertexShader(const UInt32 index) const
 411 {
 412     return _mfVertexShader[index];
 413 }
 414
 415 //! Get the ShaderProgramChunk::_mfTessControlShader field.
 416 const MFUnrecShaderProgramPtr *ShaderProgramChunkBase::getMFTessControlShader(void) const
 417 {
 418     return &_mfTessControlShader;
 419 }
 420
 421 MFUnrecShaderProgramPtr *ShaderProgramChunkBase::editMFTessControlShader(void)
 422 {
 423     editMField(TessControlShaderFieldMask, _mfTessControlShader);
 424
 425     return &_mfTessControlShader;
 426 }
 427 ShaderProgram * ShaderProgramChunkBase::getTessControlShader(const UInt32 index) const
 428 {
 429     return _mfTessControlShader[index];
 430 }
 431
 432 //! Get the ShaderProgramChunk::_mfTessEvaluationShader field.
 433 const MFUnrecShaderProgramPtr *ShaderProgramChunkBase::getMFTessEvaluationShader(void) const
 434 {
 435     return &_mfTessEvaluationShader;
 436 }
 437
 438 MFUnrecShaderProgramPtr *ShaderProgramChunkBase::editMFTessEvaluationShader(void)
 439 {
 440     editMField(TessEvaluationShaderFieldMask, _mfTessEvaluationShader);
 441
 442     return &_mfTessEvaluationShader;
 443 }
 444 ShaderProgram * ShaderProgramChunkBase::getTessEvaluationShader(const UInt32 index) const
 445 {
 446     return _mfTessEvaluationShader[index];
 447 }
 448
 449 //! Get the ShaderProgramChunk::_mfGeometryShader field.
 450 const MFUnrecShaderProgramPtr *ShaderProgramChunkBase::getMFGeometryShader(void) const
 451 {
 452     return &_mfGeometryShader;
 453 }
 454
 455 MFUnrecShaderProgramPtr *ShaderProgramChunkBase::editMFGeometryShader (void)
 456 {
 457     editMField(GeometryShaderFieldMask, _mfGeometryShader);
 458
 459     return &_mfGeometryShader;
 460 }
 461 ShaderProgram * ShaderProgramChunkBase::getGeometryShader(const UInt32 index) const
 462 {
 463     return _mfGeometryShader[index];
 464 }
 465
 466 //! Get the ShaderProgramChunk::_mfFragmentShader field.
 467 const MFUnrecShaderProgramPtr *ShaderProgramChunkBase::getMFFragmentShader(void) const
 468 {
 469     return &_mfFragmentShader;
 470 }
 471
 472 MFUnrecShaderProgramPtr *ShaderProgramChunkBase::editMFFragmentShader (void)
 473 {
 474     editMField(FragmentShaderFieldMask, _mfFragmentShader);
 475
 476     return &_mfFragmentShader;
 477 }
 478 ShaderProgram * ShaderProgramChunkBase::getFragmentShader(const UInt32 index) const
 479 {
 480     return _mfFragmentShader[index];
 481 }
 482
 483 SFUInt32 *ShaderProgramChunkBase::editSFGeometryVerticesOut(void)
 484 {
 485     editSField(GeometryVerticesOutFieldMask);
 486
 487     return &_sfGeometryVerticesOut;
 488 }
 489
 490 const SFUInt32 *ShaderProgramChunkBase::getSFGeometryVerticesOut(void) const
 491 {
 492     return &_sfGeometryVerticesOut;
 493 }
 494
 495
 496 SFGLenum *ShaderProgramChunkBase::editSFGeometryInputType(void)
 497 {
 498     editSField(GeometryInputTypeFieldMask);
 499
 500     return &_sfGeometryInputType;
 501 }
 502
 503 const SFGLenum *ShaderProgramChunkBase::getSFGeometryInputType(void) const
 504 {
 505     return &_sfGeometryInputType;
 506 }
 507
 508
 509 SFGLenum *ShaderProgramChunkBase::editSFGeometryOutputType(void)
 510 {
 511     editSField(GeometryOutputTypeFieldMask);
 512
 513     return &_sfGeometryOutputType;
 514 }
 515
 516 const SFGLenum *ShaderProgramChunkBase::getSFGeometryOutputType(void) const
 517 {
 518     return &_sfGeometryOutputType;
 519 }
 520
 521
 522
 523
 524 void ShaderProgramChunkBase::addVertexShader(ShaderProgram * const value)
 525 {
 526     editMField(VertexShaderFieldMask, _mfVertexShader);
 527
 528     _mfVertexShader.push_back(value);
 529 }
 530
 531 void ShaderProgramChunkBase::assignVertexShader(const MFUnrecShaderProgramPtr &value)
 532 {
 533     MFUnrecShaderProgramPtr::const_iterator elemIt  =
 534         value.begin();
 535     MFUnrecShaderProgramPtr::const_iterator elemEnd =
 536         value.end  ();
 537
 538     static_cast<ShaderProgramChunk *>(this)->clearVertexShaders();
 539
 540     while(elemIt != elemEnd)
 541     {
 542         this->addVertexShader(*elemIt);
 543
 544         ++elemIt;
 545     }
 546 }
 547
 548 void ShaderProgramChunkBase::subVertexShader(UInt32 uiIndex)
 549 {
 550     if(uiIndex < _mfVertexShader.size())
 551     {
 552         editMField(VertexShaderFieldMask, _mfVertexShader);
 553
 554         _mfVertexShader.erase(uiIndex);
 555     }
 556 }
 557
 558 void ShaderProgramChunkBase::removeObjFromVertexShader(ShaderProgram * const value)
 559 {
 560     Int32 iElemIdx = _mfVertexShader.findIndex(value);
 561
 562     if(iElemIdx != -1)
 563     {
 564         editMField(VertexShaderFieldMask, _mfVertexShader);
 565
 566         _mfVertexShader.erase(iElemIdx);
 567     }
 568 }
 569 void ShaderProgramChunkBase::clearVertexShaders(void)
 570 {
 571     editMField(VertexShaderFieldMask, _mfVertexShader);
 572
 573
 574     _mfVertexShader.clear();
 575 }
 576
 577 void ShaderProgramChunkBase::addTessControlShader(ShaderProgram * const value)
 578 {
 579     editMField(TessControlShaderFieldMask, _mfTessControlShader);
 580
 581     _mfTessControlShader.push_back(value);
 582 }
 583
 584 void ShaderProgramChunkBase::assignTessControlShader(const MFUnrecShaderProgramPtr &value)
 585 {
 586     MFUnrecShaderProgramPtr::const_iterator elemIt  =
 587         value.begin();
 588     MFUnrecShaderProgramPtr::const_iterator elemEnd =
 589         value.end  ();
 590
 591     static_cast<ShaderProgramChunk *>(this)->clearTessControlShaders();
 592
 593     while(elemIt != elemEnd)
 594     {
 595         this->addTessControlShader(*elemIt);
 596
 597         ++elemIt;
 598     }
 599 }
 600
 601 void ShaderProgramChunkBase::subTessControlShader(UInt32 uiIndex)
 602 {
 603     if(uiIndex < _mfTessControlShader.size())
 604     {
 605         editMField(TessControlShaderFieldMask, _mfTessControlShader);
 606
 607         _mfTessControlShader.erase(uiIndex);
 608     }
 609 }
 610
 611 void ShaderProgramChunkBase::removeObjFromTessControlShader(ShaderProgram * const value)
 612 {
 613     Int32 iElemIdx = _mfTessControlShader.findIndex(value);
 614
 615     if(iElemIdx != -1)
 616     {
 617         editMField(TessControlShaderFieldMask, _mfTessControlShader);
 618
 619         _mfTessControlShader.erase(iElemIdx);
 620     }
 621 }
 622 void ShaderProgramChunkBase::clearTessControlShaders(void)
 623 {
 624     editMField(TessControlShaderFieldMask, _mfTessControlShader);
 625
 626
 627     _mfTessControlShader.clear();
 628 }
 629
 630 void ShaderProgramChunkBase::addTessEvaluationShader(ShaderProgram * const value)
 631 {
 632     editMField(TessEvaluationShaderFieldMask, _mfTessEvaluationShader);
 633
 634     _mfTessEvaluationShader.push_back(value);
 635 }
 636
 637 void ShaderProgramChunkBase::assignTessEvaluationShader(const MFUnrecShaderProgramPtr &value)
 638 {
 639     MFUnrecShaderProgramPtr::const_iterator elemIt  =
 640         value.begin();
 641     MFUnrecShaderProgramPtr::const_iterator elemEnd =
 642         value.end  ();
 643
 644     static_cast<ShaderProgramChunk *>(this)->clearTessEvaluationShaders();
 645
 646     while(elemIt != elemEnd)
 647     {
 648         this->addTessEvaluationShader(*elemIt);
 649
 650         ++elemIt;
 651     }
 652 }
 653
 654 void ShaderProgramChunkBase::subTessEvaluationShader(UInt32 uiIndex)
 655 {
 656     if(uiIndex < _mfTessEvaluationShader.size())
 657     {
 658         editMField(TessEvaluationShaderFieldMask, _mfTessEvaluationShader);
 659
 660         _mfTessEvaluationShader.erase(uiIndex);
 661     }
 662 }
 663
 664 void ShaderProgramChunkBase::removeObjFromTessEvaluationShader(ShaderProgram * const value)
 665 {
 666     Int32 iElemIdx = _mfTessEvaluationShader.findIndex(value);
 667
 668     if(iElemIdx != -1)
 669     {
 670         editMField(TessEvaluationShaderFieldMask, _mfTessEvaluationShader);
 671
 672         _mfTessEvaluationShader.erase(iElemIdx);
 673     }
 674 }
 675 void ShaderProgramChunkBase::clearTessEvaluationShaders(void)
 676 {
 677     editMField(TessEvaluationShaderFieldMask, _mfTessEvaluationShader);
 678
 679
 680     _mfTessEvaluationShader.clear();
 681 }
 682
 683 void ShaderProgramChunkBase::addGeometryShader(ShaderProgram * const value)
 684 {
 685     editMField(GeometryShaderFieldMask, _mfGeometryShader);
 686
 687     _mfGeometryShader.push_back(value);
 688 }
 689
 690 void ShaderProgramChunkBase::assignGeometryShader(const MFUnrecShaderProgramPtr &value)
 691 {
 692     MFUnrecShaderProgramPtr::const_iterator elemIt  =
 693         value.begin();
 694     MFUnrecShaderProgramPtr::const_iterator elemEnd =
 695         value.end  ();
 696
 697     static_cast<ShaderProgramChunk *>(this)->clearGeometryShaders();
 698
 699     while(elemIt != elemEnd)
 700     {
 701         this->addGeometryShader(*elemIt);
 702
 703         ++elemIt;
 704     }
 705 }
 706
 707 void ShaderProgramChunkBase::subGeometryShader(UInt32 uiIndex)
 708 {
 709     if(uiIndex < _mfGeometryShader.size())
 710     {
 711         editMField(GeometryShaderFieldMask, _mfGeometryShader);
 712
 713         _mfGeometryShader.erase(uiIndex);
 714     }
 715 }
 716
 717 void ShaderProgramChunkBase::removeObjFromGeometryShader(ShaderProgram * const value)
 718 {
 719     Int32 iElemIdx = _mfGeometryShader.findIndex(value);
 720
 721     if(iElemIdx != -1)
 722     {
 723         editMField(GeometryShaderFieldMask, _mfGeometryShader);
 724
 725         _mfGeometryShader.erase(iElemIdx);
 726     }
 727 }
 728 void ShaderProgramChunkBase::clearGeometryShaders(void)
 729 {
 730     editMField(GeometryShaderFieldMask, _mfGeometryShader);
 731
 732
 733     _mfGeometryShader.clear();
 734 }
 735
 736 void ShaderProgramChunkBase::addFragmentShader(ShaderProgram * const value)
 737 {
 738     editMField(FragmentShaderFieldMask, _mfFragmentShader);
 739
 740     _mfFragmentShader.push_back(value);
 741 }
 742
 743 void ShaderProgramChunkBase::assignFragmentShader(const MFUnrecShaderProgramPtr &value)
 744 {
 745     MFUnrecShaderProgramPtr::const_iterator elemIt  =
 746         value.begin();
 747     MFUnrecShaderProgramPtr::const_iterator elemEnd =
 748         value.end  ();
 749
 750     static_cast<ShaderProgramChunk *>(this)->clearFragmentShaders();
 751
 752     while(elemIt != elemEnd)
 753     {
 754         this->addFragmentShader(*elemIt);
 755
 756         ++elemIt;
 757     }
 758 }
 759
 760 void ShaderProgramChunkBase::subFragmentShader(UInt32 uiIndex)
 761 {
 762     if(uiIndex < _mfFragmentShader.size())
 763     {
 764         editMField(FragmentShaderFieldMask, _mfFragmentShader);
 765
 766         _mfFragmentShader.erase(uiIndex);
 767     }
 768 }
 769
 770 void ShaderProgramChunkBase::removeObjFromFragmentShader(ShaderProgram * const value)
 771 {
 772     Int32 iElemIdx = _mfFragmentShader.findIndex(value);
 773
 774     if(iElemIdx != -1)
 775     {
 776         editMField(FragmentShaderFieldMask, _mfFragmentShader);
 777
 778         _mfFragmentShader.erase(iElemIdx);
 779     }
 780 }
 781 void ShaderProgramChunkBase::clearFragmentShaders(void)
 782 {
 783     editMField(FragmentShaderFieldMask, _mfFragmentShader);
 784
 785
 786     _mfFragmentShader.clear();
 787 }
 788
 789
 790
 791 /*------------------------------ access -----------------------------------*/
 792
 793 SizeT ShaderProgramChunkBase::getBinSize(ConstFieldMaskArg whichField)
 794 {
 795     SizeT returnValue = Inherited::getBinSize(whichField);
 796
 797     if(FieldBits::NoField != (VertexShaderFieldMask & whichField))
 798     {
 799         returnValue += _mfVertexShader.getBinSize();
 800     }
 801     if(FieldBits::NoField != (TessControlShaderFieldMask & whichField))
 802     {
 803         returnValue += _mfTessControlShader.getBinSize();
 804     }
 805     if(FieldBits::NoField != (TessEvaluationShaderFieldMask & whichField))
 806     {
 807         returnValue += _mfTessEvaluationShader.getBinSize();
 808     }
 809     if(FieldBits::NoField != (GeometryShaderFieldMask & whichField))
 810     {
 811         returnValue += _mfGeometryShader.getBinSize();
 812     }
 813     if(FieldBits::NoField != (FragmentShaderFieldMask & whichField))
 814     {
 815         returnValue += _mfFragmentShader.getBinSize();
 816     }
 817     if(FieldBits::NoField != (GeometryVerticesOutFieldMask & whichField))
 818     {
 819         returnValue += _sfGeometryVerticesOut.getBinSize();
 820     }
 821     if(FieldBits::NoField != (GeometryInputTypeFieldMask & whichField))
 822     {
 823         returnValue += _sfGeometryInputType.getBinSize();
 824     }
 825     if(FieldBits::NoField != (GeometryOutputTypeFieldMask & whichField))
 826     {
 827         returnValue += _sfGeometryOutputType.getBinSize();
 828     }
 829
 830     return returnValue;
 831 }
 832
 833 void ShaderProgramChunkBase::copyToBin(BinaryDataHandler &pMem,
 834                                   ConstFieldMaskArg  whichField)
 835 {
 836     Inherited::copyToBin(pMem, whichField);
 837
 838     if(FieldBits::NoField != (VertexShaderFieldMask & whichField))
 839     {
 840         _mfVertexShader.copyToBin(pMem);
 841     }
 842     if(FieldBits::NoField != (TessControlShaderFieldMask & whichField))
 843     {
 844         _mfTessControlShader.copyToBin(pMem);
 845     }
 846     if(FieldBits::NoField != (TessEvaluationShaderFieldMask & whichField))
 847     {
 848         _mfTessEvaluationShader.copyToBin(pMem);
 849     }
 850     if(FieldBits::NoField != (GeometryShaderFieldMask & whichField))
 851     {
 852         _mfGeometryShader.copyToBin(pMem);
 853     }
 854     if(FieldBits::NoField != (FragmentShaderFieldMask & whichField))
 855     {
 856         _mfFragmentShader.copyToBin(pMem);
 857     }
 858     if(FieldBits::NoField != (GeometryVerticesOutFieldMask & whichField))
 859     {
 860         _sfGeometryVerticesOut.copyToBin(pMem);
 861     }
 862     if(FieldBits::NoField != (GeometryInputTypeFieldMask & whichField))
 863     {
 864         _sfGeometryInputType.copyToBin(pMem);
 865     }
 866     if(FieldBits::NoField != (GeometryOutputTypeFieldMask & whichField))
 867     {
 868         _sfGeometryOutputType.copyToBin(pMem);
 869     }
 870 }
 871
 872 void ShaderProgramChunkBase::copyFromBin(BinaryDataHandler &pMem,
 873                                     ConstFieldMaskArg  whichField)
 874 {
 875     Inherited::copyFromBin(pMem, whichField);
 876
 877     if(FieldBits::NoField != (VertexShaderFieldMask & whichField))
 878     {
 879         editMField(VertexShaderFieldMask, _mfVertexShader);
 880         _mfVertexShader.copyFromBin(pMem);
 881     }
 882     if(FieldBits::NoField != (TessControlShaderFieldMask & whichField))
 883     {
 884         editMField(TessControlShaderFieldMask, _mfTessControlShader);
 885         _mfTessControlShader.copyFromBin(pMem);
 886     }
 887     if(FieldBits::NoField != (TessEvaluationShaderFieldMask & whichField))
 888     {
 889         editMField(TessEvaluationShaderFieldMask, _mfTessEvaluationShader);
 890         _mfTessEvaluationShader.copyFromBin(pMem);
 891     }
 892     if(FieldBits::NoField != (GeometryShaderFieldMask & whichField))
 893     {
 894         editMField(GeometryShaderFieldMask, _mfGeometryShader);
 895         _mfGeometryShader.copyFromBin(pMem);
 896     }
 897     if(FieldBits::NoField != (FragmentShaderFieldMask & whichField))
 898     {
 899         editMField(FragmentShaderFieldMask, _mfFragmentShader);
 900         _mfFragmentShader.copyFromBin(pMem);
 901     }
 902     if(FieldBits::NoField != (GeometryVerticesOutFieldMask & whichField))
 903     {
 904         editSField(GeometryVerticesOutFieldMask);
 905         _sfGeometryVerticesOut.copyFromBin(pMem);
 906     }
 907     if(FieldBits::NoField != (GeometryInputTypeFieldMask & whichField))
 908     {
 909         editSField(GeometryInputTypeFieldMask);
 910         _sfGeometryInputType.copyFromBin(pMem);
 911     }
 912     if(FieldBits::NoField != (GeometryOutputTypeFieldMask & whichField))
 913     {
 914         editSField(GeometryOutputTypeFieldMask);
 915         _sfGeometryOutputType.copyFromBin(pMem);
 916     }
 917 }
 918
 919 //! create a new instance of the class
 920 ShaderProgramChunkTransitPtr ShaderProgramChunkBase::createLocal(BitVector bFlags)
 921 {
 922     ShaderProgramChunkTransitPtr fc;
 923
 924     if(getClassType().getPrototype() != NULL)
 925     {
 926         FieldContainerTransitPtr tmpPtr =
 927             getClassType().getPrototype()-> shallowCopyLocal(bFlags);
 928
 929         fc = dynamic_pointer_cast<ShaderProgramChunk>(tmpPtr);
 930     }
 931
 932     return fc;
 933 }
 934
 935 //! create a new instance of the class, copy the container flags
 936 ShaderProgramChunkTransitPtr ShaderProgramChunkBase::createDependent(BitVector bFlags)
 937 {
 938     ShaderProgramChunkTransitPtr fc;
 939
 940     if(getClassType().getPrototype() != NULL)
 941     {
 942         FieldContainerTransitPtr tmpPtr =
 943             getClassType().getPrototype()-> shallowCopyDependent(bFlags);
 944
 945         fc = dynamic_pointer_cast<ShaderProgramChunk>(tmpPtr);
 946     }
 947
 948     return fc;
 949 }
 950
 951 //! create a new instance of the class
 952 ShaderProgramChunkTransitPtr ShaderProgramChunkBase::create(void)
 953 {
 954     ShaderProgramChunkTransitPtr fc;
 955
 956     if(getClassType().getPrototype() != NULL)
 957     {
 958         FieldContainerTransitPtr tmpPtr =
 959             getClassType().getPrototype()-> shallowCopy();
 960
 961         fc = dynamic_pointer_cast<ShaderProgramChunk>(tmpPtr);
 962     }
 963
 964     return fc;
 965 }
 966
 967 ShaderProgramChunk *ShaderProgramChunkBase::createEmptyLocal(BitVector bFlags)
 968 {
 969     ShaderProgramChunk *returnValue;
 970
 971     newPtr<ShaderProgramChunk>(returnValue, bFlags);
 972
 973     returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
 974
 975     return returnValue;
 976 }
 977
 978 //! create an empty new instance of the class, do not copy the prototype
 979 ShaderProgramChunk *ShaderProgramChunkBase::createEmpty(void)
 980 {
 981     ShaderProgramChunk *returnValue;
 982
 983     newPtr<ShaderProgramChunk>(returnValue, Thread::getCurrentLocalFlags());
 984
 985     returnValue->_pFieldFlags->_bNamespaceMask &=
 986         ~Thread::getCurrentLocalFlags();
 987
 988     return returnValue;
 989 }
 990
 991
 992 FieldContainerTransitPtr ShaderProgramChunkBase::shallowCopyLocal(
 993     BitVector bFlags) const
 994 {
 995     ShaderProgramChunk *tmpPtr;
 996
 997     newPtr(tmpPtr, dynamic_cast<const ShaderProgramChunk *>(this), bFlags);
 998
 999     FieldContainerTransitPtr returnValue(tmpPtr);
1000
1001     tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
1002
1003     return returnValue;
1004 }
1005
1006 FieldContainerTransitPtr ShaderProgramChunkBase::shallowCopyDependent(
1007     BitVector bFlags) const
1008 {
1009     ShaderProgramChunk *tmpPtr;
1010
1011     newPtr(tmpPtr, dynamic_cast<const ShaderProgramChunk *>(this), ~bFlags);
1012
1013     FieldContainerTransitPtr returnValue(tmpPtr);
1014
1015     tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
1016
1017     return returnValue;
1018 }
1019
1020 FieldContainerTransitPtr ShaderProgramChunkBase::shallowCopy(void) const
1021 {
1022     ShaderProgramChunk *tmpPtr;
1023
1024     newPtr(tmpPtr,
1025            dynamic_cast<const ShaderProgramChunk *>(this),
1026            Thread::getCurrentLocalFlags());
1027
1028     tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
1029
1030     FieldContainerTransitPtr returnValue(tmpPtr);
1031
1032     return returnValue;
1033 }
1034
1035
1036
1037
1038 /*------------------------- constructors ----------------------------------*/
1039
1040 ShaderProgramChunkBase::ShaderProgramChunkBase(void) :
1041     Inherited(),
1042     _mfVertexShader           (),
1043     _mfTessControlShader      (),
1044     _mfTessEvaluationShader   (),
1045     _mfGeometryShader         (),
1046     _mfFragmentShader         (),
1047     _sfGeometryVerticesOut    (UInt32(0)),
1048     _sfGeometryInputType      (GLenum(GL_TRIANGLES)),
1049     _sfGeometryOutputType     (GLenum(GL_TRIANGLE_STRIP))
1050 {
1051 }
1052
1053 ShaderProgramChunkBase::ShaderProgramChunkBase(const ShaderProgramChunkBase &source) :
1054     Inherited(source),
1055     _mfVertexShader           (),
1056     _mfTessControlShader      (),
1057     _mfTessEvaluationShader   (),
1058     _mfGeometryShader         (),
1059     _mfFragmentShader         (),
1060     _sfGeometryVerticesOut    (source._sfGeometryVerticesOut    ),
1061     _sfGeometryInputType      (source._sfGeometryInputType      ),
1062     _sfGeometryOutputType     (source._sfGeometryOutputType     )
1063 {
1064 }
1065
1066
1067 /*-------------------------- destructors ----------------------------------*/
1068
1069 ShaderProgramChunkBase::~ShaderProgramChunkBase(void)
1070 {
1071 }
1072
1073 void ShaderProgramChunkBase::onCreate(const ShaderProgramChunk *source)
1074 {
1075     Inherited::onCreate(source);
1076
1077     if(source != NULL)
1078     {
1079         ShaderProgramChunk *pThis = static_cast<ShaderProgramChunk *>(this);
1080
1081         MFUnrecShaderProgramPtr::const_iterator VertexShaderIt  =
1082             source->_mfVertexShader.begin();
1083         MFUnrecShaderProgramPtr::const_iterator VertexShaderEnd =
1084             source->_mfVertexShader.end  ();
1085
1086         while(VertexShaderIt != VertexShaderEnd)
1087         {
1088             pThis->addVertexShader(*VertexShaderIt);
1089
1090             ++VertexShaderIt;
1091         }
1092
1093         MFUnrecShaderProgramPtr::const_iterator TessControlShaderIt  =
1094             source->_mfTessControlShader.begin();
1095         MFUnrecShaderProgramPtr::const_iterator TessControlShaderEnd =
1096             source->_mfTessControlShader.end  ();
1097
1098         while(TessControlShaderIt != TessControlShaderEnd)
1099         {
1100             pThis->addTessControlShader(*TessControlShaderIt);
1101
1102             ++TessControlShaderIt;
1103         }
1104
1105         MFUnrecShaderProgramPtr::const_iterator TessEvaluationShaderIt  =
1106             source->_mfTessEvaluationShader.begin();
1107         MFUnrecShaderProgramPtr::const_iterator TessEvaluationShaderEnd =
1108             source->_mfTessEvaluationShader.end  ();
1109
1110         while(TessEvaluationShaderIt != TessEvaluationShaderEnd)
1111         {
1112             pThis->addTessEvaluationShader(*TessEvaluationShaderIt);
1113
1114             ++TessEvaluationShaderIt;
1115         }
1116
1117         MFUnrecShaderProgramPtr::const_iterator GeometryShaderIt  =
1118             source->_mfGeometryShader.begin();
1119         MFUnrecShaderProgramPtr::const_iterator GeometryShaderEnd =
1120             source->_mfGeometryShader.end  ();
1121
1122         while(GeometryShaderIt != GeometryShaderEnd)
1123         {
1124             pThis->addGeometryShader(*GeometryShaderIt);
1125
1126             ++GeometryShaderIt;
1127         }
1128
1129         MFUnrecShaderProgramPtr::const_iterator FragmentShaderIt  =
1130             source->_mfFragmentShader.begin();
1131         MFUnrecShaderProgramPtr::const_iterator FragmentShaderEnd =
1132             source->_mfFragmentShader.end  ();
1133
1134         while(FragmentShaderIt != FragmentShaderEnd)
1135         {
1136             pThis->addFragmentShader(*FragmentShaderIt);
1137
1138             ++FragmentShaderIt;
1139         }
1140     }
1141 }
1142
1143 GetFieldHandlePtr ShaderProgramChunkBase::getHandleVertexShader    (void) const
1144 {
1145     MFUnrecShaderProgramPtr::GetHandlePtr returnValue(
1146         new  MFUnrecShaderProgramPtr::GetHandle(
1147              &_mfVertexShader,
1148              this->getType().getFieldDesc(VertexShaderFieldId),
1149              const_cast<ShaderProgramChunkBase *>(this)));
1150
1151     return returnValue;
1152 }
1153
1154 EditFieldHandlePtr ShaderProgramChunkBase::editHandleVertexShader   (void)
1155 {
1156     MFUnrecShaderProgramPtr::EditHandlePtr returnValue(
1157         new  MFUnrecShaderProgramPtr::EditHandle(
1158              &_mfVertexShader,
1159              this->getType().getFieldDesc(VertexShaderFieldId),
1160              this));
1161
1162     returnValue->setAddMethod(
1163         boost::bind(&ShaderProgramChunk::addVertexShader,
1164                     static_cast<ShaderProgramChunk *>(this), _1));
1165     returnValue->setRemoveMethod(
1166         boost::bind(&ShaderProgramChunk::subVertexShader,
1167                     static_cast<ShaderProgramChunk *>(this), _1));
1168     returnValue->setRemoveObjMethod(
1169         boost::bind(&ShaderProgramChunk::removeObjFromVertexShader,
1170                     static_cast<ShaderProgramChunk *>(this), _1));
1171     returnValue->setClearMethod(
1172         boost::bind(&ShaderProgramChunk::clearVertexShaders,
1173                     static_cast<ShaderProgramChunk *>(this)));
1174
1175     editMField(VertexShaderFieldMask, _mfVertexShader);
1176
1177     return returnValue;
1178 }
1179
1180 GetFieldHandlePtr ShaderProgramChunkBase::getHandleTessControlShader (void) const
1181 {
1182     MFUnrecShaderProgramPtr::GetHandlePtr returnValue(
1183         new  MFUnrecShaderProgramPtr::GetHandle(
1184              &_mfTessControlShader,
1185              this->getType().getFieldDesc(TessControlShaderFieldId),
1186              const_cast<ShaderProgramChunkBase *>(this)));
1187
1188     return returnValue;
1189 }
1190
1191 EditFieldHandlePtr ShaderProgramChunkBase::editHandleTessControlShader(void)
1192 {
1193     MFUnrecShaderProgramPtr::EditHandlePtr returnValue(
1194         new  MFUnrecShaderProgramPtr::EditHandle(
1195              &_mfTessControlShader,
1196              this->getType().getFieldDesc(TessControlShaderFieldId),
1197              this));
1198
1199     returnValue->setAddMethod(
1200         boost::bind(&ShaderProgramChunk::addTessControlShader,
1201                     static_cast<ShaderProgramChunk *>(this), _1));
1202     returnValue->setRemoveMethod(
1203         boost::bind(&ShaderProgramChunk::subTessControlShader,
1204                     static_cast<ShaderProgramChunk *>(this), _1));
1205     returnValue->setRemoveObjMethod(
1206         boost::bind(&ShaderProgramChunk::removeObjFromTessControlShader,
1207                     static_cast<ShaderProgramChunk *>(this), _1));
1208     returnValue->setClearMethod(
1209         boost::bind(&ShaderProgramChunk::clearTessControlShaders,
1210                     static_cast<ShaderProgramChunk *>(this)));
1211
1212     editMField(TessControlShaderFieldMask, _mfTessControlShader);
1213
1214     return returnValue;
1215 }
1216
1217 GetFieldHandlePtr ShaderProgramChunkBase::getHandleTessEvaluationShader (void) const
1218 {
1219     MFUnrecShaderProgramPtr::GetHandlePtr returnValue(
1220         new  MFUnrecShaderProgramPtr::GetHandle(
1221              &_mfTessEvaluationShader,
1222              this->getType().getFieldDesc(TessEvaluationShaderFieldId),
1223              const_cast<ShaderProgramChunkBase *>(this)));
1224
1225     return returnValue;
1226 }
1227
1228 EditFieldHandlePtr ShaderProgramChunkBase::editHandleTessEvaluationShader(void)
1229 {
1230     MFUnrecShaderProgramPtr::EditHandlePtr returnValue(
1231         new  MFUnrecShaderProgramPtr::EditHandle(
1232              &_mfTessEvaluationShader,
1233              this->getType().getFieldDesc(TessEvaluationShaderFieldId),
1234              this));
1235
1236     returnValue->setAddMethod(
1237         boost::bind(&ShaderProgramChunk::addTessEvaluationShader,
1238                     static_cast<ShaderProgramChunk *>(this), _1));
1239     returnValue->setRemoveMethod(
1240         boost::bind(&ShaderProgramChunk::subTessEvaluationShader,
1241                     static_cast<ShaderProgramChunk *>(this), _1));
1242     returnValue->setRemoveObjMethod(
1243         boost::bind(&ShaderProgramChunk::removeObjFromTessEvaluationShader,
1244                     static_cast<ShaderProgramChunk *>(this), _1));
1245     returnValue->setClearMethod(
1246         boost::bind(&ShaderProgramChunk::clearTessEvaluationShaders,
1247                     static_cast<ShaderProgramChunk *>(this)));
1248
1249     editMField(TessEvaluationShaderFieldMask, _mfTessEvaluationShader);
1250
1251     return returnValue;
1252 }
1253
1254 GetFieldHandlePtr ShaderProgramChunkBase::getHandleGeometryShader  (void) const
1255 {
1256     MFUnrecShaderProgramPtr::GetHandlePtr returnValue(
1257         new  MFUnrecShaderProgramPtr::GetHandle(
1258              &_mfGeometryShader,
1259              this->getType().getFieldDesc(GeometryShaderFieldId),
1260              const_cast<ShaderProgramChunkBase *>(this)));
1261
1262     return returnValue;
1263 }
1264
1265 EditFieldHandlePtr ShaderProgramChunkBase::editHandleGeometryShader (void)
1266 {
1267     MFUnrecShaderProgramPtr::EditHandlePtr returnValue(
1268         new  MFUnrecShaderProgramPtr::EditHandle(
1269              &_mfGeometryShader,
1270              this->getType().getFieldDesc(GeometryShaderFieldId),
1271              this));
1272
1273     returnValue->setAddMethod(
1274         boost::bind(&ShaderProgramChunk::addGeometryShader,
1275                     static_cast<ShaderProgramChunk *>(this), _1));
1276     returnValue->setRemoveMethod(
1277         boost::bind(&ShaderProgramChunk::subGeometryShader,
1278                     static_cast<ShaderProgramChunk *>(this), _1));
1279     returnValue->setRemoveObjMethod(
1280         boost::bind(&ShaderProgramChunk::removeObjFromGeometryShader,
1281                     static_cast<ShaderProgramChunk *>(this), _1));
1282     returnValue->setClearMethod(
1283         boost::bind(&ShaderProgramChunk::clearGeometryShaders,
1284                     static_cast<ShaderProgramChunk *>(this)));
1285
1286     editMField(GeometryShaderFieldMask, _mfGeometryShader);
1287
1288     return returnValue;
1289 }
1290
1291 GetFieldHandlePtr ShaderProgramChunkBase::getHandleFragmentShader  (void) const
1292 {
1293     MFUnrecShaderProgramPtr::GetHandlePtr returnValue(
1294         new  MFUnrecShaderProgramPtr::GetHandle(
1295              &_mfFragmentShader,
1296              this->getType().getFieldDesc(FragmentShaderFieldId),
1297              const_cast<ShaderProgramChunkBase *>(this)));
1298
1299     return returnValue;
1300 }
1301
1302 EditFieldHandlePtr ShaderProgramChunkBase::editHandleFragmentShader (void)
1303 {
1304     MFUnrecShaderProgramPtr::EditHandlePtr returnValue(
1305         new  MFUnrecShaderProgramPtr::EditHandle(
1306              &_mfFragmentShader,
1307              this->getType().getFieldDesc(FragmentShaderFieldId),
1308              this));
1309
1310     returnValue->setAddMethod(
1311         boost::bind(&ShaderProgramChunk::addFragmentShader,
1312                     static_cast<ShaderProgramChunk *>(this), _1));
1313     returnValue->setRemoveMethod(
1314         boost::bind(&ShaderProgramChunk::subFragmentShader,
1315                     static_cast<ShaderProgramChunk *>(this), _1));
1316     returnValue->setRemoveObjMethod(
1317         boost::bind(&ShaderProgramChunk::removeObjFromFragmentShader,
1318                     static_cast<ShaderProgramChunk *>(this), _1));
1319     returnValue->setClearMethod(
1320         boost::bind(&ShaderProgramChunk::clearFragmentShaders,
1321                     static_cast<ShaderProgramChunk *>(this)));
1322
1323     editMField(FragmentShaderFieldMask, _mfFragmentShader);
1324
1325     return returnValue;
1326 }
1327
1328 GetFieldHandlePtr ShaderProgramChunkBase::getHandleGeometryVerticesOut (void) const
1329 {
1330     SFUInt32::GetHandlePtr returnValue(
1331         new  SFUInt32::GetHandle(
1332              &_sfGeometryVerticesOut,
1333              this->getType().getFieldDesc(GeometryVerticesOutFieldId),
1334              const_cast<ShaderProgramChunkBase *>(this)));
1335
1336     return returnValue;
1337 }
1338
1339 EditFieldHandlePtr ShaderProgramChunkBase::editHandleGeometryVerticesOut(void)
1340 {
1341     SFUInt32::EditHandlePtr returnValue(
1342         new  SFUInt32::EditHandle(
1343              &_sfGeometryVerticesOut,
1344              this->getType().getFieldDesc(GeometryVerticesOutFieldId),
1345              this));
1346
1347
1348     editSField(GeometryVerticesOutFieldMask);
1349
1350     return returnValue;
1351 }
1352
1353 GetFieldHandlePtr ShaderProgramChunkBase::getHandleGeometryInputType (void) const
1354 {
1355     SFGLenum::GetHandlePtr returnValue(
1356         new  SFGLenum::GetHandle(
1357              &_sfGeometryInputType,
1358              this->getType().getFieldDesc(GeometryInputTypeFieldId),
1359              const_cast<ShaderProgramChunkBase *>(this)));
1360
1361     return returnValue;
1362 }
1363
1364 EditFieldHandlePtr ShaderProgramChunkBase::editHandleGeometryInputType(void)
1365 {
1366     SFGLenum::EditHandlePtr returnValue(
1367         new  SFGLenum::EditHandle(
1368              &_sfGeometryInputType,
1369              this->getType().getFieldDesc(GeometryInputTypeFieldId),
1370              this));
1371
1372
1373     editSField(GeometryInputTypeFieldMask);
1374
1375     return returnValue;
1376 }
1377
1378 GetFieldHandlePtr ShaderProgramChunkBase::getHandleGeometryOutputType (void) const
1379 {
1380     SFGLenum::GetHandlePtr returnValue(
1381         new  SFGLenum::GetHandle(
1382              &_sfGeometryOutputType,
1383              this->getType().getFieldDesc(GeometryOutputTypeFieldId),
1384              const_cast<ShaderProgramChunkBase *>(this)));
1385
1386     return returnValue;
1387 }
1388
1389 EditFieldHandlePtr ShaderProgramChunkBase::editHandleGeometryOutputType(void)
1390 {
1391     SFGLenum::EditHandlePtr returnValue(
1392         new  SFGLenum::EditHandle(
1393              &_sfGeometryOutputType,
1394              this->getType().getFieldDesc(GeometryOutputTypeFieldId),
1395              this));
1396
1397
1398     editSField(GeometryOutputTypeFieldMask);
1399
1400     return returnValue;
1401 }
1402
1403
1404 #ifdef OSG_MT_CPTR_ASPECT
1405 void ShaderProgramChunkBase::execSyncV(      FieldContainer    &oFrom,
1406                                         ConstFieldMaskArg  whichField,
1407                                         AspectOffsetStore &oOffsets,
1408                                         ConstFieldMaskArg  syncMode,
1409                                   const UInt32             uiSyncInfo)
1410 {
1411     ShaderProgramChunk *pThis = static_cast<ShaderProgramChunk *>(this);
1412
1413     pThis->execSync(static_cast<ShaderProgramChunk *>(&oFrom),
1414                     whichField,
1415                     oOffsets,
1416                     syncMode,
1417                     uiSyncInfo);
1418 }
1419 #endif
1420
1421
1422 #ifdef OSG_MT_CPTR_ASPECT
1423 FieldContainer *ShaderProgramChunkBase::createAspectCopy(
1424     const FieldContainer *pRefAspect) const
1425 {
1426     ShaderProgramChunk *returnValue;
1427
1428     newAspectCopy(returnValue,
1429                   dynamic_cast<const ShaderProgramChunk *>(pRefAspect),
1430                   dynamic_cast<const ShaderProgramChunk *>(this));
1431
1432     return returnValue;
1433 }
1434 #endif
1435
1436 void ShaderProgramChunkBase::resolveLinks(void)
1437 {
1438     Inherited::resolveLinks();
1439
1440     static_cast<ShaderProgramChunk *>(this)->clearVertexShaders();
1441
1442     static_cast<ShaderProgramChunk *>(this)->clearTessControlShaders();
1443
1444     static_cast<ShaderProgramChunk *>(this)->clearTessEvaluationShaders();
1445
1446     static_cast<ShaderProgramChunk *>(this)->clearGeometryShaders();
1447
1448     static_cast<ShaderProgramChunk *>(this)->clearFragmentShaders();
1449
1450
1451 }
1452
1453
1454 OSG_END_NAMESPACE