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