Source/Contrib/CgFXMaterial/OSGCgFXMaterial.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *               Copyright (C) 2000-2002 by the OpenSG Forum                 *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 //---------------------------------------------------------------------------
  40 //  Includes
  41 //---------------------------------------------------------------------------
  42
  43 #include <stdlib.h>
  44 #include <stdio.h>
  45
  46 #include "OSGConfig.h"
  47
  48 #include "OSGCgFXMaterial.h"
  49 #include "OSGCgFXTechnique.h"
  50
  51 #include "OSGSceneFileHandler.h"
  52 #include "OSGFileSystem.h"
  53 #include "OSGImageFileHandler.h"
  54 #include "OSGNameAttachment.h"
  55 #include "OSGTextureObjChunk.h"
  56
  57 #include "OSGShaderVariableBool.h"
  58 #include "OSGShaderVariableInt.h"
  59 #include "OSGShaderVariableReal.h"
  60
  61 #include "OSGShaderVariableVec2f.h"
  62 #include "OSGShaderVariableVec3f.h"
  63 #include "OSGShaderVariableVec4f.h"
  64
  65 #include "OSGShaderVariableMatrix.h"
  66
  67 #include "OSGCgFXVariableTexObj.h"
  68
  69 OSG_BEGIN_NAMESPACE
  70
  71 /*! \class osg::CGFXMaterial
  72 */
  73
  74 /***************************************************************************\
  75  *                           Class variables                               *
  76 \***************************************************************************/
  77
  78 const std::string CgFXMaterial::FALBACK_MATERIAL_TECHNIQUE_NAME =
  79     std::string("FALBACK_MATERIAL");
  80
  81 /***************************************************************************\
  82  *                           Class methods                                 *
  83 \***************************************************************************/
  84
  85 void CgFXMaterial::initMethod(InitPhase ePhase)
  86 {
  87     Inherited::initMethod(ePhase);
  88 }
  89
  90 void CgFXMaterial::resolveLinks(void)
  91 {
  92     Inherited::resolveLinks();
  93 }
  94
  95 /***************************************************************************\
  96  *                           Instance methods                              *
  97 \***************************************************************************/
  98
  99 /*-------------------------------------------------------------------------*\
 100  -  private                                                                 -
 101 \*-------------------------------------------------------------------------*/
 102
 103 /*----------------------- constructors & destructors ----------------------*/
 104
 105 CgFXMaterial::CgFXMaterial(void) :
 106      Inherited              (     ),
 107     _pCGcontext             (NULL ),
 108     _pCGeffect              (NULL ),
 109     _pTechIdx               (    0),
 110     _mDelayTextureExtraction(false),
 111     _bForceUseFallback      (false)
 112 {
 113     this->markFieldsThreadLocal ((Self::MapCacheFieldMask        |
 114                                   Self::FallbackMaterialFieldMask));
 115     this->markFieldsClusterLocal((Self::MapCacheFieldMask        |
 116                                   Self::FallbackMaterialFieldMask));
 117 }
 118
 119 CgFXMaterial::CgFXMaterial(const CgFXMaterial &source) :
 120      Inherited              (source                         ),
 121     _pCGcontext             (NULL                           ),
 122     _pCGeffect              (NULL                           ),
 123     _pTechIdx               (source._pTechIdx               ),
 124     _mDelayTextureExtraction(source._mDelayTextureExtraction),
 125     _bForceUseFallback      (source._bForceUseFallback      )
 126 {
 127     this->markFieldsThreadLocal ((Self::MapCacheFieldMask        |
 128                                   Self::FallbackMaterialFieldMask));
 129     this->markFieldsClusterLocal((Self::MapCacheFieldMask        |
 130                                   Self::FallbackMaterialFieldMask));
 131 }
 132
 133 CgFXMaterial::~CgFXMaterial(void)
 134 {
 135 }
 136
 137 void CgFXMaterial::onCreate (const CgFXMaterial *source)
 138 {
 139     Inherited::onCreate(source);
 140
 141     if(GlobalSystemState == Startup)
 142         return;
 143
 144     setGLId(Window::registerGLObject(
 145                 boost::bind(&CgFXMaterial::handleGL,
 146                             CgFXMaterialMTUncountedPtr(this),
 147                             _1, _2, _3, _4),
 148                 &CgFXMaterial::handleDestroyGL));
 149 }
 150
 151 void CgFXMaterial::onDestroy(UInt32 uiContainerId)
 152 {
 153     if(getGLId() > 0)
 154         Window::destroyGLObject(getGLId(), 1);
 155
 156     Inherited::onDestroy(uiContainerId);
 157 }
 158
 159 bool CgFXMaterial::isTransparent(void) const
 160 {
 161     // not sure, CHECK_TOOLBOX_MERGE
 162     //return true;
 163
 164     return false;
 165 }
 166
 167 UInt32 CgFXMaterial::handleGL(DrawEnv                 *pEnv,
 168                               UInt32                   osgId,
 169                               Window::GLObjectStatusE  mode,
 170                               UInt64                   uiOptions)
 171
 172 {
 173     if(mode == Window::initialize)
 174     {
 175         Window::GLObjectId glId =
 176             reinterpret_cast<Window::GLObjectId>(_pCGcontext);
 177
 178         pEnv->getWindow()->setGLObjectId(osgId, glId);
 179
 180 #if OSG_CGFX_DUMP_DEBUG
 181         fprintf( stderr, "setting gl id %" PRIUSize " | %p\n",
 182                  glId,
 183                 _pCGcontext);
 184 #endif
 185     }
 186     else if(mode == Window::reinitialize)
 187     {
 188         //Window::GLObjectId oldGlId = pEnv->getWindow()->getGLObjectId(osgId);
 189
 190         //Window::GLObjectId glId =
 191             //reinterpret_cast<Window::GLObjectId>(_pCGcontext);
 192
 193         //OSG_ASSERT(oldGlId != glId);
 194
 195         //CGcontext pOldCGcontext = reinterpret_cast<CGcontext>(oldGlId);
 196
 197 //#if OSG_CGFX_DUMP_DEBUG
 198         //fprintf(stderr, "destroying gl id %"PRIUSize" | %p\n",
 199                 //oldGlId,
 200                 //pOldCGcontext);
 201 //#endif
 202
 203         //if(pOldCGcontext != NULL)
 204         //{
 205             //cgDestroyContext(pOldCGcontext);
 206         //}
 207
 208         //pEnv->getWindow()->setGLObjectId(osgId, glId);
 209
 210 //#if OSG_CGFX_DUMP_DEBUG
 211         //fprintf(stderr, "setting gl id %"PRIUSize" | %p\n",
 212                 //glId,
 213                //_pCGcontext);
 214 //#endif
 215     }
 216
 217     return 0;
 218 }
 219
 220 void CgFXMaterial::handleDestroyGL(DrawEnv                 *pEnv,
 221                                    UInt32                   osgId,
 222                                    Window::GLObjectStatusE  mode)
 223 {
 224     Window* win = pEnv->getWindow();
 225
 226     if(mode == Window::destroy)
 227     {
 228         Window::GLObjectId glId = win->getGLObjectId(osgId);
 229
 230         CGcontext pCGcontext = reinterpret_cast<CGcontext>(glId);
 231
 232         fprintf(stderr, "destroying gl id %" PRIUSize "\n",
 233                 glId);
 234
 235         if(pCGcontext != NULL)
 236         {
 237             cgDestroyContext(pCGcontext);
 238
 239             CgFXMaterial::checkForCgError("cgDestroyContext", NULL);
 240         }
 241
 242         win->setGLObjectId(osgId, 0);
 243     }
 244 }
 245
 246 /*----------------------------- class specific ----------------------------*/
 247
 248 void CgFXMaterial::changed(ConstFieldMaskArg whichField,
 249                            UInt32            origin,
 250                            BitVector         detail)
 251 {
 252
 253     if(0x0000 != (whichField & EffectFileFieldMask))
 254     {
 255         this->readEffectFile();
 256     }
 257
 258     if(0x0000 != (whichField & SelectedTechniqueFieldMask))
 259     {
 260         this->setActiveTechnique(getSelectedTechnique());
 261     }
 262
 263     if(0x0000 != (whichField & EffectStringFieldMask))
 264     {
 265         //Inherited::resolveLinks();
 266
 267         this->processEffectString();
 268
 269         Window::reinitializeGLObject(getGLId());
 270     }
 271
 272     if(0x0000 != (whichField & VariablesFieldMask))
 273     {
 274         if(detail != 0x0001)
 275         {
 276             updateUniformVariables();
 277         }
 278     }
 279
 280     if(0x0000 != (whichField & TechniquesFieldMask) ||
 281        0x0000 != (whichField & SortKeyFieldMask))
 282     {
 283         //Update the sort key of all the techniques
 284         MFTechniquesType::const_iterator tIt  = _mfTechniques.begin();
 285         MFTechniquesType::const_iterator tEnd = _mfTechniques.end  ();
 286
 287         for(; tIt != tEnd; ++tIt)
 288         {
 289             (*tIt)->setSortKey(getSortKey());
 290         }
 291     }
 292
 293     if(0x0000 != (whichField & (TreatTechniquesAsVariantsFieldMask |
 294                                 TechniquesFieldMask                )))
 295     {
 296         Inherited::clearElements();
 297
 298         if(getTreatTechniquesAsVariants() == true)
 299         {
 300             Inherited::addElement(getFallbackMaterial(),
 301                                   RenderPropertiesPool::the()->getDefault());
 302
 303             MaterialMapKey TechniqueKey;
 304
 305             std::vector<std::string> TechNames = getAvailableTechniques();
 306
 307             for(UInt32 i = 0; i < TechNames.size(); ++i)
 308             {
 309                 TechniqueKey =
 310                     RenderPropertiesPool::the()->getFrom1(TechNames[i].c_str());
 311
 312                 Inherited::addElement(getTechnique(TechNames[i]), TechniqueKey);
 313             }
 314         }
 315     }
 316
 317     Inherited::changed(whichField, origin, detail);
 318 }
 319
 320 void CgFXMaterial::dump(      UInt32    ,
 321                         const BitVector ) const
 322 {
 323     SLOG << "Dump CgFXMaterial NI" << std::endl;
 324 }
 325
 326 PrimeMaterial *CgFXMaterial::finalize(      MaterialMapKey  oKey,
 327                                       const StateOverride  *pOverrides,
 328                                             Window         *pWin      )
 329 {
 330     PrimeMaterial *returnValue = NULL;
 331
 332     if(pWin == NULL)
 333         return returnValue;
 334
 335     if(_bForceUseFallback == true)
 336         return getFallbackMaterial();
 337
 338     DrawEnv oEnv;
 339
 340     oEnv.setWindow(pWin);
 341
 342     pWin->validateGLObject(getGLId(), &oEnv);
 343
 344     if(getTreatTechniquesAsVariants() == true)
 345     {
 346         returnValue = Inherited::finalize(oKey, pOverrides, pWin);
 347
 348         if((dynamic_cast<CgFXTechnique *>(returnValue) == NULL) ||
 349            (dynamic_cast<CgFXTechnique *>(returnValue)->validate(this, &oEnv)))
 350         {
 351             return returnValue;
 352         }
 353     }
 354     else
 355     {
 356         if(_pTechIdx < _mfTechniques.size() &&
 357            _mfTechniques[_pTechIdx]->validate(this, &oEnv) == true)
 358         {
 359             return _mfTechniques[_pTechIdx];
 360         }
 361     }
 362
 363     // If the selected technique did not validate, pick the first one that
 364     // does
 365     MFTechniquesType::const_iterator tIt  = _mfTechniques.begin();
 366     MFTechniquesType::const_iterator tEnd = _mfTechniques.end  ();
 367
 368     for(; tIt != tEnd; ++tIt)
 369     {
 370         if((*tIt)->validate(this, &oEnv) == true)
 371         {
 372             returnValue = *tIt;
 373
 374             break;
 375         }
 376     }
 377
 378     return returnValue;
 379 }
 380
 381 /*---------------------------------- Access -------------------------------*/
 382
 383
 384 /*------------------------------------ Set --------------------------------*/
 385
 386 bool CgFXMaterial::checkForCgError(const Char8     *szSituation,
 387                                          CGcontext  pCGcontext )
 388 {
 389     CGerror error;
 390
 391     //Get the last error string and value
 392     const Char8 *string = cgGetLastErrorString(&error);
 393
 394     //Was there an error
 395     if(error != CG_NO_ERROR)
 396     {
 397         //Log the error
 398         SWARNING << "CgfxMaterial Cgfx Error: " << szSituation << ": "
 399                  << string << std::endl;
 400
 401         //Give more detailed informatino if there was a compile error
 402         if(error == CG_COMPILER_ERROR)
 403         {
 404             SWARNING << cgGetLastListing(pCGcontext) << std::endl;
 405         }
 406
 407         //Clear the error
 408         cgGetError();
 409
 410         return true;
 411     }
 412
 413     return false;
 414 }
 415
 416 /*------------------------------------ Get --------------------------------*/
 417
 418 void CgFXMaterial::readEffectFile(void)
 419 {
 420
 421     if(_sfEffectFile.getValue().empty() == true)
 422         return;
 423
 424     const Char8 *szTmpCurrentDir = Directory::getCurrent();
 425
 426     std::string szCurrentDir = szTmpCurrentDir;
 427
 428     delete [] szTmpCurrentDir;
 429
 430     PathHandler *pPathHandler = SceneFileHandler::the()->getPathHandler();
 431
 432     std::string szFullFilePath;
 433
 434     if(pPathHandler != NULL)
 435     {
 436         pPathHandler->pushState();
 437
 438         pPathHandler->push_backPath(".");
 439         pPathHandler->push_backPath(szCurrentDir.c_str());
 440
 441         szFullFilePath =
 442             pPathHandler->findFile(_sfEffectFile.getValue().c_str());
 443
 444         pPathHandler->popState();
 445     }
 446     else
 447     {
 448         szFullFilePath = _sfEffectFile.getValue();
 449     }
 450
 451 #if 0
 452     fprintf(stderr, "Read effect from %s\n",
 453             szFullFilePath.c_str());
 454 #endif
 455
 456     std::string szPath = szFullFilePath;
 457
 458     while(szPath.length()             >   0  &&
 459           szPath[szPath.length() - 1] != '/' &&
 460           szPath[szPath.length() - 1] != '\\'  )
 461     {
 462         szPath.resize(szPath.length() - 1);
 463     }
 464
 465     if(szPath.empty())
 466         szPath = ".";
 467
 468 #if 0
 469     fprintf(stderr, "use path %s\n", szPath.c_str());
 470 #endif
 471
 472     FILE *pFile = fopen(szFullFilePath.c_str(), "rb");
 473
 474     if(pFile == NULL)
 475         return;
 476
 477     fseek(pFile, 0, SEEK_END);
 478
 479     long lFileSize = ftell(pFile);
 480
 481     fseek(pFile, 0, SEEK_SET);
 482
 483     std::string &szData = editEffectString();
 484
 485     szData.erase();
 486     szData.resize(lFileSize);
 487
 488     fread(&(szData[0]), 1, lFileSize, pFile);
 489
 490     fclose(pFile);
 491 }
 492
 493 void CgFXMaterial::initContext(void)
 494 {
 495     checkForCgError("precheck", _pCGcontext);
 496
 497     if(_pCGcontext != NULL)
 498     {
 499         //Already initialized
 500         return;
 501     }
 502
 503     _pCGcontext = cgCreateContext();
 504
 505     if( checkForCgError("Creating Cg Context", _pCGcontext) == true ||
 506        _pCGcontext                                          == NULL  )
 507     {
 508         return;
 509     }
 510
 511     cgGLRegisterStates            (_pCGcontext         );
 512     cgGLSetManageTextureParameters(_pCGcontext, CG_TRUE);
 513
 514     if(checkForCgError("Registering GL States", _pCGcontext) == true)
 515     {
 516         return;
 517     }
 518
 519 #if 0
 520 #if CG_VERSION_NUM >= 2100
 521     registerIncludeCallback( (OSGCGcontext)context, this );
 522     cgSetCompilerIncludeCallback( context,
 523                                   CgFXMaterial::checkForCgError("",
 524                                                                 _pCGcontext);
 525                                   (CGIncludeCallbackFunc)cgIncludeCallback );
 526 #endif
 527 #endif
 528 }
 529
 530 void CgFXMaterial::processEffectString(void)
 531 {
 532     checkForCgError("precheck", _pCGcontext);
 533
 534     if(_sfEffectString.getValue().empty() == true)
 535         return;
 536
 537     initContext();
 538
 539     // we have to transform _compilerOptions to an array of
 540     // const char* to feed it to cgCreateEffect
 541     std::vector<const char *> vOptions(_mfCompilerOptions.size());
 542
 543     for(UInt32 i = 0; i < _mfCompilerOptions.size(); ++i)
 544         vOptions[i] = _mfCompilerOptions[i].c_str();
 545
 546     vOptions.push_back(NULL);
 547
 548     const char **pRawOptions = &(vOptions[0]);
 549
 550     if(_pCGeffect != NULL)
 551     {
 552         //Destroy the effect
 553         cgDestroyEffect(_pCGeffect);
 554
 555         if( checkForCgError("Destroying Cg Effect", _pCGcontext) == true ||
 556            _pCGeffect                                            == NULL )
 557         {
 558             return;
 559         }
 560     }
 561
 562     _pCGeffect = cgCreateEffect(_pCGcontext,
 563                                 _sfEffectString.getValue().c_str(),
 564                                  pRawOptions                      );
 565
 566     if( checkForCgError("Creating Cg Effect", _pCGcontext) == true ||
 567        _pCGeffect                                          == NULL )
 568     {
 569         return;
 570     }
 571
 572     //Any Compile warnings
 573     const char *CompileWarnings = cgGetLastListing(_pCGcontext);
 574
 575     if(CompileWarnings != NULL)
 576     {
 577         SWARNING << CompileWarnings << std::endl;
 578     }
 579
 580     CGtechnique pFirstTechnique = cgGetFirstTechnique(_pCGeffect);
 581
 582     CgFXMaterial::checkForCgError("pFirstTechnique", _pCGcontext);
 583
 584     if(pFirstTechnique == NULL)
 585         return;
 586
 587     CGannotation pVarAnno  =
 588         cgGetNamedTechniqueAnnotation(pFirstTechnique,
 589                                       "treatTechniqueAsVariant");
 590
 591     CgFXMaterial::checkForCgError("cgGetNamedTechniqueAnnotation", _pCGcontext);
 592
 593     if(pVarAnno != NULL)
 594     {
 595 #if 0
 596         fprintf(stderr, "got var anno\n");
 597 #endif
 598
 599         int iNVals = 0;
 600
 601         const int *pTechVar = cgGetBooleanAnnotationValues( pVarAnno,
 602                                                            &iNVals  );
 603
 604         CgFXMaterial::checkForCgError("cgGetBooleanAnnotationValues",
 605                                       _pCGcontext);
 606
 607         if(pTechVar != NULL)
 608         {
 609 #if 0
 610             fprintf(stderr, "got tech var : %d\n", *pTechVar);
 611 #endif
 612
 613             setTreatTechniquesAsVariants((*pTechVar) != 0);
 614         }
 615     }
 616
 617     // we might not want to extract the parameters just yet,
 618     // check if this is the case and if so, skip parameter extraction
 619     extractParameters();
 620
 621     CGtechnique pCGTech = cgGetFirstTechnique(_pCGeffect);
 622
 623     CgFXMaterial::checkForCgError("cgGetFirstTechnique", _pCGcontext);
 624
 625     //Remove previous techniques
 626     clearTechniques();
 627
 628     while(pCGTech != NULL)
 629     {
 630 #if 0
 631         SLOG << "add Technique : "
 632              << cgGetTechniqueName(pCGTech) << std::endl;
 633 #endif
 634
 635         CgFXTechniqueUnrecPtr pTechnique = CgFXTechnique::create();
 636
 637         pTechnique->setTechnique(pCGTech);
 638
 639         this->pushToTechniques(pTechnique);
 640
 641         pCGTech = cgGetNextTechnique(pCGTech);
 642
 643         CgFXMaterial::checkForCgError("cgGetNextTechnique", _pCGcontext);
 644     }
 645
 646     setActiveTechnique(getSelectedTechnique());
 647 }
 648
 649 CgFXTechnique *CgFXMaterial::getTechnique(
 650     const std::string& techniqueName) const
 651 {
 652     CGtechnique tech = cgGetNamedTechnique(_pCGeffect, techniqueName.c_str());
 653
 654     CgFXMaterial::checkForCgError("cgGetNamedTechnique", _pCGcontext);
 655
 656     if(tech != NULL)
 657     {
 658         for(UInt32 i = 0; i < _mfTechniques.size(); ++i)
 659         {
 660             if(tech == getTechniques(i)->_pCGTechnique)
 661             {
 662                 return getTechniques(i);
 663             }
 664         }
 665     }
 666
 667     return NULL;
 668 }
 669
 670 bool CgFXMaterial::setActiveTechnique(const std::string &techniqueName)
 671 {
 672     // if we don't have a valid effect yet, store the string and try
 673     // again after the effect is loaded up.
 674     if(_pCGeffect == NULL && getSelectedTechnique() != techniqueName)
 675     {
 676         editSelectedTechnique() = techniqueName;
 677     }
 678     // is this a valid technique name?
 679     CGtechnique pTech = cgGetNamedTechnique(_pCGeffect, techniqueName.c_str());
 680
 681     CgFXMaterial::checkForCgError("cgGetNamedTechnique", _pCGcontext);
 682
 683     if(pTech != NULL)
 684     { // if so, find the index of the technique to use for this material
 685         for(_pTechIdx = 0; _pTechIdx < _mfTechniques.size(); ++_pTechIdx)
 686         {
 687             if(pTech == _mfTechniques[_pTechIdx]->_pCGTechnique)
 688             {
 689                 _bForceUseFallback = false;
 690
 691                 return true;
 692             }
 693         }
 694
 695         _bForceUseFallback = false;
 696
 697         return false;
 698     }
 699     else if(techniqueName.compare(FALBACK_MATERIAL_TECHNIQUE_NAME) == 0)
 700     {
 701         //Special case: if the Technique is the Fallback material technique
 702         //name. Then disable CgFX and use the fallback material
 703
 704         _bForceUseFallback = true;
 705
 706         return false;
 707     }
 708     else
 709     {
 710         // if the technique name wasn't valid, we just use
 711         // the default behavior (use the first valid technique)
 712
 713         _bForceUseFallback = false;
 714
 715         return false;
 716     }
 717 }
 718
 719 /**
 720 *   Function to get the names of all of the available techniques for this
 721 *   material.
 722 *
 723 */
 724 std::vector<std::string> CgFXMaterial::getAvailableTechniques(void) const
 725 {
 726     std::vector<std::string> techNames;
 727
 728     for(UInt32 i = 0; i < _mfTechniques.size(); ++i)
 729     {
 730         std::string curTechName =
 731             cgGetTechniqueName(_mfTechniques[i]->_pCGTechnique);
 732
 733         CgFXMaterial::checkForCgError("cgGetTechniqueName", _pCGcontext);
 734
 735         if(curTechName.compare("") != 0)
 736             techNames.push_back(curTechName);
 737     }
 738
 739     return techNames;
 740 }
 741
 742 void CgFXMaterial::extractParameters(void)
 743 {
 744
 745 #if OSG_CGFX_DUMP_DEBUG
 746     checkForCgError("extract precheck", _pCGcontext);
 747 #endif
 748
 749     CGparameter pParam = cgGetFirstEffectParameter(_pCGeffect);
 750
 751     CgFXMaterial::checkForCgError("cgGetFirstEffectParameter", _pCGcontext);
 752
 753     if(pParam != NULL)
 754     {
 755
 756 #if OSG_CGFX_DUMP_DEBUG
 757         fprintf(stderr, "Effect parameter : \n");
 758 #endif
 759
 760         editStateVariables() = 0x0000;
 761     }
 762
 763     while(pParam)
 764     {
 765         CGtype oParamType      = cgGetParameterType   (pParam);
 766
 767         CgFXMaterial::checkForCgError("cgGetParameterType", _pCGcontext);
 768
 769         UInt32 uiNumRows       = cgGetParameterRows   (pParam);
 770
 771         CgFXMaterial::checkForCgError("cgGetParameterRows", _pCGcontext);
 772
 773         UInt32 uiNumCols       = cgGetParameterColumns(pParam);
 774
 775         CgFXMaterial::checkForCgError("cgGetParameterColumns", _pCGcontext);
 776
 777         UInt32 uiNumComponents = uiNumRows * uiNumCols;
 778
 779         std::string szParamName     =
 780             cgGetParameterName(pParam)     ? cgGetParameterName(pParam)    : "";
 781
 782         std::string szParamSemantic =
 783             cgGetParameterSemantic(pParam) ? cgGetParameterSemantic(pParam): "";
 784
 785
 786         if(szParamSemantic.empty() == false)
 787         {
 788             bool bFoundSemanticParam = false;
 789
 790             if(osgStringCaseCmp(szParamSemantic.c_str(), "PROJECTION") == 0)
 791             {
 792                 editStateVariables() |= CgProjectionMask;
 793
 794                 _vStateVarNames[CgProjection] = szParamName;
 795
 796                 bFoundSemanticParam = true;
 797             }
 798
 799             else if(osgStringCaseCmp(szParamSemantic.c_str(),
 800                                      "WORLDVIEWPROJECTION"  ) == 0)
 801             {
 802                 editStateVariables() |= CgModelViewProjectionMask;
 803
 804                 _vStateVarNames[CgModelViewProjection] = szParamName;
 805
 806                 bFoundSemanticParam = true;
 807             }
 808             else if(osgStringCaseCmp(szParamSemantic.c_str(),
 809                                      "MODELVIEWPROJECTION"  ) == 0)
 810             {
 811                 editStateVariables() |= CgModelViewProjectionMask;
 812
 813                 _vStateVarNames[CgModelViewProjection] = szParamName;
 814
 815                 bFoundSemanticParam = true;
 816             }
 817
 818
 819             // -------------
 820             // World
 821             // -------------
 822             else if(osgStringCaseCmp(szParamSemantic.c_str(), "WORLD") == 0)
 823             {
 824                 editStateVariables() |= CgModelMask;
 825
 826                 _vStateVarNames[CgModel] = szParamName;
 827
 828                 bFoundSemanticParam = true;
 829             }
 830             else if(osgStringCaseCmp(szParamSemantic.c_str(), "WORLDI") == 0)
 831             {
 832                 editStateVariables() |= CgModelIMask;
 833
 834                 _vStateVarNames[CgModelI] = szParamName;
 835
 836                 bFoundSemanticParam = true;
 837             }
 838             else if(osgStringCaseCmp(szParamSemantic.c_str(),
 839                                      "WORLDINVERSE") == 0   )
 840             {
 841                 editStateVariables() |= CgModelIMask;
 842
 843                 _vStateVarNames[CgModelI] = szParamName;
 844
 845                 bFoundSemanticParam = true;
 846             }
 847             else if(osgStringCaseCmp(szParamSemantic.c_str(), "WORLDIT") == 0)
 848             {
 849                 editStateVariables() |= CgModelITMask;
 850
 851                 _vStateVarNames[CgModelIT] = szParamName;
 852
 853                 bFoundSemanticParam = true;
 854             }
 855             else if(osgStringCaseCmp(szParamSemantic.c_str(),
 856                                      "WORLDINVERSETRANSPOSE") == 0)
 857             {
 858                 editStateVariables() |= CgModelITMask;
 859
 860                 _vStateVarNames[CgModelIT] = szParamName;
 861
 862                 bFoundSemanticParam = true;
 863             }
 864
 865
 866             // -------------
 867             // Model
 868             // -------------
 869             else if(osgStringCaseCmp(szParamSemantic.c_str(), "MODEL") == 0)
 870             {
 871                 editStateVariables() |= CgModelMask;
 872
 873                 _vStateVarNames[CgModel] = szParamName;
 874
 875                 bFoundSemanticParam = true;
 876             }
 877             else if(osgStringCaseCmp(szParamSemantic.c_str(), "MODELI") == 0)
 878             {
 879                 editStateVariables() |= CgModelIMask;
 880
 881                 _vStateVarNames[CgModelI] = szParamName;
 882
 883                 bFoundSemanticParam = true;
 884             }
 885             else if(osgStringCaseCmp(szParamSemantic.c_str(),
 886                                      "MODELINVERSE"         ) == 0)
 887             {
 888                 editStateVariables() |= CgModelIMask;
 889
 890                 _vStateVarNames[CgModelI] = szParamName;
 891
 892                 bFoundSemanticParam = true;
 893             }
 894             else if(osgStringCaseCmp(szParamSemantic.c_str(), "MODELIT") == 0)
 895             {
 896                 editStateVariables() |= CgModelITMask;
 897
 898                 _vStateVarNames[CgModelIT] = szParamName;
 899
 900                 bFoundSemanticParam = true;
 901             }
 902             else if(osgStringCaseCmp(szParamSemantic.c_str(),
 903                                      "MODELINVERSERTRANSPOSE") == 0)
 904             {
 905                 editStateVariables() |= CgModelITMask;
 906
 907                 _vStateVarNames[CgModelIT] = szParamName;
 908
 909                 bFoundSemanticParam = true;
 910             }
 911
 912
 913             // -------------
 914             // WorldView
 915             // -------------
 916             else if(osgStringCaseCmp(szParamSemantic.c_str(), "WORLDVIEW") == 0)
 917             {
 918                 editStateVariables() |= CgModelViewMask;
 919
 920                 _vStateVarNames[CgModelView] = szParamName;
 921
 922                 bFoundSemanticParam = true;
 923             }
 924             else if(osgStringCaseCmp(szParamSemantic.c_str(),
 925                                      "WORLDVIEWI"           ) == 0)
 926             {
 927                 editStateVariables() |= CgModelViewIMask;
 928
 929                 _vStateVarNames[CgModelViewI] = szParamName;
 930
 931                 bFoundSemanticParam = true;
 932             }
 933             else if(osgStringCaseCmp(szParamSemantic.c_str(),
 934                                      "WORLDVIEWINVERSE"     ) == 0)
 935             {
 936                 editStateVariables() |= CgModelViewIMask;
 937
 938                 _vStateVarNames[CgModelViewI] = szParamName;
 939
 940                 bFoundSemanticParam = true;
 941             }
 942             else if(osgStringCaseCmp(szParamSemantic.c_str(),
 943                                      "WORLDVIEWIT"          ) == 0)
 944             {
 945                 editStateVariables() |= CgModelViewITMask;
 946
 947                 _vStateVarNames[CgModelViewIT] = szParamName;
 948
 949                 bFoundSemanticParam = true;
 950             }
 951             else if(osgStringCaseCmp(szParamSemantic.c_str(),
 952                                      "WORLDVIEWINVERSETRANSPOSE") == 0)
 953             {
 954                 editStateVariables() |= CgModelViewITMask;
 955
 956                 _vStateVarNames[CgModelViewIT] = szParamName;
 957
 958                 bFoundSemanticParam = true;
 959             }
 960
 961
 962             // -------------
 963             // ModelView
 964             // -------------
 965             else if(osgStringCaseCmp(szParamSemantic.c_str(), "MODELVIEW") == 0)
 966             {
 967                 editStateVariables() |= CgModelViewMask;
 968
 969                 _vStateVarNames[CgModelView] = szParamName;
 970
 971                 bFoundSemanticParam = true;
 972             }
 973             else if(osgStringCaseCmp(szParamSemantic.c_str(),
 974                                      "ModelVIEWI"           ) == 0)
 975             {
 976                 editStateVariables() |= CgModelViewIMask;
 977
 978                 _vStateVarNames[CgModelViewI] = szParamName;
 979
 980                 bFoundSemanticParam = true;
 981             }
 982             else if(osgStringCaseCmp(szParamSemantic.c_str(),
 983                                      "MODELVIEWINVERSE"     ) == 0)
 984             {
 985                 editStateVariables() |= CgModelViewIMask;
 986
 987                 _vStateVarNames[CgModelViewI] = szParamName;
 988
 989                 bFoundSemanticParam = true;
 990             }
 991             else if(osgStringCaseCmp(szParamSemantic.c_str(),
 992                                      "MODELVIEWIT"          ) == 0)
 993             {
 994                 editStateVariables() |= CgModelViewITMask;
 995
 996                 _vStateVarNames[CgModelViewIT] = szParamName;
 997
 998                 bFoundSemanticParam = true;
 999             }
1000             else if(osgStringCaseCmp(szParamSemantic.c_str(),
1001                                      "MODELVIEWINVERSETRANSPOSE") == 0)
1002             {
1003                 editStateVariables() |= CgModelViewITMask;
1004
1005                 _vStateVarNames[CgModelViewIT] = szParamName;
1006
1007                 bFoundSemanticParam = true;
1008             }
1009
1010
1011             // -------------
1012             // View
1013             // -------------
1014             else if(osgStringCaseCmp(szParamSemantic.c_str(), "VIEW") == 0)
1015             {
1016                 editStateVariables() |= CgViewMask;
1017
1018                 _vStateVarNames[CgView] = szParamName;
1019
1020                 bFoundSemanticParam = true;
1021             }
1022             else if(osgStringCaseCmp(szParamSemantic.c_str(), "VIEWI") == 0)
1023             {
1024                 editStateVariables() |= CgViewIMask;
1025
1026                 _vStateVarNames[CgViewI] = szParamName;
1027
1028                 bFoundSemanticParam = true;
1029             }
1030             else if(osgStringCaseCmp(szParamSemantic.c_str(),
1031                                      "VIEWINVERSE"          ) == 0)
1032             {
1033                 editStateVariables() |= CgViewIMask;
1034
1035                 _vStateVarNames[CgViewI] = szParamName;
1036
1037                 bFoundSemanticParam = true;
1038             }
1039             else if(osgStringCaseCmp(szParamSemantic.c_str(), "VIEWIT") == 0)
1040             {
1041                 editStateVariables() |= CgViewITMask;
1042
1043                 _vStateVarNames[CgViewIT] = szParamName;
1044
1045                 bFoundSemanticParam = true;
1046             }
1047             else if(osgStringCaseCmp(szParamSemantic.c_str(),
1048                                      "VIEWINVERSETRANSPOSE" ) == 0)
1049             {
1050                 editStateVariables() |= CgViewITMask;
1051
1052                 _vStateVarNames[CgViewIT] = szParamName;
1053
1054                 bFoundSemanticParam = true;
1055             }
1056
1057             else if(osgStringCaseCmp(szParamSemantic.c_str(),
1058                                      "VIEWPROJECTION"       ) == 0)
1059             {
1060                 editStateVariables() |= CgViewProjectionMask;
1061
1062                 _vStateVarNames[CgViewProjection] = szParamName;
1063
1064                 bFoundSemanticParam = true;
1065             }
1066
1067             // -------------
1068             // Time / Timer
1069             // -------------
1070             else if(osgStringCaseCmp(szParamSemantic.c_str(),
1071                                      "TIME"                 ) == 0)
1072             {
1073                 editStateVariables() |= CgTimeMask;
1074
1075                 _vStateVarNames[CgTime] = szParamName;
1076
1077                 bFoundSemanticParam = true;
1078             }
1079
1080             if(bFoundSemanticParam == true)
1081             {
1082                 pParam = cgGetNextParameter(pParam);
1083
1084                 CgFXMaterial::checkForCgError("cgGetNextParameter",
1085                                               _pCGcontext);
1086                 continue;
1087             }
1088         }
1089
1090         switch(oParamType)
1091         {
1092             case CG_BOOL:
1093             {
1094                 Int32 val;
1095
1096                 if(cgGetParameterValueir(pParam, 1, &val) == 1)
1097                 {
1098                     // check where what values we should be using
1099                     if(this->getParameterValueSource() == CURRENT)
1100                     {   // check if this is already a variable
1101
1102                         Int32 tmp;
1103
1104                         if(this->getUniformVariable(szParamName.c_str(), tmp))
1105                         {   // if it is, set the variable to value we already
1106                             // have for it.
1107                             cgSetParameterValueir( pParam,
1108                                                    uiNumComponents,
1109                                                   &tmp);
1110
1111                             CgFXMaterial::checkForCgError(
1112                                 "cgSetParameterValueir", _pCGcontext);
1113
1114                         } // otherwise use the default value
1115                         else
1116                         {
1117                             this->addUniformVariable(szParamName.c_str(),
1118                                                      (val > 0)          );
1119                         }
1120                     }
1121                     else // use default value from .cgfx file
1122                     {
1123                         this->addUniformVariable(szParamName.c_str(),
1124                                                  (val > 0)          );
1125                     }
1126                 }
1127             }
1128             break;
1129
1130             case CG_INT:
1131             {
1132                 Int32 val;
1133
1134                 if(cgGetParameterValueir(pParam, 1, &val) == 1)
1135                 {
1136                     // check where what values we should be using
1137                     if(this->getParameterValueSource() == CURRENT)
1138                     {   // check if this is already a variable
1139                         Int32 tmp;
1140                         if(this->getUniformVariable(szParamName.c_str(), tmp))
1141                         {   // if it is, set the variable to value we already
1142                             // have for it.
1143                             cgSetParameterValueir( pParam,
1144                                                    uiNumComponents,
1145                                                   &tmp);
1146
1147                             CgFXMaterial::checkForCgError(
1148                                 "cgSetParameterValueir", _pCGcontext);
1149
1150                         } // otherwise use the default value
1151                         else
1152                         {
1153                             this->addUniformVariable(szParamName.c_str(),
1154                                                      val                );
1155                         }
1156                     }
1157                     else // use default value from .cgfx file
1158                     {
1159                         this->addUniformVariable(szParamName.c_str(), val);
1160                     }
1161                 }
1162             }
1163             break;
1164
1165             case CG_FLOAT:
1166             case CG_FLOAT2:
1167             case CG_FLOAT3:
1168             case CG_FLOAT4:
1169             case CG_FLOAT4x4:
1170             {
1171                 switch(uiNumComponents)
1172                 {
1173                     case 1:
1174                     {
1175                         Real32 val;
1176
1177                         if(cgGetParameterValuefr(pParam, 1, &val) == 1)
1178                         {
1179                             // check where what values we should be using
1180                             if(this->getParameterValueSource() == CURRENT)
1181                             {   // check if this is already a variable
1182                                 Real32 tmp;
1183
1184                                 if(this->getUniformVariable(
1185                                        szParamName.c_str(),
1186                                        tmp                ))
1187                                 {   // if it is, set the variable to value we
1188                                     // already have for it.
1189                                     cgSetParameterValuefr( pParam,
1190                                                            uiNumComponents,
1191                                                           &tmp);
1192
1193                                     CgFXMaterial::checkForCgError(
1194                                         "cgSetParameterValuefr", _pCGcontext);
1195                                 } // otherwise use the default value
1196                                 else
1197                                 {
1198                                     this->addUniformVariable(
1199                                         szParamName.c_str(),
1200                                         val )               ;
1201                                 }
1202                             }
1203                             else // use default value from .cgfx file
1204                             {
1205                                 this->addUniformVariable(szParamName.c_str(),
1206                                                          val                );
1207                             }
1208                         }
1209                     }
1210                     break;
1211
1212                     case 2:
1213                     {
1214                         Vec2f val;
1215
1216                         if(cgGetParameterValuefr(pParam,
1217                                                  2,
1218                                                  val.getValues()) == 2)
1219                         {
1220                             // check where what values we should be using
1221                             if(this->getParameterValueSource() == CURRENT)
1222                             {   // check if this is already a variable
1223                                 Vec2f tmp;
1224                                 if(this->getUniformVariable(
1225                                        szParamName.c_str(),
1226                                        tmp                ))
1227                                 {   // if it is, set the variable to value we
1228                                     // already have for it.
1229                                     cgSetParameterValuefr(pParam,
1230                                                           uiNumComponents,
1231                                                           tmp.getValues());
1232
1233                                     CgFXMaterial::checkForCgError(
1234                                         "cgSetParameterValuefr", _pCGcontext);
1235                                 } // otherwise use the default value
1236                                 else
1237                                 {
1238                                     this->addUniformVariable(
1239                                         szParamName.c_str(),
1240                                         val                 );
1241                                 }
1242                             }
1243                             else // use default value from .cgfx file
1244                             {
1245                                 this->addUniformVariable(szParamName.c_str(),
1246                                                          val                );
1247                             }
1248                         }
1249                     }
1250                     break;
1251
1252                     case 3:
1253                     {
1254                         Vec3f val;
1255
1256                         if(cgGetParameterValuefr(pParam,
1257                                                  3,
1258                                                  val.getValues()) == 3)
1259                         {
1260                             // check where what values we should be using
1261                             if(this->getParameterValueSource() == CURRENT)
1262                             {   // check if this is already a variable
1263                                 Vec3f tmp;
1264                                 if(this->getUniformVariable(
1265                                        szParamName.c_str(),
1266                                        tmp                ))
1267                                 {   // if it is, set the variable to value we
1268                                     // already have for it.
1269                                     cgSetParameterValuefr(pParam,
1270                                                           uiNumComponents,
1271                                                           tmp.getValues());
1272
1273                                     CgFXMaterial::checkForCgError(
1274                                         "cgSetParameterValuefr", _pCGcontext);
1275                                 } // otherwise use the default value
1276                                 else
1277                                 {
1278                                     this->addUniformVariable(
1279                                         szParamName.c_str(),
1280                                         val                 );
1281                                 }
1282                             }
1283                             else // use default value from .cgfx file
1284                             {
1285                                 this->addUniformVariable(szParamName.c_str(),
1286                                                          val                );
1287                             }
1288                         }
1289                     }
1290                     break;
1291
1292                     case 4:
1293                     {
1294                         Vec4f val;
1295
1296                         if(cgGetParameterValuefr(pParam,
1297                                                  4,
1298                                                  val.getValues()) == 4)
1299                         {
1300                             // check where what values we should be using
1301                             if(this->getParameterValueSource() == CURRENT)
1302                             {   // check if this is already a variable
1303                                 Vec4f tmp;
1304                                 if(this->getUniformVariable(
1305                                        szParamName.c_str(),
1306                                        tmp                ))
1307                                 {   // if it is, set the variable to value we
1308                                     // already have for it.
1309                                     cgSetParameterValuefr(pParam,
1310                                                           uiNumComponents,
1311                                                           tmp.getValues());
1312
1313                                     CgFXMaterial::checkForCgError(
1314                                         "cgSetParameterValuefr", _pCGcontext);
1315                                 } // otherwise use the default value
1316                                 else
1317                                 {
1318                                     this->addUniformVariable(
1319                                         szParamName.c_str(),
1320                                         val                 );
1321                                 }
1322                             }
1323                             else // use default value from .cgfx file
1324                             {
1325                                 this->addUniformVariable(szParamName.c_str(),
1326                                                          val                );
1327                             }
1328                         }
1329                     }
1330                     break;
1331
1332                     case 16:
1333                     {
1334                         // CHECK cgSetParameterValuefr or cgSetParameterValuefc
1335                         Matrix val;
1336
1337                         if(cgGetParameterValuefr(pParam,
1338                                                  16,
1339                                                  val.getValues()) == 16)
1340                         {
1341                             val.transpose();
1342                             // check where what values we should be using
1343                             if(this->getParameterValueSource() == CURRENT)
1344                             {   // check if this is already a variable
1345                                 Vec4f tmp;
1346                                 if(this->getUniformVariable(
1347                                        szParamName.c_str(),
1348                                        tmp                ))
1349                                 {   // if it is, set the variable to value we
1350                                     // already have for it.
1351                                     cgSetParameterValuefr(pParam,
1352                                                           uiNumComponents,
1353                                                           tmp.getValues());
1354
1355                                     CgFXMaterial::checkForCgError(
1356                                         "cgSetParameterValuefr", _pCGcontext);
1357                                 } // otherwise use the default value
1358                                 else
1359                                 {
1360                                     this->addUniformVariable(
1361                                         szParamName.c_str(),
1362                                         val                 );
1363                                 }
1364                             }
1365                             else // use default value from .cgfx file
1366                             {
1367                                 this->addUniformVariable(szParamName.c_str(),
1368                                                          val                );
1369                             }
1370                         }
1371                     }
1372                     break;
1373                 }
1374             }
1375             break;
1376
1377             case CG_TEXTURE:
1378                 break;
1379
1380             case CG_SAMPLER1D:
1381             case CG_SAMPLER2D:
1382             case CG_SAMPLER3D:
1383             case CG_SAMPLERRECT:
1384             case CG_SAMPLERCUBE:
1385             {
1386                 CgFXVariableTexObjUnrecPtr pVar;
1387                 std::string                szFilename;
1388                 bool                       varIsInitialized = false;
1389                 bool                       readFile         = true;
1390
1391                 if(this->getParameterValueSource() == CURRENT)
1392                 {
1393                     if(this->getVariable(szParamName.c_str()) != NULL)
1394                     {   // use the specified texture
1395                         szFilename =
1396                             dynamic_cast<const CgFXVariableTexObj *>(
1397                                 this->getVariable(
1398                                     szParamName.c_str()))->getFilePath();
1399
1400                         varIsInitialized = true;
1401
1402                         for(UInt32 i = 0; i < getMFTextures()->size(); ++i)
1403                         {
1404                             if(szParamName.compare(
1405                                    getName(getTextures(i))) == 0)
1406                             {   // image file is already loaded and ready to
1407                                 // use, so skip reading it again.
1408                                 readFile = false;
1409                                 break;
1410                             }
1411                         }
1412                     }
1413                 }
1414
1415                 if(szFilename.empty())
1416                 {
1417                     CGannotation pAnno = cgGetNamedParameterAnnotation(pParam,
1418                                                                        "File");
1419
1420                     CgFXMaterial::checkForCgError(
1421                         "cgGetNamedParameterAnnotation", _pCGcontext);
1422
1423                     if(pAnno == NULL)
1424                     {
1425                         pAnno = cgGetNamedParameterAnnotation(pParam,
1426                                                               "ResourceName");
1427
1428                         CgFXMaterial::checkForCgError(
1429                             "cgGetNamedParameterAnnotation", _pCGcontext);
1430                     }
1431
1432                     if(pAnno != NULL)
1433                     {
1434                         szFilename = cgGetStringAnnotationValue(pAnno);
1435
1436                         CgFXMaterial::checkForCgError(
1437                             "cgGetStringAnnotationValue", _pCGcontext);
1438                     }
1439                 }
1440
1441                 if(szFilename.empty())
1442                 {
1443                     CGstateassignment pSamplerState =
1444                         cgGetFirstSamplerStateAssignment(pParam);
1445
1446                     CgFXMaterial::checkForCgError(
1447                         "cgGetFirstSamplerStateAssignment", _pCGcontext);
1448
1449                     if(pSamplerState != NULL)
1450                     {
1451                         // cgGetSamplerStateAssignmentValue
1452                         CGparameter pTParam =
1453                             cgGetTextureStateAssignmentValue(pSamplerState);
1454
1455                         CgFXMaterial::checkForCgError(
1456                             "cgGetTextureStateAssignmentValue", _pCGcontext);
1457
1458                         if(pTParam != NULL)
1459                         {
1460                             CGtype pTParamType = cgGetParameterType(pTParam);
1461
1462                             CgFXMaterial::checkForCgError(
1463                                 "cgGetParameterType", _pCGcontext);
1464
1465                             // get tweakable parameters
1466                             if(cgGetFirstParameterAnnotation(pTParam) != NULL &&
1467                                pTParamType == CG_TEXTURE                       )
1468                             {
1469                                 CGannotation pAnno =
1470                                     cgGetNamedParameterAnnotation(pTParam,
1471                                                                   "File");
1472
1473                                 CgFXMaterial::checkForCgError(
1474                                     "cgGetNamedParameterAnnotation",
1475                                     _pCGcontext);
1476
1477                                 if(pAnno == NULL)
1478                                 {
1479                                     pAnno =
1480                                         cgGetNamedParameterAnnotation(
1481                                             pTParam,
1482                                             "ResourceName");
1483
1484                                     CgFXMaterial::checkForCgError(
1485                                         "cgGetNamedParameterAnnotation",
1486                                         _pCGcontext);
1487                                 }
1488
1489                                 if(pAnno != NULL)
1490                                 {
1491                                     szFilename =
1492                                         cgGetStringAnnotationValue(pAnno);
1493
1494                                     CgFXMaterial::checkForCgError(
1495                                         "cgGetStringAnnotationValue",
1496                                         _pCGcontext);
1497                                 }
1498                             }
1499                         }
1500                     }
1501                 }
1502
1503                 if(readFile)
1504                 {
1505                     Int32 uiSamplerId = -1;
1506
1507                     ImageUnrecPtr pImg =
1508                         ImageFileHandler::the()->read(szFilename.c_str());
1509
1510                     if(pImg != NULL)
1511                     {
1512                         TextureObjChunkUnrecPtr pTexO =
1513                             TextureObjChunk::create();
1514
1515                         setName(pTexO, szParamName);
1516
1517                         pTexO->setImage(pImg);
1518
1519                         this->pushToTextures(pTexO);
1520                     }
1521                     else
1522                     {
1523                         MFTexturesType::const_iterator TexIt =
1524                             this->getMFTextures()->begin();
1525
1526                         for(; TexIt != getMFTextures()->end(); ++TexIt)
1527                         {
1528                             if(szParamName.compare(getName(*TexIt)) == 0)
1529                             {
1530                                 pImg = (*TexIt)->getImage();
1531                                 break;
1532                             }
1533                         }
1534                     }
1535
1536                     if(pImg != NULL && varIsInitialized == false)
1537                     {
1538                         pVar = CgFXVariableTexObj::create();
1539
1540                         pVar->setName    (szParamName);
1541                         this->addVariable(pVar       );
1542                         pVar->setValue   (uiSamplerId);
1543                     }
1544                 }
1545             }
1546             break;
1547
1548             case CG_ARRAY:
1549             {
1550             }
1551             break;
1552
1553             case CG_STRUCT:
1554             {
1555             }
1556             break;
1557
1558             case CG_STRING:
1559             {
1560             }
1561             break;
1562
1563             default:
1564             {
1565                 FWARNING(("CgFXMaterial : Unsupported parameter (%s) type "
1566                           "(%d)!\n",
1567                           szParamName.c_str(),
1568                           oParamType));
1569             }
1570             break;
1571         }
1572
1573         pParam = cgGetNextParameter(pParam);
1574         CgFXMaterial::checkForCgError("cgGetNextParameter", _pCGcontext);
1575     }
1576
1577 #if OSG_CGFX_DUMP_DEBUG
1578     checkForCgError("extract postcheck", _pCGcontext);
1579 #endif
1580 }
1581
1582 void CgFXMaterial::updateUniformVariables(void)
1583 {
1584 #if OSG_CGFX_DUMP_DEBUG
1585     checkForCgError("update precheck", _pCGcontext);
1586 #endif
1587
1588     if(_pCGeffect == NULL)
1589         return; // can't update variables w/out a program.
1590
1591     const ShaderProgramVariables::MFVariablesType       *pMFVars   = NULL;
1592           ShaderProgramVariables::MFVariableChangedType *pMFVarChg = NULL;
1593
1594     if(_sfVariables.getValue() != NULL)
1595     {
1596         pMFVars   = _sfVariables.getValue()->getMFVariables       ();
1597         pMFVarChg = _sfVariables.getValue()->editMFVariableChanged();
1598     }
1599
1600     if(pMFVars == NULL || pMFVars->size() == 0 || pMFVarChg == NULL)
1601     {
1602         return;
1603     }
1604
1605     OSG_ASSERT(pMFVars->size() == pMFVarChg->size());
1606
1607     ShaderProgramVariables::MFVariablesType::const_iterator mVarIt  =
1608         pMFVars->begin();
1609     ShaderProgramVariables::MFVariablesType::const_iterator mVarEnd =
1610         pMFVars->end  ();
1611
1612     ShaderProgramVariables::MFVariableChangedType::iterator mVarChgIt =
1613         pMFVarChg->begin();
1614
1615     for(; mVarIt != mVarEnd; ++mVarIt, ++mVarChgIt)
1616     {
1617         ShaderVariable *pVar = *mVarIt;
1618
1619         if(pVar == NULL)
1620             continue;
1621
1622         if(*mVarChgIt == false)
1623             continue;
1624
1625         *mVarChgIt = false;
1626
1627         CGparameter pParam =
1628             cgGetNamedEffectParameter(_pCGeffect,
1629                                       pVar->getName().c_str());
1630
1631         CgFXMaterial::checkForCgError("cgGetNamedEffectParameter",
1632                                       _pCGcontext);
1633
1634         switch(pVar->getTypeId())
1635         {
1636             case ShaderVariable::SHVTypeBool:
1637             {
1638                 ShaderVariableBool *p =
1639                     dynamic_cast<ShaderVariableBool *>(pVar);
1640
1641                 cgSetParameter1i(pParam, p->getValue() ? 1 : 0);
1642
1643                 CgFXMaterial::checkForCgError("cgSetParameter1i", _pCGcontext);
1644             }
1645             break;
1646
1647             case ShaderVariable::SHVTypeInt:
1648             {
1649                 ShaderVariableInt *p =
1650                     dynamic_cast<ShaderVariableInt *>(pVar);
1651
1652                 cgSetParameter1i(pParam, p->getValue());
1653
1654                 CgFXMaterial::checkForCgError("cgSetParameter1i", _pCGcontext);
1655             }
1656             break;
1657
1658             case ShaderVariable::SHVTypeReal:
1659             {
1660                 ShaderVariableReal *p =
1661                     dynamic_cast<ShaderVariableReal *>(pVar);
1662
1663                 cgSetParameter1f(pParam, p->getValue());
1664
1665                 CgFXMaterial::checkForCgError("cgSetParameter1f", _pCGcontext);
1666             }
1667             break;
1668
1669             case ShaderVariable::SHVTypeVec2f:
1670             {
1671                 ShaderVariableVec2f *p =
1672                     dynamic_cast<ShaderVariableVec2f *>(pVar);
1673
1674                 cgSetParameter2fv(pParam, p->getValue().getValues());
1675
1676                 CgFXMaterial::checkForCgError("cgSetParameter2fv", _pCGcontext);
1677             }
1678             break;
1679
1680             case ShaderVariable::SHVTypeVec3f:
1681             {
1682                 ShaderVariableVec3f *p =
1683                     dynamic_cast<ShaderVariableVec3f *>(pVar);
1684
1685                 cgSetParameter3fv(pParam, p->getValue().getValues());
1686
1687                 CgFXMaterial::checkForCgError("cgSetParameter3fv", _pCGcontext);
1688             }
1689             break;
1690
1691             case ShaderVariable::SHVTypeVec4f:
1692             {
1693                 ShaderVariableVec4f *p =
1694                     dynamic_cast<ShaderVariableVec4f *>(pVar);
1695
1696                 cgSetParameter4fv(pParam, p->getValue().getValues());
1697
1698                 CgFXMaterial::checkForCgError("cgSetParameter4fv", _pCGcontext);
1699             }
1700             break;
1701
1702             case ShaderVariable::SHVTypeMatrix:
1703             {
1704                 ShaderVariableMatrix *p =
1705                     dynamic_cast<ShaderVariableMatrix *>(pVar);
1706
1707                 cgSetMatrixParameterfr(pParam, p->getValue().getValues());
1708
1709                 CgFXMaterial::checkForCgError("cgSetMatrixParameterfr",
1710                                               _pCGcontext);
1711             }
1712             break;
1713
1714             default:
1715                 break;
1716         };
1717     }
1718
1719 #if OSG_CGFX_DUMP_DEBUG
1720     checkForCgError("update postcheck", _pCGcontext);
1721 #endif
1722 }
1723
1724 OSG_END_NAMESPACE