Source/System/State/Shader/SHL/OSGSimpleSHLChunk.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *               Copyright (C) 2000-2006 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 <cstdlib>
  44 #include <cstdio>
  45
  46 #include "OSGConfig.h"
  47
  48 #include "OSGSimpleSHLChunk.h"
  49 #include "OSGDrawEnv.h"
  50
  51 #include "OSGShaderVariables.h"
  52 #include "OSGConceptPropertyChecks.h"
  53
  54 #include <boost/bind.hpp>
  55
  56 OSG_BEGIN_NAMESPACE
  57
  58 // Documentation for this class is emitted in the
  59 // OSGSimpleSHLChunkBase.cpp file.
  60 // To modify it, please change the .fcd file (OSGSimpleSHLChunk.fcd) and
  61 // regenerate the base file.
  62
  63 /***************************************************************************\
  64  *                           Class variables                               *
  65 \***************************************************************************/
  66
  67 #if 0
  68 volatile UInt16 SimpleSHLChunk::_uiChunkCounter = 1;
  69 #endif
  70
  71 #ifdef OSG_1_COMPAT
  72 SimpleSHLChunk::ParamFunctor SimpleSHLChunk::_fParameterCallback;
  73 #endif
  74
  75 /***************************************************************************\
  76  *                           Class methods                                 *
  77 \***************************************************************************/
  78
  79 void SimpleSHLChunk::initMethod(InitPhase ePhase)
  80 {
  81     Inherited::initMethod(ePhase);
  82 }
  83
  84 UInt32 SimpleSHLChunk::handleGL(DrawEnv                 *pEnv,
  85                                 UInt32                   id,
  86                                 Window::GLObjectStatusE  mode,
  87                                 UInt64                   uiOptions)
  88 {
  89     UInt32  returnValue = 0;
  90     Window *pWin        = pEnv->getWindow();
  91
  92     if(!pWin->hasExtOrVersion(_extSHL, 0x0200, 0x0200))
  93     {
  94         FWARNING(("OpenGL Shading Language is not supported, couldn't find "
  95                   "extension 'GL_ARB_shading_language_100'!\n"));
  96
  97         pWin->setGLObjectId(getGLId(), 0);
  98
  99         return returnValue;
 100     }
 101
 102     if(mode == Window::initialize   ||
 103        mode == Window::reinitialize ||
 104        mode == Window::needrefresh   )
 105     {
 106         GLuint uiProgram = GLuint(pWin->getGLObjectId(getGLId()));;
 107
 108         if(mode != Window::needrefresh)
 109         {
 110             if(uiProgram != 0)
 111             {
 112                 OSGGETGLFUNCBYID_GL3_ES(glDeleteProgram,
 113                                         osgGlDeleteProgram,
 114                                         ShaderProgram::getFuncIdDeleteProgram(),
 115                                         pWin);
 116
 117                 osgGlDeleteProgram(uiProgram);
 118             }
 119
 120             OSGGETGLFUNCBYID_GL3_ES(glCreateProgram,
 121                                     osgGlCreateProgram,
 122                                     ShaderProgram::getFuncIdCreateProgram(),
 123                                     pWin);
 124
 125             OSGGETGLFUNCBYID_GL3_ES(glAttachShader,
 126                                     osgGlAttachShader,
 127                                     ShaderProgram::getFuncIdAttachShader(),
 128                                     pWin);
 129
 130             OSGGETGLFUNCBYID_GL3_ES(glLinkProgram,
 131                                     osgGlLinkProgram,
 132                                     ShaderProgram::getFuncIdLinkProgram(),
 133                                     pWin);
 134
 135             uiProgram = osgGlCreateProgram();
 136
 137             FragmentShaderIt fIt  = _mfFragmentShader.begin();
 138             FragmentShaderIt fEnd = _mfFragmentShader.end  ();
 139
 140             for(; fIt != fEnd; ++fIt)
 141             {
 142                 (*fIt)->validate(pEnv);
 143
 144                 GLuint uiShader =
 145                     GLuint(pWin->getGLObjectId((*fIt)->getGLId()));
 146
 147                 if(uiShader != 0)
 148                     osgGlAttachShader(uiProgram, uiShader);
 149             }
 150
 151             GeometryShaderIt gIt  = _mfGeometryShader.begin();
 152             GeometryShaderIt gEnd = _mfGeometryShader.end  ();
 153
 154             for(; gIt != gEnd; ++gIt)
 155             {
 156                 (*gIt)->validate(pEnv);
 157
 158                 GLuint uiShader =
 159                     GLuint(pWin->getGLObjectId((*gIt)->getGLId()));
 160
 161                 if(uiShader != 0)
 162                     osgGlAttachShader(uiProgram, uiShader);
 163             }
 164
 165             TessEvalShaderIt teIt  = _mfTessEvaluationShader.begin();
 166             TessEvalShaderIt teEnd = _mfTessEvaluationShader.end  ();
 167
 168             for(; teIt != teEnd; ++teIt)
 169             {
 170                 (*teIt)->validate(pEnv);
 171
 172                 GLuint uiShader =
 173                     GLuint(pWin->getGLObjectId((*teIt)->getGLId()));
 174
 175                 if(uiShader != 0)
 176                     osgGlAttachShader(uiProgram, uiShader);
 177             }
 178
 179             TessControlShaderIt tcIt  = _mfTessControlShader.begin();
 180             TessControlShaderIt tcEnd = _mfTessControlShader.end  ();
 181
 182             for(; tcIt != tcEnd; ++tcIt)
 183             {
 184                 (*tcIt)->validate(pEnv);
 185
 186                 GLuint uiShader =
 187                     GLuint(pWin->getGLObjectId((*tcIt)->getGLId()));
 188
 189                 if(uiShader != 0)
 190                     osgGlAttachShader(uiProgram, uiShader);
 191             }
 192
 193             VertexShaderIt vIt  = _mfVertexShader.begin();
 194             VertexShaderIt vEnd = _mfVertexShader.end  ();
 195
 196             for(; vIt != vEnd; ++vIt)
 197             {
 198                 (*vIt)->validate(pEnv);
 199
 200                 GLuint uiShader =
 201                     GLuint(pWin->getGLObjectId((*vIt)->getGLId()));
 202
 203                 if(uiShader != 0)
 204                     osgGlAttachShader(uiProgram, uiShader);
 205             }
 206
 207             // parameters must be set before linking
 208             updateParameters(pEnv, uiProgram);
 209
 210             osgGlLinkProgram(uiProgram);
 211
 212             GLint  iInfoLength;
 213             Char8 *szInfoBuffer = NULL;
 214
 215             OSGGETGLFUNCBYID_GL3_ES(glGetProgramiv,
 216                                     osgGlGetProgramiv,
 217                                     ShaderProgram::getFuncIdGetProgramiv(),
 218                                     pWin);
 219
 220             osgGlGetProgramiv(uiProgram,
 221                               GL_OBJECT_INFO_LOG_LENGTH_ARB,
 222                               &iInfoLength);
 223
 224             if(iInfoLength > 0)
 225             {
 226                 szInfoBuffer = new Char8[iInfoLength];
 227                 szInfoBuffer[0] = '\0';
 228
 229                 OSGGETGLFUNCBYID_GL3_ES(
 230                     glGetProgramInfoLog,
 231                     osgGlGetProgramInfoLog,
 232                     ShaderProgram::getFuncIdGetProgramInfoLog(),
 233                     pWin);
 234
 235                 osgGlGetProgramInfoLog( uiProgram,
 236                                         iInfoLength,
 237                                        &iInfoLength,
 238                                         szInfoBuffer);
 239             }
 240
 241             GLint iStatus = 0;
 242
 243             osgGlGetProgramiv(uiProgram, GL_LINK_STATUS, &iStatus);
 244
 245             if(iStatus == 0)
 246             {
 247                 if(szInfoBuffer != NULL && szInfoBuffer[0] != '\0')
 248                 {
 249                     FFATAL(("Couldn't link vertex and fragment program!\n%s\n",
 250                             szInfoBuffer));
 251                 }
 252                 else
 253                 {
 254                     FFATAL(("Couldn't link vertex and fragment program!\n"
 255                             "No further info available\n"));
 256                 }
 257
 258                 OSGGETGLFUNCBYID_GL3_ES(glDeleteProgram,
 259                                         osgGlDeleteProgram,
 260                                         ShaderProgram::getFuncIdDeleteProgram(),
 261                                         pWin);
 262
 263                 osgGlDeleteProgram(uiProgram);
 264
 265                 uiProgram = 0;
 266             }
 267             else
 268             {
 269                 if(szInfoBuffer != NULL && szInfoBuffer[0] != '\0')
 270                 {
 271                     FWARNING(("SimpleSHLChunk: link status: %s\n",
 272                               szInfoBuffer));
 273                 }
 274             }
 275
 276             pWin->setGLObjectId(getGLId(), uiProgram);
 277
 278             updateVariableLocations(pEnv, uiProgram);
 279         }
 280
 281         if(uiProgram != 0)
 282         {
 283             OSGGETGLFUNCBYID_GL3_ES(glUseProgram,
 284                                     osgGlUseProgram,
 285                                     ShaderProgram::getFuncIdUseProgram(),
 286                                     pWin);
 287
 288             osgGlUseProgram(uiProgram);
 289
 290             updateVariables(pEnv, uiProgram);
 291
 292             if(0x0000 == (uiOptions & KeepProgActive))
 293             {
 294                 osgGlUseProgram(0);
 295             }
 296             else
 297             {
 298                 returnValue |= ProgActive;
 299             }
 300         }
 301     }
 302
 303     return returnValue;
 304 }
 305
 306 void SimpleSHLChunk::handleDestroyGL(DrawEnv                 *pEnv,
 307                                      UInt32                   id,
 308                                      Window::GLObjectStatusE  mode)
 309 {
 310     Window *pWin = pEnv->getWindow();
 311
 312     if(!pWin->hasExtOrVersion(_extSHL, 0x0200, 0x0200))
 313     {
 314         FWARNING(("OpenGL Shading Language is not supported, couldn't find "
 315                   "extension 'GL_ARB_shading_language_100'!\n"));
 316
 317         pWin->setGLObjectId(id, 0);
 318
 319         return;
 320     }
 321
 322     // BUG this is not called for every window!
 323     if(mode == Window::destroy)
 324     {
 325         GLuint uiProgram = GLuint(pWin->getGLObjectId(id));
 326
 327         if(uiProgram != 0)
 328         {
 329             OSGGETGLFUNCBYID_GL3_ES(glDeleteProgram,
 330                                     osgGlDeleteProgram,
 331                                     ShaderProgram::getFuncIdDeleteProgram(),
 332                                     pWin);
 333
 334             osgGlDeleteProgram(uiProgram);
 335
 336             pWin->setGLObjectId(id, 0);
 337         }
 338     }
 339     else if(mode == Window::finaldestroy)
 340     {
 341         ;//SWARNING << "Last program user destroyed" << std::endl;
 342     }
 343 }
 344
 345 /***************************************************************************\
 346  *                           Instance methods                              *
 347 \***************************************************************************/
 348
 349 /*-------------------------------------------------------------------------*\
 350  -  private                                                                 -
 351 \*-------------------------------------------------------------------------*/
 352
 353 /*----------------------- constructors & destructors ----------------------*/
 354
 355 SimpleSHLChunk::SimpleSHLChunk(void) :
 356      Inherited( ),
 357     _uiChunkId(0)
 358 {
 359 }
 360
 361 SimpleSHLChunk::SimpleSHLChunk(const SimpleSHLChunk &source) :
 362      Inherited(source),
 363     _uiChunkId(0     )
 364 {
 365 }
 366
 367 SimpleSHLChunk::~SimpleSHLChunk(void)
 368 {
 369 }
 370
 371 void SimpleSHLChunk::onCreate(const SimpleSHLChunk *source)
 372 {
 373     Inherited::onCreate(source);
 374
 375     // ignore prototypes.
 376     if(GlobalSystemState == Startup)
 377         return;
 378
 379     setGLId(
 380         Window::registerGLObject(
 381             boost::bind(&SimpleSHLChunk::handleGL,
 382                         SimpleSHLChunkMTUncountedPtr(this),
 383                         _1, _2, _3, _4),
 384             &SimpleSHLChunk::handleDestroyGL));
 385
 386     _uiChunkId = ShaderExecutableChunk::_uiChunkCounter++;
 387 }
 388
 389 void SimpleSHLChunk::onCreateAspect(const SimpleSHLChunk *createAspect,
 390                                     const SimpleSHLChunk *source      )
 391 {
 392     Inherited::onCreateAspect(createAspect, source);
 393
 394     _uiChunkId = createAspect->_uiChunkId;
 395 }
 396
 397 void SimpleSHLChunk::onDestroy(UInt32 uiId)
 398 {
 399     if(getGLId() > 0)
 400         Window::destroyGLObject(getGLId(), 1);
 401
 402     Inherited::onDestroy(uiId);
 403 }
 404
 405 const StateChunkClass *SimpleSHLChunk::getClass(void) const
 406 {
 407     return ShaderExecutableChunk::getStaticClass();
 408 }
 409
 410 UInt16 SimpleSHLChunk::getChunkId(void)
 411 {
 412     return _uiChunkId;
 413 }
 414
 415 /*----------------------------- class specific ----------------------------*/
 416
 417 void SimpleSHLChunk::changed(ConstFieldMaskArg whichField,
 418                              UInt32            origin,
 419                              BitVector         details)
 420 {
 421     bool bMarkChanged = false;
 422
 423     if(0x0000 != (whichField & FragmentProgramFieldMask) &&
 424        0      != _sfFragmentProgram.getValue().size()     )
 425     {
 426         if(_mfFragmentShader.size() == 0)
 427         {
 428             ShaderProgramUnrecPtr pProg = ShaderProgram::createDependent(
 429                 this->getFieldFlags()->_bNamespaceMask);
 430
 431             pProg->setShaderType(GL_FRAGMENT_SHADER);
 432
 433             addFragmentShader(pProg);
 434         }
 435         else if(_mfFragmentShader.size() > 1)
 436         {
 437             editMFFragmentShader()->resize(1);
 438         }
 439
 440         _mfFragmentShader[0]->setProgram   (_sfFragmentProgram.getValue());
 441         _mfFragmentShader[0]->setCgFrontEnd(_sfCgFrontEnd     .getValue());
 442
 443         bMarkChanged = true;
 444
 445         Window::reinitializeGLObject(this->getGLId());
 446     }
 447
 448     if(0x0000 != (whichField & GeometryProgramFieldMask) &&
 449        0      != _sfGeometryProgram.getValue().size()     )
 450     {
 451         if(_mfGeometryShader.size() == 0)
 452         {
 453             ShaderProgramUnrecPtr pProg = ShaderProgram::createDependent(
 454                 this->getFieldFlags()->_bNamespaceMask);
 455
 456             pProg->setShaderType(GL_GEOMETRY_SHADER_EXT);
 457
 458             addGeometryShader(pProg);
 459         }
 460         else if(_mfGeometryShader.size() > 1)
 461         {
 462             editMFGeometryShader()->resize(1);
 463         }
 464
 465         _mfGeometryShader[0]->setProgram   (_sfGeometryProgram.getValue());
 466         _mfGeometryShader[0]->setCgFrontEnd(_sfCgFrontEnd     .getValue());
 467
 468         bMarkChanged = true;
 469
 470         Window::reinitializeGLObject(this->getGLId());
 471     }
 472
 473     if(0x0000 != (whichField & TessControlProgramFieldMask) &&
 474        0      != _sfTessControlProgram.getValue().size()     )
 475     {
 476         if(_mfTessControlShader.size() == 0)
 477         {
 478             ShaderProgramUnrecPtr pProg = ShaderProgram::createDependent(
 479                 this->getFieldFlags()->_bNamespaceMask);
 480
 481             pProg->setShaderType(GL_TESS_CONTROL_SHADER);
 482
 483             addTessControlShader(pProg);
 484         }
 485         else if(_mfTessControlShader.size() > 1)
 486         {
 487             editMFTessControlShader()->resize(1);
 488         }
 489
 490         _mfTessControlShader[0]->setProgram   (
 491             _sfTessControlProgram.getValue());
 492         _mfTessControlShader[0]->setCgFrontEnd(
 493             _sfCgFrontEnd        .getValue());
 494
 495         bMarkChanged = true;
 496
 497         Window::reinitializeGLObject(this->getGLId());
 498     }
 499
 500     if(0x0000 != (whichField & TessEvaluationProgramFieldMask) &&
 501        0      != _sfTessEvaluationProgram.getValue().size()     )
 502     {
 503         if(_mfTessEvaluationShader.size() == 0)
 504         {
 505             ShaderProgramUnrecPtr pProg = ShaderProgram::createDependent(
 506                 this->getFieldFlags()->_bNamespaceMask);
 507
 508             pProg->setShaderType(GL_TESS_EVALUATION_SHADER);
 509
 510             addTessEvaluationShader(pProg);
 511         }
 512         else if(_mfTessEvaluationShader.size() > 1)
 513         {
 514             editMFTessEvaluationShader()->resize(1);
 515         }
 516
 517         _mfTessEvaluationShader[0]->setProgram   (
 518             _sfTessEvaluationProgram.getValue());
 519         _mfTessEvaluationShader[0]->setCgFrontEnd(
 520             _sfCgFrontEnd           .getValue());
 521
 522         bMarkChanged = true;
 523
 524         Window::reinitializeGLObject(this->getGLId());
 525     }
 526
 527     if(0x0000 != (whichField & VertexProgramFieldMask) &&
 528        0      != _sfVertexProgram.getValue().size()     )
 529     {
 530         if(_mfVertexShader.size() == 0)
 531         {
 532             ShaderProgramUnrecPtr pProg = ShaderProgram::createDependent(
 533                 this->getFieldFlags()->_bNamespaceMask);
 534
 535             pProg->setShaderType(GL_VERTEX_SHADER);
 536
 537             addVertexShader(pProg);
 538
 539             pProg->setVariables(this->getVariables());
 540         }
 541         else if(_mfVertexShader.size() > 1)
 542         {
 543             editMFVertexShader()->resize(1);
 544         }
 545
 546         _mfVertexShader[0]->setProgram   (_sfVertexProgram.getValue());
 547         _mfVertexShader[0]->setCgFrontEnd(_sfCgFrontEnd   .getValue());
 548
 549         bMarkChanged = true;
 550
 551         Window::reinitializeGLObject(this->getGLId());
 552     }
 553
 554
 555     if(0x0000 != (whichField & VariablesFieldMask))
 556     {
 557         ShaderProgramVariables *pVars = _sfVariables.getValue();
 558
 559         if(pVars != NULL)
 560         {
 561             if(details == 0x0001)
 562             {
 563                 // be save reset all locations
 564
 565                 if(pVars->getMFVariables()->size() == 0)
 566                 {
 567                     editMFVariableLocations()->clear();
 568                 }
 569                 else
 570                 {
 571                     editMFVariableLocations()->resize(
 572                         pVars->getMFVariables()->size(),
 573                         -1);
 574
 575                     std::fill(editMFVariableLocations()->begin(),
 576                               editMFVariableLocations()->end  (),
 577                               -1);
 578                 }
 579
 580                 // be save reset all locations
 581
 582                 if(pVars->getMFProceduralVariables()->size() == 0     )
 583                 {
 584                     editMFProceduralVariableLocations()->clear();
 585                 }
 586                 else
 587                 {
 588                     editMFProceduralVariableLocations()->resize(
 589                         pVars->getMFProceduralVariables()->size(),
 590                         -1);
 591
 592                     std::fill(editMFProceduralVariableLocations()->begin(),
 593                               editMFProceduralVariableLocations()->end  (),
 594                               -1);
 595                 }
 596             }
 597         }
 598
 599         Window::refreshGLObject(this->getGLId());
 600     }
 601
 602     if(0x0000 != (whichField & (VertexShaderFieldMask   |
 603                                 GeometryShaderFieldMask |
 604                                 FragmentShaderFieldMask )))
 605     {
 606         bMarkChanged = true;
 607
 608         Window::reinitializeGLObject(this->getGLId());
 609     }
 610
 611     if(0x0000 != (whichField & (GeometryVerticesOutFieldMask |
 612                                 GeometryInputTypeFieldMask   |
 613                                 GeometryOutputTypeFieldMask  )))
 614     {
 615         bMarkChanged = true;
 616
 617         // changing parameters requires re-linking the shader
 618         Window::reinitializeGLObject(this->getGLId());
 619     }
 620
 621     if(bMarkChanged == true)
 622     {
 623         // be save reset all locations
 624
 625         std::fill(editMFVariableLocations()->begin(),
 626                   editMFVariableLocations()->end  (),
 627                   -1);
 628
 629         std::fill(editMFProceduralVariableLocations()->begin(),
 630                   editMFProceduralVariableLocations()->end  (),
 631                   -1);
 632
 633         if(_sfVariables.getValue() != NULL)
 634         {
 635             _sfVariables.getValue()->markAllChanged();
 636         }
 637     }
 638
 639     Inherited::changed(whichField, origin, details);
 640 }
 641
 642 void SimpleSHLChunk::activate(DrawEnv    *pEnv,
 643                               UInt32      uiIdx)
 644 {
 645 #if 0
 646     FragmentShaderIt fIt  = _mfFragmentShader.begin();
 647     FragmentShaderIt fEnd = _mfFragmentShader.end  ();
 648
 649     for(; fIt != fEnd; ++fIt)
 650     {
 651         (*fIt)->validate(pEnv);
 652     }
 653
 654     GeometryShaderIt gIt  = _mfGeometryShader.begin();
 655     GeometryShaderIt gEnd = _mfGeometryShader.end  ();
 656
 657     for(; gIt != gEnd; ++gIt)
 658     {
 659         (*gIt)->validate(pEnv);
 660     }
 661
 662     VertexShaderIt vIt  = _mfVertexShader.begin();
 663     VertexShaderIt vEnd = _mfVertexShader.end  ();
 664
 665     for(; vIt != vEnd; ++vIt)
 666     {
 667         (*vIt)->validate(pEnv);
 668     }
 669 #endif
 670
 671     Window *pWin    = pEnv->getWindow();
 672
 673     UInt32 uiValRes = pWin->validateGLObject(getGLId(),
 674                                              pEnv,
 675                                              KeepProgActive);
 676
 677     GLuint uiProgId = GLuint(pWin->getGLObjectId(getGLId()));
 678
 679     if(uiProgId == 0)
 680         return;
 681
 682     pEnv->setActiveShader(uiProgId);
 683
 684     if(0x0000 == (uiValRes & ProgActive))
 685     {
 686         OSGGETGLFUNCBYID_GL3_ES(glUseProgram,
 687                                 osgGlUseProgram,
 688                                 ShaderProgram::getFuncIdUseProgram(),
 689                                 pWin);
 690
 691         osgGlUseProgram(uiProgId);
 692     }
 693
 694     pEnv->incNumShaderChanges();
 695
 696     updateProceduralVariables(pEnv, ShaderProcVariable::SHDAll);
 697
 698     if(_sfPointSize.getValue() == true)
 699     {
 700         glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
 701     }
 702
 703 }
 704
 705 void SimpleSHLChunk::changeFrom(DrawEnv    *pEnv,
 706                                 StateChunk *pOther,
 707                                 UInt32      uiIdx)
 708 {
 709     SimpleSHLChunk *pOld = dynamic_cast<SimpleSHLChunk *>(pOther);
 710
 711     // pOther can be a ShaderExecutableChunk, since we share the StateClass id
 712     // with it
 713     if(pOld != NULL)
 714     {
 715         Window   *pWin     = pEnv->getWindow();
 716         GLuint    uiProgId = GLuint(pWin->getGLObjectId(getGLId()));
 717
 718         UInt32 uiDep = ShaderProcVariable::SHDObject;
 719
 720         if(uiProgId != pEnv->getActiveShader())
 721         {
 722 #if 0
 723             FragmentShaderIt fIt  = _mfFragmentShader.begin();
 724             FragmentShaderIt fEnd = _mfFragmentShader.end  ();
 725
 726             for(; fIt != fEnd; ++fIt)
 727             {
 728                 (*fIt)->validate(pEnv);
 729             }
 730
 731             GeometryShaderIt gIt  = _mfGeometryShader.begin();
 732             GeometryShaderIt gEnd = _mfGeometryShader.end  ();
 733
 734             for(; gIt != gEnd; ++gIt)
 735             {
 736                 (*gIt)->validate(pEnv);
 737             }
 738
 739             VertexShaderIt vIt  = _mfVertexShader.begin();
 740             VertexShaderIt vEnd = _mfVertexShader.end  ();
 741
 742             for(; vIt != vEnd; ++vIt)
 743             {
 744                 (*vIt)->validate(pEnv);
 745             }
 746 #endif
 747
 748             UInt32 uiValRes = pWin->validateGLObject(getGLId(),
 749                                                      pEnv,
 750                                                      KeepProgActive);
 751
 752             uiProgId = GLuint(pWin->getGLObjectId(getGLId()));
 753
 754             if(uiProgId == 0)
 755                 return;
 756
 757             pEnv->setActiveShader(uiProgId);
 758
 759             if(0x0000 == (uiValRes & ProgActive))
 760             {
 761                 OSGGETGLFUNCBYID_GL3_ES(glUseProgram,
 762                                         osgGlUseProgram,
 763                                         ShaderProgram::getFuncIdUseProgram(),
 764                                         pWin);
 765
 766                 osgGlUseProgram(uiProgId);
 767             }
 768
 769             if(_sfPointSize.getValue() == true)
 770             {
 771                 if(pOld->getPointSize() == false)
 772                 {
 773                     glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
 774                 }
 775             }
 776             else
 777             {
 778                 if(pOld->getPointSize() == true)
 779                 {
 780                     glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
 781                 }
 782             }
 783
 784             uiDep = ShaderProcVariable::SHDAll;
 785
 786             pEnv->incNumShaderChanges();
 787         }
 788
 789         updateProceduralVariables(pEnv, uiDep);
 790     }
 791     else
 792     {
 793         pOther->deactivate(pEnv, uiIdx);
 794         activate          (pEnv, uiIdx);
 795
 796         pEnv->incNumShaderChanges();
 797     }
 798 }
 799
 800 void SimpleSHLChunk::deactivate(DrawEnv    *pEnv,
 801                                 UInt32      uiIdx)
 802 {
 803     if(pEnv->getWindow()->getGLObjectId(getGLId()) == 0)
 804         return;
 805
 806     pEnv->setActiveShader(0);
 807
 808     OSGGETGLFUNC_GL3_ES(glUseProgram,
 809                         osgGlUseProgram,
 810                         ShaderProgram::getFuncIdUseProgram());
 811
 812     if(_sfPointSize.getValue() == true)
 813     {
 814         glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
 815     }
 816
 817     osgGlUseProgram(0);
 818 }
 819
 820 void SimpleSHLChunk::updateObjectDependencies(DrawEnv    *pEnv,
 821                                               UInt32      index)
 822 {
 823     updateProceduralVariables(pEnv, ShaderProcVariable::SHDObject);
 824 }
 825
 826 void SimpleSHLChunk::dump(      UInt32    ,
 827                           const BitVector ) const
 828 {
 829     SLOG << "Dump SimpleSHLChunk NI" << std::endl;
 830 }
 831
 832 bool SimpleSHLChunk::readFragmentProgram(const Char8 *file)
 833 {
 834     return readProgram(editSFFragmentProgram()->getValue(), file);
 835 }
 836
 837 bool SimpleSHLChunk::readGeometryProgram(const Char8 *file)
 838 {
 839     return readProgram(editSFGeometryProgram()->getValue(), file);
 840 }
 841
 842 bool SimpleSHLChunk::readTessControlProgram(const Char8* file)
 843 {
 844     return readProgram(editSFTessControlProgram()->getValue(), file);
 845 }
 846
 847 bool SimpleSHLChunk::readTessEvaluationProgram(const Char8* file)
 848 {
 849     return readProgram(editSFTessEvaluationProgram()->getValue(), file);
 850 }
 851
 852 bool SimpleSHLChunk::readVertexProgram(const Char8 *file)
 853 {
 854     return readProgram(editSFVertexProgram()->getValue(), file);
 855 }
 856
 857 bool SimpleSHLChunk::readProgram(      std::string  &szTarget,
 858                                  const Char8        *szFilename)
 859 {
 860     std::ifstream s(szFilename);
 861
 862     if(s.good())
 863     {
 864         return readProgram(szTarget, s);
 865     }
 866     else
 867     {
 868         FWARNING(("ShaderChunk::readProgram: couldn't open '%s' "
 869                   "for reading!\n", szFilename));
 870
 871         return false;
 872     }
 873
 874 }
 875
 876 bool SimpleSHLChunk::readProgram(std::string  &szTarget,
 877                                  std::istream &iStream)
 878 {
 879 #define BUFSIZE 200
 880
 881     szTarget.erase();
 882
 883     Char8 buf[BUFSIZE];
 884
 885     if(!iStream.good())
 886     {
 887         FWARNING(("SHLChunk::readProgram: stream is not good!\n"));
 888
 889         return false;
 890     }
 891
 892     do
 893     {
 894         iStream.read(buf, BUFSIZE);
 895
 896         szTarget.append(buf, iStream.gcount());
 897     }
 898     while(!iStream.eof());
 899
 900     return true;
 901 }
 902
 903 #ifdef OSG_1_COMPAT
 904 void SimpleSHLChunk::addProgramParameter(GLenum name, UInt32 value)
 905 {
 906     switch(name)
 907     {
 908         case GL_GEOMETRY_VERTICES_OUT_EXT:
 909             this->setGeometryVerticesOut(value);
 910             break;
 911
 912         case GL_GEOMETRY_INPUT_TYPE_EXT:
 913             this->setGeometryInputType(value);
 914             break;
 915
 916         case GL_GEOMETRY_OUTPUT_TYPE_EXT:
 917             this->setGeometryOutputType(value);
 918             break;
 919
 920         default:
 921             FWARNING(("Invalid program paramter '%d'.\n", name));
 922             break;
 923     }
 924 }
 925
 926 void SimpleSHLChunk::subProgramParameter(GLenum name)
 927 {
 928     switch(name)
 929     {
 930         case GL_GEOMETRY_VERTICES_OUT_EXT:
 931             this->setGeometryVerticesOut(0);
 932             break;
 933
 934         case GL_GEOMETRY_INPUT_TYPE_EXT:
 935             this->setGeometryInputType(GL_TRIANGLES);
 936             break;
 937
 938         case GL_GEOMETRY_OUTPUT_TYPE_EXT:
 939             this->setGeometryOutputType(GL_TRIANGLE_STRIP);
 940             break;
 941
 942         default:
 943             FWARNING(("Invalid program paramter '%d'.\n", name));
 944             break;
 945     }
 946 }
 947 #endif
 948
 949 void SimpleSHLChunk::setProgramParameter(GLenum name, UInt32 value)
 950 {
 951     switch(name)
 952     {
 953         case GL_GEOMETRY_VERTICES_OUT_EXT:
 954             this->setGeometryVerticesOut(value);
 955             break;
 956
 957         case GL_GEOMETRY_INPUT_TYPE_EXT:
 958             this->setGeometryInputType(value);
 959             break;
 960
 961         case GL_GEOMETRY_OUTPUT_TYPE_EXT:
 962             this->setGeometryOutputType(value);
 963             break;
 964
 965         default:
 966             FWARNING(("Invalid program paramter '%d'.\n", name));
 967             break;
 968     }
 969 }
 970
 971 UInt32 SimpleSHLChunk::getProgramParameter(GLenum name)
 972 {
 973     switch(name)
 974     {
 975         case GL_GEOMETRY_VERTICES_OUT_EXT:
 976             return this->getGeometryVerticesOut();
 977             break;
 978
 979         case GL_GEOMETRY_INPUT_TYPE_EXT:
 980             return this->getGeometryInputType();
 981             break;
 982
 983         case GL_GEOMETRY_OUTPUT_TYPE_EXT:
 984             return this->getGeometryOutputType();
 985             break;
 986
 987         default:
 988             FWARNING(("Invalid program paramter '%d'.\n", name));
 989             return 0;
 990             break;
 991     }
 992 }
 993
 994 void SimpleSHLChunk::clearProgramParameters(void)
 995 {
 996     setGeometryVerticesOut(0                );
 997     setGeometryInputType  (GL_TRIANGLES     );
 998     setGeometryOutputType (GL_TRIANGLE_STRIP);
 999 }
