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