Source/System/State/Shader/Base/OSGShaderProgram.inl

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *               Copyright (C) 2000-2006 by the OpenSG Forum                 *
   6  *                                                                           *
   7  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
   8  *                                                                           *
   9 \*---------------------------------------------------------------------------*/
  10 /*---------------------------------------------------------------------------*\
  11  *                                License                                    *
  12  *                                                                           *
  13  * This library is free software; you can redistribute it and/or modify it   *
  14  * under the terms of the GNU Library General Public License as published    *
  15  * by the Free Software Foundation, version 2.                               *
  16  *                                                                           *
  17  * This library is distributed in the hope that it will be useful, but       *
  18  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  20  * Library General Public License for more details.                          *
  21  *                                                                           *
  22  * You should have received a copy of the GNU Library General Public         *
  23  * License along with this library; if not, write to the Free Software       *
  24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  25  *                                                                           *
  26 \*---------------------------------------------------------------------------*/
  27 /*---------------------------------------------------------------------------*\
  28  *                                Changes                                    *
  29  *                                                                           *
  30  *                                                                           *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35 \*---------------------------------------------------------------------------*/
  36
  37 //---------------------------------------------------------------------------
  38 //  Includes
  39 //---------------------------------------------------------------------------
  40
  41 OSG_BEGIN_NAMESPACE
  42
  43 inline
  44 void ShaderProgram::validate(DrawEnv *pEnv)
  45 {
  46     pEnv->getWindow()->validateGLObject(getGLId(), pEnv);
  47 }
  48
  49 inline
  50 bool ShaderProgram::hasParameter(void)
  51 {
  52     return _mfParameter.size() != 0;
  53 }
  54
  55 inline
  56 bool ShaderProgram::hasAttributes(void)
  57 {
  58     return _mfAttributes.size() != 0;
  59 }
  60
  61 template<class ValueT> inline
  62 bool ShaderProgram::addUniformVariable(const Char8 *name, const ValueT &value)
  63 {
  64     if(_sfVariables.getValue() == NULL)
  65     {
  66         ShaderProgramVariablesUnrecPtr pParam =
  67             ShaderProgramVariables::createDependent(
  68                 this->getFieldFlags()->_bNamespaceMask);
  69
  70         setVariables(pParam);
  71     }
  72
  73 #if 0
  74     return _sfVariables.getValue()->addUniformVariable(
  75         name,
  76         value,
  77         editMFVariableLocations          (),
  78         editMFProceduralVariableLocations());
  79 #else
  80     return _sfVariables.getValue()->addUniformVariable(
  81         name,
  82         value,
  83         NULL,
  84         NULL);
  85 #endif
  86 }
  87
  88 template<class ValueT> inline
  89 bool ShaderProgram::updateUniformVariable(const Char8  *name,
  90                                           const ValueT &value)
  91 {
  92     if(_sfVariables.getValue() == NULL)
  93     {
  94         ShaderProgramVariablesUnrecPtr pParam =
  95             ShaderProgramVariables::createDependent(
  96                 this->getFieldFlags()->_bNamespaceMask);
  97
  98         setVariables(pParam);
  99     }
 100
 101     return _sfVariables.getValue()->updateUniformVariable(name, value);
 102 }
 103
 104 template<class ValueT> inline
 105 bool ShaderProgram::getUniformVariable(const Char8  *name,
 106                                              ValueT &value)
 107 {
 108     if(_sfVariables.getValue() != NULL)
 109     {
 110         return _sfVariables.getValue()->getUniformVariable(name, value);
 111     }
 112
 113     return false;
 114 }
 115
 116 inline
 117 bool ShaderProgram::addUniformBlock(const Char8 *name, UInt32 value)
 118 {
 119     if(_sfVariables.getValue() == NULL)
 120     {
 121         ShaderProgramVariablesUnrecPtr pParam =
 122             ShaderProgramVariables::createDependent(
 123                 this->getFieldFlags()->_bNamespaceMask);
 124
 125         setVariables(pParam);
 126     }
 127
 128 #if 0
 129     return _sfVariables.getValue()->addUniformBlock(
 130         name,
 131         value,
 132         editMFVariableLocations          (),
 133         editMFProceduralVariableLocations());
 134 #else
 135     return _sfVariables.getValue()->addUniformBlock(
 136         name,
 137         value,
 138         NULL,
 139         NULL);
 140 #endif
 141 }
 142
 143 inline
 144 bool ShaderProgram::updateUniformBlock(const Char8  *name, UInt32 value)
 145 {
 146     if(_sfVariables.getValue() == NULL)
 147     {
 148         ShaderProgramVariablesUnrecPtr pParam =
 149             ShaderProgramVariables::createDependent(
 150                 this->getFieldFlags()->_bNamespaceMask);
 151
 152         setVariables(pParam);
 153     }
 154
 155     return _sfVariables.getValue()->updateUniformBlock(name, value);
 156 }
 157
 158 inline
 159 bool ShaderProgram::getUniformBlock(const Char8  *name, UInt32 &value)
 160 {
 161     if(_sfVariables.getValue() != NULL)
 162     {
 163         return _sfVariables.getValue()->getUniformBlock(name, value);
 164     }
 165
 166     return false;
 167 }
 168
 169 inline
 170 bool ShaderProgram::addShaderStorageBlock(const Char8 *name, UInt32 value)
 171 {
 172     if(_sfVariables.getValue() == NULL)
 173     {
 174         ShaderProgramVariablesUnrecPtr pParam =
 175             ShaderProgramVariables::createDependent(
 176                 this->getFieldFlags()->_bNamespaceMask);
 177
 178         setVariables(pParam);
 179     }
 180
 181 #if 0
 182     return _sfVariables.getValue()->addShaderStorageBlock(
 183         name,
 184         value,
 185         editMFVariableLocations          (),
 186         editMFProceduralVariableLocations());
 187 #else
 188     return _sfVariables.getValue()->addShaderStorageBlock(
 189         name,
 190         value,
 191         NULL,
 192         NULL);
 193 #endif
 194 }
 195
 196 inline
 197 bool ShaderProgram::updateShaderStorageBlock(const Char8  *name, UInt32 value)
 198 {
 199     if(_sfVariables.getValue() == NULL)
 200     {
 201         ShaderProgramVariablesUnrecPtr pParam =
 202             ShaderProgramVariables::createDependent(
 203                 this->getFieldFlags()->_bNamespaceMask);
 204
 205         setVariables(pParam);
 206     }
 207
 208     return _sfVariables.getValue()->updateShaderStorageBlock(name, value);
 209 }
 210
 211 inline
 212 bool ShaderProgram::getShaderStorageBlock(const Char8  *name, UInt32 &value)
 213 {
 214     if(_sfVariables.getValue() != NULL)
 215     {
 216         return _sfVariables.getValue()->getShaderStorageBlock(name, value);
 217     }
 218
 219     return false;
 220 }
 221
 222 inline
 223 void ShaderProgram::addDestroyedFunctor(ChangedFunctor func,
 224                                         std::string    createSymbol)
 225 {
 226     ChangedFunctorCallback oTmp;
 227
 228     oTmp._func         = func;
 229     oTmp._createSymbol = createSymbol;
 230
 231     _mfDestroyedFunctors.push_back(oTmp);
 232 }
 233
 234 template<class FunctorT> inline
 235 void ShaderProgram::subDestroyedFunctor(FunctorT func)
 236 {
 237     MFChangedFunctorCallback::iterator       cfIt =
 238         _mfDestroyedFunctors.begin();
 239
 240     MFChangedFunctorCallback::const_iterator cfEnd=
 241         _mfDestroyedFunctors.end();
 242
 243     for(; cfIt != cfEnd; ++cfIt)
 244     {
 245         if(cfIt->_func == func)
 246             break;
 247     }
 248
 249     if(cfIt != cfEnd)
 250         _mfDestroyedFunctors.erase(cfIt);
 251 }
 252
 253 template<class FunctorT> inline
 254 bool ShaderProgram::hasDestroyedFunctor(FunctorT func)
 255 {
 256     bool returnValue = false;
 257
 258     MFChangedFunctorCallback::iterator       cfIt =
 259         _mfDestroyedFunctors.begin();
 260
 261     MFChangedFunctorCallback::const_iterator cfEnd=
 262         _mfDestroyedFunctors.end();
 263
 264
 265     for(; cfIt != cfEnd; ++cfIt)
 266     {
 267         if(cfIt->_func == func)
 268         {
 269             returnValue = true;
 270             break;
 271         }
 272     }
 273
 274     return returnValue;
 275 }
 276
 277 inline
 278 UInt32 ShaderProgram::getNumDestroyedFunctors(void) const
 279 {
 280     return _mfDestroyedFunctors.size32();
 281 }
 282
 283 inline
 284 void ShaderProgram::clearDestroyedFunctors(void)
 285 {
 286     _mfDestroyedFunctors.clear();
 287 }
 288
 289 inline
 290 UInt32 ShaderProgram::getExtIdSHL(void)
 291 {
 292     return _extSHL;
 293 }
 294
 295 inline
 296 UInt32 ShaderProgram::getExtIdCgShader(void)
 297 {
 298     return _extCG;
 299 }
 300
 301 inline
 302 UInt32 ShaderProgram::getExtIdGeometryShader4(void)
 303 {
 304     return _extGeoShader4;
 305 }
 306
 307 inline
 308 UInt32 ShaderProgram::getExtIdGPUShader4(void)
 309 {
 310     return _extGPUShader4;
 311 }
 312
 313 inline
 314 UInt32 ShaderProgram::getExtIdTransformFeedback2(void)
 315 {
 316     return _extTransformFeedback2;
 317 }
 318
 319 inline
 320 UInt32 ShaderProgram::getExtIdUniformBufferObject(void)
 321 {
 322     return _extUniformBufferObject;
 323 }
 324
 325 inline
 326 UInt32 ShaderProgram::getExtIdProgramInterfaceQuery(void)
 327 {
 328     return _extProgramInterfaceQuery;
 329 }
 330
 331 inline
 332 UInt32 ShaderProgram::getExtIdShaderStorageBufferObject(void)
 333 {
 334     return _extShaderStorageBufferObject;
 335 }
 336
 337 inline
 338 UInt32 ShaderProgram::getFuncIdCreateShader(void)
 339 {
 340     return FuncIdCreateShader;
 341 }
 342
 343 inline
 344 UInt32 ShaderProgram::getFuncIdDeleteShader(void)
 345 {
 346     return FuncIdDeleteShader;
 347 }
 348
 349 inline
 350 UInt32 ShaderProgram::getFuncIdShaderSource(void)
 351 {
 352     return FuncIdShaderSource;
 353 }
 354
 355 inline
 356 UInt32 ShaderProgram::getFuncIdCompileShader(void)
 357 {
 358     return FuncIdCompileShader;
 359 }
 360
 361 inline
 362 UInt32 ShaderProgram::getFuncIdAttachShader(void)
 363 {
 364     return FuncIdAttachShader;
 365 }
 366
 367 inline
 368 UInt32 ShaderProgram::getFuncIdGetShaderiv(void)
 369 {
 370     return FuncIdGetShaderiv;
 371 }
 372
 373 inline
 374 UInt32 ShaderProgram::getFuncIdGetShaderInfoLog(void)
 375 {
 376     return FuncIdGetShaderInfoLog;
 377 }
 378
 379 inline
 380 UInt32 ShaderProgram::getFuncIdGetActiveAttrib(void)
 381 {
 382     return FuncIdGetActiveAttrib;
 383 }
 384
 385 inline
 386 UInt32 ShaderProgram::getFuncIdCreateProgram(void)
 387 {
 388     return FuncIdCreateProgram;
 389 }
 390
 391 inline
 392 UInt32 ShaderProgram::getFuncIdDeleteProgram(void)
 393 {
 394     return FuncIdDeleteProgram;
 395 }
 396
 397 inline
 398 UInt32 ShaderProgram::getFuncIdLinkProgram(void)
 399 {
 400     return FuncIdLinkProgram;
 401 }
 402
 403 inline
 404 UInt32 ShaderProgram::getFuncIdGetProgramiv(void)
 405 {
 406     return FuncIdGetProgramiv;
 407 }
 408
 409 inline
 410 UInt32 ShaderProgram::getFuncIdGetProgramInfoLog(void)
 411 {
 412     return FuncIdGetProgramInfoLog;
 413 }
 414
 415 inline
 416 UInt32 ShaderProgram::getFuncIdUseProgram(void)
 417 {
 418     return FuncIdUseProgram;
 419 }
 420
 421
 422 inline
 423 UInt32 ShaderProgram::getFuncIdGetUniformLocation(void)
 424 {
 425     return FuncIdGetUniformLocation;
 426 }
 427
 428 inline
 429 UInt32 ShaderProgram::getFuncIdUniform1i(void)
 430 {
 431     return FuncIdUniform1i;
 432 }
 433
 434 inline
 435 UInt32 ShaderProgram::getFuncIdUniform2i(void)
 436 {
 437     return FuncIdUniform2i;
 438 }
 439
 440 inline
 441 UInt32 ShaderProgram::getFuncIdUniform3i(void)
 442 {
 443     return FuncIdUniform3i;
 444 }
 445
 446 inline
 447 UInt32 ShaderProgram::getFuncIdUniform4i(void)
 448 {
 449     return FuncIdUniform4i;
 450 }
 451
 452
 453 inline
 454 UInt32 ShaderProgram::getFuncIdUniform1ui(void)
 455 {
 456     return FuncIdUniform1ui;
 457 }
 458
 459 inline
 460 UInt32 ShaderProgram::getFuncIdUniform2ui(void)
 461 {
 462     return FuncIdUniform2ui;
 463 }
 464
 465 inline
 466 UInt32 ShaderProgram::getFuncIdUniform3ui(void)
 467 {
 468     return FuncIdUniform3ui;
 469 }
 470
 471 inline
 472 UInt32 ShaderProgram::getFuncIdUniform4ui(void)
 473 {
 474     return FuncIdUniform4ui;
 475 }
 476
 477
 478 inline
 479 UInt32 ShaderProgram::getFuncIdUniform1f(void)
 480 {
 481     return FuncIdUniform1f;
 482 }
 483
 484 inline
 485 UInt32 ShaderProgram::getFuncIdUniform2f(void)
 486 {
 487     return FuncIdUniform2f;
 488 }
 489
 490 inline
 491 UInt32 ShaderProgram::getFuncIdUniform3f(void)
 492 {
 493     return FuncIdUniform3f;
 494 }
 495
 496 inline
 497 UInt32 ShaderProgram::getFuncIdUniform4f(void)
 498 {
 499     return FuncIdUniform4f;
 500 }
 501
 502
 503 inline
 504 UInt32 ShaderProgram::getFuncIdUniform1iv(void)
 505 {
 506     return FuncIdUniform1iv;
 507 }
 508
 509 inline
 510 UInt32 ShaderProgram::getFuncIdUniform2iv(void)
 511 {
 512     return FuncIdUniform2iv;
 513 }
 514
 515 inline
 516 UInt32 ShaderProgram::getFuncIdUniform3iv(void)
 517 {
 518     return FuncIdUniform3iv;
 519 }
 520
 521 inline
 522 UInt32 ShaderProgram::getFuncIdUniform4iv(void)
 523 {
 524     return FuncIdUniform4iv;
 525 }
 526
 527
 528 inline
 529 UInt32 ShaderProgram::getFuncIdUniform1uiv(void)
 530 {
 531     return FuncIdUniform1uiv;
 532 }
 533
 534 inline
 535 UInt32 ShaderProgram::getFuncIdUniform2uiv(void)
 536 {
 537     return FuncIdUniform2uiv;
 538 }
 539
 540 inline
 541 UInt32 ShaderProgram::getFuncIdUniform3uiv(void)
 542 {
 543     return FuncIdUniform3uiv;
 544 }
 545
 546 inline
 547 UInt32 ShaderProgram::getFuncIdUniform4uiv(void)
 548 {
 549     return FuncIdUniform4uiv;
 550 }
 551
 552
 553 inline
 554 UInt32 ShaderProgram::getFuncIdUniform1fv(void)
 555 {
 556     return FuncIdUniform1fv;
 557 }
 558
 559 inline
 560 UInt32 ShaderProgram::getFuncIdUniform2fv(void)
 561 {
 562     return FuncIdUniform2fv;
 563 }
 564
 565 inline
 566 UInt32 ShaderProgram::getFuncIdUniform3fv(void)
 567 {
 568     return FuncIdUniform3fv;
 569 }
 570
 571 inline
 572 UInt32 ShaderProgram::getFuncIdUniform4fv(void)
 573 {
 574     return FuncIdUniform4fv;
 575 }
 576
 577 inline
 578 UInt32 ShaderProgram::getFuncIdUniformMatrix2fv(void)
 579 {
 580     return FuncIdUniformMatrix2fv;
 581 }
 582
 583 inline
 584 UInt32 ShaderProgram::getFuncIdUniformMatrix3fv(void)
 585 {
 586     return FuncIdUniformMatrix3fv;
 587 }
 588
 589 inline
 590 UInt32 ShaderProgram::getFuncIdUniformMatrix4fv(void)
 591 {
 592     return FuncIdUniformMatrix4fv;
 593 }
 594
 595 inline
 596 UInt32 ShaderProgram::getFuncIdGetUniformiv(void)
 597 {
 598     return FuncIdGetUniformiv;
 599 }
 600
 601 inline
 602 UInt32 ShaderProgram::getFuncIdGetUniformfv(void)
 603 {
 604     return FuncIdGetUniformfv;
 605 }
 606
 607 inline
 608 UInt32 ShaderProgram::getFuncIdProgramParameteri(void)
 609 {
 610     return FuncIdProgramParameteri;
 611 }
 612
 613 inline
 614 UInt32 ShaderProgram::getFuncIdBindAttribLocation(void)
 615 {
 616     return FuncIdBindAttribLocation;
 617 }
 618
 619 inline
 620 UInt32 ShaderProgram::getFuncIdBindBufferBase(void)
 621 {
 622     return FuncIdBindBufferBase;
 623 }
 624
 625 inline
 626 UInt32 ShaderProgram::getFuncIdTransformFeedbackVaryings(void)
 627 {
 628     return FuncIdTransformFeedbackVaryings;
 629 }
 630
 631 inline
 632 UInt32 ShaderProgram::getFuncIdBeginTransformFeedback(void)
 633 {
 634     return FuncIdBeginTransformFeedback;
 635 }
 636
 637 inline
 638 UInt32 ShaderProgram::getFuncIdEndTransformFeedback(void)
 639 {
 640     return FuncIdEndTransformFeedback;
 641 }
 642
 643 inline
 644 UInt32 ShaderProgram::getFuncIdPauseTransformFeedback(void)
 645 {
 646     return FuncIdPauseTransformFeedback;
 647 }
 648
 649 inline
 650 UInt32 ShaderProgram::getFuncIdResumeTransformFeedback(void)
 651 {
 652     return FuncIdResumeTransformFeedback;
 653 }
 654
 655 inline
 656 UInt32 ShaderProgram::getFuncIdGetUniformBlockIndex(void)
 657 {
 658     return FuncIdGetUniformBlockIndex;
 659 }
 660
 661 inline
 662 UInt32 ShaderProgram::getFuncIdUniformBlockBinding(void)
 663 {
 664     return FuncIdUniformBlockBinding;
 665 }
 666
 667 inline
 668 UInt16 ShaderProgram::getProgramId(void)
 669 {
 670     return _uiProgId;
 671 }
 672
 673 inline
 674 UInt32 ShaderProgram::getFuncIdGetProgramResourceIndex(void)
 675 {
 676     return FuncIdGetProgramResourceIndex;
 677 }
 678
 679 inline
 680 UInt32 ShaderProgram::getFuncIdGetProgramResourceiv(void)
 681 {
 682     return FuncIdGetProgramResourceiv;
 683 }
 684
 685 inline
 686 UInt32 ShaderProgram::getFuncIdShaderStorageBlockBinding(void)
 687 {
 688     return FuncIdShaderStorageBlockBinding;
 689 }
 690
 691 OSG_END_NAMESPACE