1000
1001 #ifdef OSG_1_COMPAT
1002 bool SimpleSHLChunk::subUniformParameter(const Char8 *name)
1003 {
1004     if(_sfVariables.getValue() != NULL)
1005     {
1006         return _sfVariables.getValue()->subUniformVariable(
1007             name,
1008             editMFVariableLocations(),
1009             editMFProceduralVariableLocations());
1010
1011     }
1012
1013     return false;
1014 }
1015
1016 void SimpleSHLChunk::clearUniformParameters(void)
1017 {
1018     if(_sfVariables.getValue() != NULL)
1019     {
1020         _sfVariables.getValue()->clearUniformVariables();
1021     }
1022
1023     editMFVariableLocations          ()->clear();
1024     editMFProceduralVariableLocations()->clear();
1025 }
1026 #endif
1027
1028 bool SimpleSHLChunk::hasUniformVariable(const Char8 *name)
1029 {
1030     if(_sfVariables.getValue() != NULL)
1031     {
1032         return _sfVariables.getValue()->hasUniformVariable(name);
1033     }
1034
1035     return false;
1036 }
1037
1038 bool SimpleSHLChunk::subUniformVariable(const Char8 *name)
1039 {
1040     if(_sfVariables.getValue() != NULL)
1041     {
1042         return _sfVariables.getValue()->subUniformVariable(
1043             name,
1044             editMFVariableLocations(),
1045             editMFProceduralVariableLocations());
1046
1047     }
1048
1049     return false;
1050 }
1051
1052 bool SimpleSHLChunk::addUniformBlock(const Char8 *name, UInt32  value)
1053 {
1054     if(_sfVariables.getValue() == NULL)
1055     {
1056         ShaderProgramVariablesUnrecPtr pParam =
1057             ShaderProgramVariables::createDependent(
1058                 this->getFieldFlags()->_bNamespaceMask);
1059
1060         setVariables(pParam);
1061     }
1062
1063     return _sfVariables.getValue()->addUniformBlock(
1064         name,
1065         value,
1066         editMFVariableLocations          (),
1067         editMFProceduralVariableLocations());
1068 }
1069
1070 bool SimpleSHLChunk::updateUniformBlock(const Char8 *name, UInt32  value)
1071 {
1072     if(_sfVariables.getValue() == NULL)
1073     {
1074         ShaderProgramVariablesUnrecPtr pParam =
1075             ShaderProgramVariables::createDependent(
1076                 this->getFieldFlags()->_bNamespaceMask);
1077
1078         setVariables(pParam);
1079     }
1080
1081     return _sfVariables.getValue()->updateUniformBlock(name, value);
1082 }
1083
1084 bool SimpleSHLChunk::getUniformBlock(const Char8 *name, UInt32& value)
1085 {
1086     if(_sfVariables.getValue() != NULL)
1087     {
1088         return _sfVariables.getValue()->getUniformBlock(name, value);
1089     }
1090
1091     return false;
1092 }
1093
1094 bool SimpleSHLChunk::subUniformBlock(const Char8 *name)
1095 {
1096     if(_sfVariables.getValue() != NULL)
1097     {
1098         return _sfVariables.getValue()->subUniformBlock(
1099             name,
1100             editMFVariableLocations(),
1101             editMFProceduralVariableLocations());
1102
1103     }
1104
1105     return false;
1106 }
1107
1108 bool SimpleSHLChunk::addShaderStorageBlock(const Char8 *name, UInt32  value)
1109 {
1110     if(_sfVariables.getValue() == NULL)
1111     {
1112         ShaderProgramVariablesUnrecPtr pParam =
1113             ShaderProgramVariables::createDependent(
1114                 this->getFieldFlags()->_bNamespaceMask);
1115
1116         setVariables(pParam);
1117     }
1118
1119     return _sfVariables.getValue()->addShaderStorageBlock(
1120         name,
1121         value,
1122         editMFVariableLocations          (),
1123         editMFProceduralVariableLocations());
1124 }
1125
1126 bool SimpleSHLChunk::updateShaderStorageBlock(const Char8 *name, UInt32  value)
1127 {
1128     if(_sfVariables.getValue() == NULL)
1129     {
1130         ShaderProgramVariablesUnrecPtr pParam =
1131             ShaderProgramVariables::createDependent(
1132                 this->getFieldFlags()->_bNamespaceMask);
1133
1134         setVariables(pParam);
1135     }
1136
1137     return _sfVariables.getValue()->updateShaderStorageBlock(name, value);
1138 }
1139
1140 bool SimpleSHLChunk::getShaderStorageBlock(const Char8 *name, UInt32& value)
1141 {
1142     if(_sfVariables.getValue() != NULL)
1143     {
1144         return _sfVariables.getValue()->getShaderStorageBlock(name, value);
1145     }
1146
1147     return false;
1148 }
1149
1150 bool SimpleSHLChunk::subShaderStorageBlock(const Char8 *name)
1151 {
1152     if(_sfVariables.getValue() != NULL)
1153     {
1154         return _sfVariables.getValue()->subShaderStorageBlock(
1155             name,
1156             editMFVariableLocations(),
1157             editMFProceduralVariableLocations());
1158
1159     }
1160
1161     return false;
1162 }
1163
1164 void SimpleSHLChunk::clearUniformVariables(void)
1165 {
1166     if(_sfVariables.getValue() != NULL)
1167     {
1168         _sfVariables.getValue()->clearUniformVariables();
1169     }
1170
1171     editMFVariableLocations          ()->clear();
1172     editMFProceduralVariableLocations()->clear();
1173 }
1174
1175 bool SimpleSHLChunk::addOSGVariable(const Char8 *name)
1176 {
1177     if(_sfVariables.getValue() == NULL)
1178     {
1179         ShaderProgramVariablesUnrecPtr pVar =
1180             ShaderProgramVariables::createDependent(
1181                 this->getFieldFlags()->_bNamespaceMask);
1182
1183         setVariables(pVar);
1184
1185         if(_mfVertexShader.size() > 0)
1186         {
1187             _mfVertexShader[0]->setVariables(this->getVariables());
1188         }
1189     }
1190
1191     return _sfVariables.getValue()->addOSGVariable(
1192         name,
1193         editMFProceduralVariableLocations());
1194 }
1195
1196 bool SimpleSHLChunk::addProceduralVariable(const Char8          *name,
1197                                                  ProcVarFunctor  pFunc,
1198                                                  UInt32          uiDependency)
1199 {
1200     if(_sfVariables.getValue() == NULL)
1201     {
1202         ShaderProgramVariablesUnrecPtr pParam =
1203             ShaderProgramVariables::createDependent(
1204                 this->getFieldFlags()->_bNamespaceMask);
1205
1206         setVariables(pParam);
1207
1208         if(_mfVertexShader.size() > 0)
1209         {
1210             _mfVertexShader[0]->setVariables(this->getVariables());
1211         }
1212     }
1213
1214     return _sfVariables.getValue()->addProceduralVariable(
1215         name,
1216         pFunc,
1217         uiDependency,
1218         editMFProceduralVariableLocations());
1219 }
1220
1221 bool SimpleSHLChunk::updateNodeProceduralVariable(
1222     const Char8             *name,
1223           ProcVarNodeFunctor pFunc,
1224           UInt32             uiDependency)
1225 {
1226     if(_sfVariables.getValue() == NULL)
1227     {
1228         ShaderProgramVariablesUnrecPtr pParam =
1229             ShaderProgramVariables::createDependent(
1230                 this->getFieldFlags()->_bNamespaceMask);
1231
1232         setVariables(pParam);
1233
1234         if(_mfVertexShader.size() > 0)
1235         {
1236             _mfVertexShader[0]->setVariables(this->getVariables());
1237         }
1238     }
1239
1240     return _sfVariables.getValue()->updateNodeProceduralVariable(name,
1241                                                                  pFunc,
1242                                                                  uiDependency);
1243 }
1244
1245 bool SimpleSHLChunk::addNodeProceduralVariable(
1246     const Char8              *name,
1247           ProcVarNodeFunctor  pFunc,
1248           UInt32              uiDependency)
1249 {
1250     if(_sfVariables.getValue() == NULL)
1251     {
1252         ShaderProgramVariablesUnrecPtr pParam =
1253             ShaderProgramVariables::createDependent(
1254                 this->getFieldFlags()->_bNamespaceMask);
1255
1256         setVariables(pParam);
1257
1258         if(_mfVertexShader.size() > 0)
1259         {
1260             _mfVertexShader[0]->setVariables(this->getVariables());
1261         }
1262     }
1263
1264     return _sfVariables.getValue()->addNodeProceduralVariable(
1265         name,
1266         pFunc,
1267         uiDependency,
1268         editMFProceduralVariableLocations());
1269 }
1270
1271 bool SimpleSHLChunk::updateProceduralVariable(const Char8         *name,
1272                                                     ProcVarFunctor pFunc,
1273                                                     UInt32         uiDependency)
1274 {
1275     if(_sfVariables.getValue() == NULL)
1276     {
1277         ShaderProgramVariablesUnrecPtr pParam =
1278             ShaderProgramVariables::createDependent(
1279                 this->getFieldFlags()->_bNamespaceMask);
1280
1281         setVariables(pParam);
1282
1283         if(_mfVertexShader.size() > 0)
1284         {
1285             _mfVertexShader[0]->setVariables(this->getVariables());
1286         }
1287     }
1288
1289     return _sfVariables.getValue()->updateProceduralVariable(name,
1290                                                              pFunc,
1291                                                              uiDependency);
1292 }
1293
1294 #ifdef OSG_1_COMPAT
1295 void SimpleSHLChunk::addParameterCallback(const Char8 *name, ParamFunctor fp)
1296 {
1297     if(_sfVariables.getValue() == NULL)
1298     {
1299         ShaderProgramVariablesUnrecPtr pParam =
1300             ShaderProgramVariables::createDependent(
1301                 this->getFieldFlags()->_bNamespaceMask);
1302
1303         setVariables(pParam);
1304
1305         if(_mfVertexShader.size() > 0)
1306         {
1307             _mfVertexShader[0]->setVariables(this->getVariables());
1308         }
1309     }
1310
1311     _sfVariables.getValue()->addProceduralVariable(
1312         name,
1313         fp,
1314         editMFProceduralVariableLocations());
1315 }
1316
1317 void SimpleSHLChunk::addParameterCallback(const Char8 *name, OSGParamFunctor fp)
1318 {
1319     if(_sfVariables.getValue() == NULL)
1320     {
1321         ShaderProgramVariablesUnrecPtr pParam =
1322             ShaderProgramVariables::createDependent(
1323                 this->getFieldFlags()->_bNamespaceMask);
1324
1325         setVariables(pParam);
1326
1327         if(_mfVertexShader.size() > 0)
1328         {
1329             _mfVertexShader[0]->setVariables(this->getVariables());
1330         }
1331     }
1332
1333     _sfVariables.getValue()->addProceduralVariable(
1334         name,
1335         fp,
1336         editMFProceduralVariableLocations());
1337 }
1338
1339 void SimpleSHLChunk::setParameterCallback(ParamFunctor fp)
1340 {
1341     _fParameterCallback = fp;
1342 }
1343 #endif
1344
1345 #if 1
1346 void SimpleSHLChunk::updateParameters(
1347     Window                         *win,
1348     const UInt32                         &parameters,
1349     bool                            useProgram,
1350     bool                            force,
1351     bool                            keepProgramActive)
1352 {
1353 }
1354
1355 const UInt32 *SimpleSHLChunk::getMFParameters(void) const
1356 {
1357     static UInt32 foo;
1358
1359     return &foo;
1360 }
1361 #endif
1362
1363 void SimpleSHLChunk::updateVariableLocations(DrawEnv *pEnv,
1364                                              UInt32   uiProgram)
1365 {
1366     if(uiProgram == 0)
1367         return;
1368
1369     const ShaderProgramVariables::MFVariablesType           *pMFVars     = NULL;
1370     const ShaderProgramVariables::MFProceduralVariablesType *pMFProcVars = NULL;
1371
1372     if(_sfVariables.getValue() != NULL)
1373     {
1374         pMFVars     = _sfVariables.getValue()->getMFVariables          ();
1375         pMFProcVars = _sfVariables.getValue()->getMFProceduralVariables();
1376     }
1377
1378     if(pMFVars != NULL && pMFVars->size() != 0)
1379     {
1380         MFInt32 &vVarLocations = *this->editMFVariableLocations();
1381
1382         OSG_ASSERT(pMFVars->size() == vVarLocations.size());
1383
1384         MFInt32::iterator mLocIt = vVarLocations.begin();
1385
1386         ShaderProgramVariables::MFVariablesType::const_iterator mVarIt  =
1387             pMFVars->begin();
1388         ShaderProgramVariables::MFVariablesType::const_iterator mVarEnd =
1389             pMFVars->end  ();
1390
1391         OSGGETGLFUNC_GL3_ES(glGetUniformLocation,
1392                             osgGlGetUniformLocation,
1393                             ShaderProgram::getFuncIdGetUniformLocation());
1394
1395         for(; mVarIt != mVarEnd; ++mVarIt, ++mLocIt)
1396         {
1397             // variable at this position was removed
1398             if((*mVarIt) == NULL)
1399                 continue;
1400
1401             *mLocIt = osgGlGetUniformLocation(uiProgram,
1402                                               (*mVarIt)->getName().c_str());
1403         }
1404     }
1405
1406     if(pMFProcVars != NULL && pMFProcVars->size() != 0)
1407     {
1408         MFInt32 &vVarLocations = *this->editMFProceduralVariableLocations();
1409
1410         OSG_ASSERT(pMFProcVars->size() == vVarLocations.size());
1411
1412         MFInt32::iterator mLocIt = vVarLocations.begin();
1413
1414         ShaderProgramVariables::MFProceduralVariablesType::const_iterator
1415             mVarIt  = pMFProcVars->begin();
1416         ShaderProgramVariables::MFProceduralVariablesType::const_iterator
1417             mVarEnd = pMFProcVars->end  ();
1418
1419         OSGGETGLFUNC_GL3_ES(glGetUniformLocation,
1420                             osgGlGetUniformLocation,
1421                             ShaderProgram::getFuncIdGetUniformLocation());
1422
1423         for(; mVarIt != mVarEnd; ++mVarIt, ++mLocIt)
1424         {
1425             *mLocIt = osgGlGetUniformLocation(uiProgram,
1426                                               (*mVarIt)->getName().c_str());
1427         }
1428     }
1429 }
1430
1431 void SimpleSHLChunk::updateVariables(DrawEnv *pEnv,
1432                                      UInt32   uiProgram)
1433 {
1434     if(uiProgram == 0)
1435         return;
1436
1437     const ShaderProgramVariables::MFVariablesType       *pMFVars   = NULL;
1438           ShaderProgramVariables::MFVariableChangedType *pMFVarChg = NULL;
1439
1440     if(_sfVariables.getValue() != NULL)
1441     {
1442         pMFVars   = _sfVariables.getValue()->getMFVariables       ();
1443         pMFVarChg = _sfVariables.getValue()->editMFVariableChanged();
1444     }
1445
1446     if(pMFVars == NULL || pMFVars->size() == 0 || pMFVarChg == NULL)
1447     {
1448         return;
1449     }
1450
1451     OSG_ASSERT(pMFVars->size() == pMFVarChg->size());
1452
1453     MFInt32 &vVarLocations = *this->editMFVariableLocations();
1454
1455     OSG_ASSERT(pMFVars->size() == vVarLocations.size());
1456
1457     MFInt32::iterator mLocIt = vVarLocations.begin();
1458
1459     ShaderProgramVariables::MFVariablesType::const_iterator mVarIt  =
1460         pMFVars->begin();
1461     ShaderProgramVariables::MFVariablesType::const_iterator mVarEnd =
1462         pMFVars->end  ();
1463
1464     ShaderProgramVariables::MFVariableChangedType::iterator mVarChgIt =
1465         pMFVarChg->begin();
1466
1467     bool warnUnknown = ShaderVariable::WarnUnknown;
1468
1469     for(; mVarIt != mVarEnd; ++mVarIt, ++mLocIt, ++mVarChgIt)
1470     {
1471         ShaderVariable *pVar = *mVarIt;
1472
1473         if(pVar == NULL)
1474             continue;
1475
1476         if(*mVarChgIt == false)
1477             continue;
1478
1479         *mVarChgIt = false;
1480
1481         osgUniformShaderVariableSwitch(pEnv,    pVar,
1482                                        *mLocIt, uiProgram, warnUnknown);
1483     }
1484 }
1485
1486 void SimpleSHLChunk::updateParameters(DrawEnv *pEnv,
1487                                       UInt32   uiProgram)
1488 {
1489     if(uiProgram == 0 || this->getGeometryVerticesOut() == 0)
1490         return;
1491
1492     OSGGETGLFUNC_EXT(glProgramParameteriEXT,
1493                      osgGlProgramParameteriEXT,
1494                      ShaderProgram::getFuncIdProgramParameteri());
1495
1496     osgGlProgramParameteriEXT(uiProgram,
1497                               GL_GEOMETRY_VERTICES_OUT_EXT,
1498                               this->getGeometryVerticesOut());
1499     osgGlProgramParameteriEXT(uiProgram,
1500                               GL_GEOMETRY_INPUT_TYPE_EXT,
1501                               this->getGeometryInputType());
1502     osgGlProgramParameteriEXT(uiProgram,
1503                               GL_GEOMETRY_OUTPUT_TYPE_EXT,
1504                               this->getGeometryOutputType());
1505 }
1506
1507 void SimpleSHLChunk::updateProceduralVariables(
1508     DrawEnv *pEnv,
1509     UInt32   uiUpdateDependents)
1510 {
1511     UInt32 uiProgram = pEnv->getActiveShader();
1512
1513     if(uiProgram == 0)
1514         return;
1515
1516     const ShaderProgramVariables::MFProceduralVariablesType *pMFVars = NULL;
1517
1518     if(_sfVariables.getValue() != NULL)
1519     {
1520         pMFVars   = _sfVariables.getValue()->getMFProceduralVariables();
1521     }
1522
1523     if(pMFVars == NULL || pMFVars->size() == 0)
1524     {
1525         return;
1526     }
1527
1528     MFInt32 &vVarLocations = *this->editMFProceduralVariableLocations();
1529
1530     OSG_ASSERT(pMFVars->size() == vVarLocations.size());
1531
1532     MFInt32::iterator mLocIt = vVarLocations.begin();
1533
1534     ShaderProgramVariables::MFProceduralVariablesType::const_iterator mVarIt  =
1535         pMFVars->begin();
1536     ShaderProgramVariables::MFProceduralVariablesType::const_iterator mVarEnd =
1537         pMFVars->end  ();
1538
1539     Window *pWin = pEnv->getWindow();
1540
1541     osgSinkUnusedWarning(pWin);
1542
1543 #ifdef OSG_1_COMPAT
1544     if(_fParameterCallback)
1545     {
1546         OSGGETGLFUNCBYID_GL3_ES(glGetUniformLocation,
1547                                 osgGlGetUniformLocation,
1548                                 ShaderProgram::getFuncIdGetUniformLocation(),
1549                                 pWin);
1550
1551         _fParameterCallback(osgGlGetUniformLocation, pEnv, uiProgram);
1552     }
1553 #endif
1554
1555     for(; mVarIt != mVarEnd; ++mVarIt, ++mLocIt)
1556     {
1557         ShaderVariable *pVar = *mVarIt;
1558
1559         switch(pVar->getTypeId())
1560         {
1561             case ShaderVariable::SHVTypeOSG:
1562             {
1563                 ShaderVariableOSG *p =
1564                     dynamic_cast<ShaderVariableOSG *>(pVar);
1565
1566                 if(0x0000 == (p->getDependency() & uiUpdateDependents))
1567                     continue;
1568
1569                 if(*mLocIt == -1)
1570                 {
1571                     OSGGETGLFUNCBYID_GL3_ES(
1572                         glGetUniformLocation,
1573                         osgGlGetUniformLocation,
1574                         ShaderProgram::getFuncIdGetUniformLocation(),
1575                         pWin);
1576
1577                     *mLocIt = osgGlGetUniformLocation(uiProgram,
1578                                                       p->getName().c_str());
1579                 }
1580
1581                 p->evaluate(pEnv, *mLocIt);
1582             }
1583             break;
1584
1585             case ShaderVariable::SHVTypeFunctor:
1586             {
1587                 ShaderVariableFunctor *p =
1588                     dynamic_cast<ShaderVariableFunctor *>(pVar);
1589
1590                 if(0x0000 == (p->getDependency() & uiUpdateDependents))
1591                     continue;
1592
1593                 if(*mLocIt == -1)
1594                 {
1595                     OSGGETGLFUNCBYID_GL3_ES(
1596                         glGetUniformLocation,
1597                         osgGlGetUniformLocation,
1598                         ShaderProgram::getFuncIdGetUniformLocation(),
1599                         pWin);
1600
1601                     *mLocIt = osgGlGetUniformLocation(uiProgram,
1602                                                       p->getName().c_str());
1603                 }
1604
1605 #ifdef OSG_1_COMPAT
1606                 switch(p->getFuncMode())
1607                 {
1608                     case 0:
1609                     {
1610                         p->evaluate(pEnv, *mLocIt);
1611                     }
1612                     break;
1613
1614                     case 1:
1615                     {
1616                         OSGGETGLFUNCBYID_GL3_ES(
1617                             glGetUniformLocation,
1618                             osgGlGetUniformLocation,
1619                             ShaderProgram::getFuncIdGetUniformLocation(),
1620                             pWin);
1621
1622                         p->evaluate(osgGlGetUniformLocation,
1623                                     pEnv,
1624                                     uiProgram);
1625                     }
1626                     break;
1627
1628                     case 2:
1629                     {
1630                         p->evaluate(p,
1631                                     pEnv,
1632                                     uiProgram);
1633                     }
1634                     break;
1635                 }
1636 #else
1637                 p->evaluate(pEnv, *mLocIt);
1638 #endif
1639             }
1640             break;
1641
1642             default:
1643                 break;
1644         }
1645     }
1646 }
1647
1648
1649 OSG_END_NAMESPACE