Source/Contrib/ComputeBase/ComputeShader/OSGComputeShaderChunk.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 "OSGComputeShaderChunk.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 // OSGComputeShaderChunkBase.cpp file.
  60 // To modify it, please change the .fcd file (OSGComputeShaderChunk.fcd) and
  61 // regenerate the base file.
  62
  63 /***************************************************************************\
  64  *                           Class variables                               *
  65 \***************************************************************************/
  66
  67 StateChunkClass ComputeShaderChunk::_class("ShaderProgram", 1, 40);
  68
  69 volatile UInt16 ComputeShaderChunk::_uiChunkCounter = 1;
  70
  71 UInt32 ComputeShaderChunk::_arbComputeShader = Window::invalidExtensionID;
  72
  73 /***************************************************************************\
  74  *                           Class methods                                 *
  75 \***************************************************************************/
  76
  77 void ComputeShaderChunk::initMethod(InitPhase ePhase)
  78 {
  79     Inherited::initMethod(ePhase);
  80
  81     if(ePhase == TypeObject::SystemPost)
  82     {
  83         _arbComputeShader =
  84             Window::registerExtension("GL_ARB_compute_shader");
  85     }
  86 }
  87
  88 UInt32 ComputeShaderChunk::handleGL(DrawEnv                 *pEnv,
  89                                     UInt32                   id,
  90                                     Window::GLObjectStatusE  mode,
  91                                     UInt64                   uiOptions)
  92 {
  93     UInt32  returnValue = 0;
  94     Window *pWin        = pEnv->getWindow();
  95
  96     if(!pWin->hasExtOrVersion(_arbComputeShader, 0x0403, 0xFFFF))
  97     {
  98         FWARNING(("OpenGL compute shader is not supported, couldn't find "
  99                   "extension 'GL_ARB_compute_shader'!\n"));
 100
 101         pWin->setGLObjectId(getGLId(), 0);
 102
 103         return returnValue;
 104     }
 105
 106     if(mode == Window::initialize   ||
 107        mode == Window::reinitialize ||
 108        mode == Window::needrefresh   )
 109     {
 110         GLuint uiProgram = GLuint(pWin->getGLObjectId(getGLId()));;
 111
 112         if(mode != Window::needrefresh)
 113         {
 114             if(uiProgram != 0)
 115             {
 116                 OSGGETGLFUNCBYID_GL3_ES(glDeleteProgram,
 117                                         osgGlDeleteProgram,
 118                                         ShaderProgram::getFuncIdDeleteProgram(),
 119                                         pWin);
 120
 121                 osgGlDeleteProgram(uiProgram);
 122             }
 123
 124             OSGGETGLFUNCBYID_GL3_ES(glCreateProgram,
 125                                     osgGlCreateProgram,
 126                                     ShaderProgram::getFuncIdCreateProgram(),
 127                                     pWin);
 128
 129             OSGGETGLFUNCBYID_GL3_ES(glAttachShader,
 130                                     osgGlAttachShader,
 131                                     ShaderProgram::getFuncIdAttachShader(),
 132                                     pWin);
 133
 134             OSGGETGLFUNCBYID_GL3_ES(glLinkProgram,
 135                                     osgGlLinkProgram,
 136                                     ShaderProgram::getFuncIdLinkProgram(),
 137                                     pWin);
 138
 139             uiProgram = osgGlCreateProgram();
 140
 141             ComputeShaderIt vIt  = _mfComputeShader.begin();
 142             ComputeShaderIt vEnd = _mfComputeShader.end  ();
 143
 144             for(; vIt != vEnd; ++vIt)
 145             {
 146                 (*vIt)->validate(pEnv);
 147
 148                 GLuint uiShader =
 149                     GLuint(pWin->getGLObjectId((*vIt)->getGLId()));
 150
 151                 if(uiShader != 0)
 152                     osgGlAttachShader(uiProgram, uiShader);
 153             }
 154
 155             osgGlLinkProgram(uiProgram);
 156
 157             GLint  iInfoLength;
 158             Char8 *szInfoBuffer = NULL;
 159
 160             OSGGETGLFUNCBYID_GL3_ES(glGetProgramiv,
 161                                     osgGlGetProgramiv,
 162                                     ShaderProgram::getFuncIdGetProgramiv(),
 163                                     pWin);
 164
 165             osgGlGetProgramiv(uiProgram,
 166                               GL_OBJECT_INFO_LOG_LENGTH_ARB,
 167                               &iInfoLength);
 168
 169             if(iInfoLength > 0)
 170             {
 171                 szInfoBuffer = new Char8[iInfoLength];
 172                 szInfoBuffer[0] = '\0';
 173
 174                 OSGGETGLFUNCBYID_GL3_ES(
 175                     glGetProgramInfoLog,
 176                     osgGlGetProgramInfoLog,
 177                     ShaderProgram::getFuncIdGetProgramInfoLog(),
 178                     pWin);
 179
 180                 osgGlGetProgramInfoLog( uiProgram,
 181                                         iInfoLength,
 182                                        &iInfoLength,
 183                                         szInfoBuffer);
 184             }
 185
 186             GLint iStatus = 0;
 187
 188             osgGlGetProgramiv(uiProgram, GL_LINK_STATUS, &iStatus);
 189
 190             if(iStatus == 0)
 191             {
 192                 if(szInfoBuffer != NULL && szInfoBuffer[0] != '\0')
 193                 {
 194                     FFATAL(("Couldn't link compute program!\n%s\n",
 195                             szInfoBuffer));
 196                 }
 197                 else
 198                 {
 199                     FFATAL(("Couldn't link compute program!\n"
 200                             "No further info available\n"));
 201                 }
 202
 203                 OSGGETGLFUNCBYID_GL3_ES(glDeleteProgram,
 204                                         osgGlDeleteProgram,
 205                                         ShaderProgram::getFuncIdDeleteProgram(),
 206                                         pWin);
 207
 208                 osgGlDeleteProgram(uiProgram);
 209
 210                 uiProgram = 0;
 211             }
 212             else
 213             {
 214                 if(szInfoBuffer != NULL && szInfoBuffer[0] != '\0')
 215                 {
 216                     FWARNING(("ComputeShaderChunk: link status: %s\n",
 217                               szInfoBuffer));
 218                 }
 219             }
 220
 221             pWin->setGLObjectId(getGLId(), uiProgram);
 222
 223             updateVariableLocations(pEnv, uiProgram);
 224         }
 225
 226         if(uiProgram != 0)
 227         {
 228             OSGGETGLFUNCBYID_GL3_ES(glUseProgram,
 229                                     osgGlUseProgram,
 230                                     ShaderProgram::getFuncIdUseProgram(),
 231                                     pWin);
 232
 233             osgGlUseProgram(uiProgram);
 234
 235             updateVariables(pEnv, uiProgram);
 236
 237             if(0x0000 == (uiOptions & KeepProgActive))
 238             {
 239                 osgGlUseProgram(0);
 240             }
 241             else
 242             {
 243                 returnValue |= ProgActive;
 244             }
 245         }
 246     }
 247
 248     return returnValue;
 249 }
 250
 251 void ComputeShaderChunk::handleDestroyGL(DrawEnv                 *pEnv,
 252                                          UInt32                   id,
 253                                          Window::GLObjectStatusE  mode)
 254 {
 255     Window *pWin = pEnv->getWindow();
 256
 257     if(!pWin->hasExtOrVersion(_arbComputeShader, 0x0403, 0xFFFF))
 258     {
 259         FWARNING(("OpenGL Shading Language is not supported, couldn't find "
 260                   "extension 'GL_ARB_shading_language_100'!\n"));
 261
 262         pWin->setGLObjectId(id, 0);
 263
 264         return;
 265     }
 266
 267     // BUG this is not called for every window!
 268     if(mode == Window::destroy)
 269     {
 270         GLuint uiProgram = GLuint(pWin->getGLObjectId(id));
 271
 272         if(uiProgram != 0)
 273         {
 274             OSGGETGLFUNCBYID_GL3_ES(glDeleteProgram,
 275                                     osgGlDeleteProgram,
 276                                     ShaderProgram::getFuncIdDeleteProgram(),
 277                                     pWin);
 278
 279             osgGlDeleteProgram(uiProgram);
 280
 281             pWin->setGLObjectId(id, 0);
 282         }
 283     }
 284     else if(mode == Window::finaldestroy)
 285     {
 286         ;//SWARNING << "Last program user destroyed" << std::endl;
 287     }
 288 }
 289
 290 /***************************************************************************\
 291  *                           Instance methods                              *
 292 \***************************************************************************/
 293
 294 /*-------------------------------------------------------------------------*\
 295  -  private                                                                 -
 296 \*-------------------------------------------------------------------------*/
 297
 298 /*----------------------- constructors & destructors ----------------------*/
 299
 300 ComputeShaderChunk::ComputeShaderChunk(void) :
 301      Inherited( ),
 302     _uiChunkId(0)
 303 {
 304 }
 305
 306 ComputeShaderChunk::ComputeShaderChunk(const ComputeShaderChunk &source) :
 307      Inherited(source),
 308     _uiChunkId(0     )
 309 {
 310 }
 311
 312 ComputeShaderChunk::~ComputeShaderChunk(void)
 313 {
 314 }
 315
 316 void ComputeShaderChunk::onCreate(const ComputeShaderChunk *source)
 317 {
 318     Inherited::onCreate(source);
 319
 320     // ignore prototypes.
 321     if(GlobalSystemState == Startup)
 322         return;
 323
 324     setGLId(
 325         Window::registerGLObject(
 326             boost::bind(&ComputeShaderChunk::handleGL,
 327                         ComputeShaderChunkMTUncountedPtr(this),
 328                         _1, _2, _3, _4),
 329             &ComputeShaderChunk::handleDestroyGL));
 330
 331     _uiChunkId = ComputeShaderChunk::_uiChunkCounter++;
 332 }
 333
 334 void ComputeShaderChunk::onCreateAspect(const ComputeShaderChunk *createAspect,
 335                                         const ComputeShaderChunk *source      )
 336 {
 337     Inherited::onCreateAspect(createAspect, source);
 338
 339     _uiChunkId = createAspect->_uiChunkId;
 340 }
 341
 342 void ComputeShaderChunk::onDestroy(UInt32 uiId)
 343 {
 344     if(getGLId() > 0)
 345         Window::destroyGLObject(getGLId(), 1);
 346
 347     Inherited::onDestroy(uiId);
 348 }
 349
 350 const StateChunkClass *ComputeShaderChunk::getClass(void) const
 351 {
 352     return &_class;
 353 }
 354
 355 UInt16 ComputeShaderChunk::getChunkId(void)
 356 {
 357     return _uiChunkId;
 358 }
 359
 360 /*----------------------------- class specific ----------------------------*/
 361
 362 void ComputeShaderChunk::changed(ConstFieldMaskArg whichField,
 363                              UInt32            origin,
 364                              BitVector         details)
 365 {
 366     bool bMarkChanged = false;
 367
 368     if(0x0000 != (whichField & ComputeProgramFieldMask) &&
 369        0      != _sfComputeProgram.getValue().size()     )
 370     {
 371         if(_mfComputeShader.size() == 0)
 372         {
 373             ShaderProgramUnrecPtr pProg = ShaderProgram::createDependent(
 374                 this->getFieldFlags()->_bNamespaceMask);
 375
 376             pProg->setShaderType(GL_COMPUTE_SHADER);
 377
 378             addComputeShader(pProg);
 379
 380             pProg->setVariables(this->getVariables());
 381         }
 382         else if(_mfComputeShader.size() > 1)
 383         {
 384             editMFComputeShader()->resize(1);
 385         }
 386
 387         _mfComputeShader[0]->setProgram(_sfComputeProgram.getValue());
 388
 389         bMarkChanged = true;
 390
 391         Window::reinitializeGLObject(this->getGLId());
 392     }
 393
 394
 395     if(0x0000 != (whichField & VariablesFieldMask))
 396     {
 397         ShaderProgramVariables *pVars = _sfVariables.getValue();
 398
 399         if(pVars != NULL)
 400         {
 401             if(details == 0x0001)
 402             {
 403                 // be save reset all locations
 404
 405                 if(pVars->getMFVariables()->size() == 0)
 406                 {
 407                     editMFVariableLocations()->clear();
 408                 }
 409                 else
 410                 {
 411                     editMFVariableLocations()->resize(
 412                         pVars->getMFVariables()->size(),
 413                         -1);
 414
 415                     std::fill(editMFVariableLocations()->begin(),
 416                               editMFVariableLocations()->end  (),
 417                               -1);
 418                 }
 419
 420                 // be save reset all locations
 421
 422                 if(pVars->getMFProceduralVariables()->size() == 0     )
 423                 {
 424                     editMFProceduralVariableLocations()->clear();
 425                 }
 426                 else
 427                 {
 428                     editMFProceduralVariableLocations()->resize(
 429                         pVars->getMFProceduralVariables()->size(),
 430                         -1);
 431
 432                     std::fill(editMFProceduralVariableLocations()->begin(),
 433                               editMFProceduralVariableLocations()->end  (),
 434                               -1);
 435                 }
 436             }
 437         }
 438
 439         Window::refreshGLObject(this->getGLId());
 440     }
 441
 442     if(0x0000 != (whichField & ComputeShaderFieldMask))
 443     {
 444         bMarkChanged = true;
 445
 446         Window::reinitializeGLObject(this->getGLId());
 447     }
 448
 449     if(bMarkChanged == true)
 450     {
 451         // be save reset all locations
 452
 453         std::fill(editMFVariableLocations()->begin(),
 454                   editMFVariableLocations()->end  (),
 455                   -1);
 456
 457         std::fill(editMFProceduralVariableLocations()->begin(),
 458                   editMFProceduralVariableLocations()->end  (),
 459                   -1);
 460
 461         if(_sfVariables.getValue() != NULL)
 462         {
 463             _sfVariables.getValue()->markAllChanged();
 464         }
 465     }
 466
 467     Inherited::changed(whichField, origin, details);
 468 }
 469
 470 void ComputeShaderChunk::activate(DrawEnv    *pEnv,
 471                                   UInt32      uiIdx)
 472 {
 473     Window *pWin    = pEnv->getWindow();
 474
 475     UInt32 uiValRes = pWin->validateGLObject(getGLId(),
 476                                              pEnv,
 477                                              KeepProgActive);
 478
 479     GLuint uiProgId = GLuint(pWin->getGLObjectId(getGLId()));
 480
 481     if(uiProgId == 0)
 482         return;
 483
 484     pEnv->setActiveShader(uiProgId);
 485
 486     if(0x0000 == (uiValRes & ProgActive))
 487     {
 488         OSGGETGLFUNCBYID_GL3_ES(glUseProgram,
 489                                 osgGlUseProgram,
 490                                 ShaderProgram::getFuncIdUseProgram(),
 491                                 pWin);
 492
 493         osgGlUseProgram(uiProgId);
 494     }
 495
 496     pEnv->incNumShaderChanges();
 497
 498     updateProceduralVariables(pEnv, ShaderProcVariable::SHDAll);
 499
 500 }
 501
 502 void ComputeShaderChunk::changeFrom(DrawEnv    *pEnv,
 503                                     StateChunk *pOther,
 504                                     UInt32      uiIdx)
 505 {
 506     ComputeShaderChunk *pOld = dynamic_cast<ComputeShaderChunk *>(pOther);
 507
 508     // pOther can be a ShaderExecutableChunk, since we share the StateClass id
 509     // with it
 510     if(pOld != NULL)
 511     {
 512         Window   *pWin     = pEnv->getWindow();
 513         GLuint    uiProgId = GLuint(pWin->getGLObjectId(getGLId()));
 514
 515         UInt32 uiDep = ShaderProcVariable::SHDObject;
 516
 517         if(uiProgId != pEnv->getActiveShader())
 518         {
 519             UInt32 uiValRes = pWin->validateGLObject(getGLId(),
 520                                                      pEnv,
 521                                                      KeepProgActive);
 522
 523             uiProgId = GLuint(pWin->getGLObjectId(getGLId()));
 524
 525             if(uiProgId == 0)
 526                 return;
 527
 528             pEnv->setActiveShader(uiProgId);
 529
 530             if(0x0000 == (uiValRes & ProgActive))
 531             {
 532                 OSGGETGLFUNCBYID_GL3_ES(glUseProgram,
 533                                         osgGlUseProgram,
 534                                         ShaderProgram::getFuncIdUseProgram(),
 535                                         pWin);
 536
 537                 osgGlUseProgram(uiProgId);
 538             }
 539
 540             uiDep = ShaderProcVariable::SHDAll;
 541
 542             pEnv->incNumShaderChanges();
 543         }
 544
 545         updateProceduralVariables(pEnv, uiDep);
 546     }
 547     else
 548     {
 549         pOther->deactivate(pEnv, uiIdx);
 550         activate          (pEnv, uiIdx);
 551
 552         pEnv->incNumShaderChanges();
 553     }
 554 }
 555
 556 void ComputeShaderChunk::deactivate(DrawEnv    *pEnv,
 557                                     UInt32      uiIdx)
 558 {
 559     if(pEnv->getWindow()->getGLObjectId(getGLId()) == 0)
 560         return;
 561
 562     pEnv->setActiveShader(0);
 563
 564     OSGGETGLFUNC_GL3_ES(glUseProgram,
 565                         osgGlUseProgram,
 566                         ShaderProgram::getFuncIdUseProgram());
 567
 568     osgGlUseProgram(0);
 569 }
 570
 571 void ComputeShaderChunk::dump(      UInt32    ,
 572                               const BitVector ) const
 573 {
 574     SLOG << "Dump ComputeShaderChunk NI" << std::endl;
 575 }
 576
 577 bool ComputeShaderChunk::readComputeProgram(const Char8 *file)
 578 {
 579     return readProgram(editSFComputeProgram()->getValue(), file);
 580 }
 581
 582 bool ComputeShaderChunk::readProgram(      std::string  &szTarget,
 583                                      const Char8        *szFilename)
 584 {
 585     std::ifstream s(szFilename);
 586
 587     if(s.good())
 588     {
 589         return readProgram(szTarget, s);
 590     }
 591     else
 592     {
 593         FWARNING(("ShaderChunk::readProgram: couldn't open '%s' "
 594                   "for reading!\n", szFilename));
 595
 596         return false;
 597     }
 598
 599 }
 600
 601 bool ComputeShaderChunk::readProgram(std::string  &szTarget,
 602                                      std::istream &iStream)
 603 {
 604 #define BUFSIZE 200
 605
 606     szTarget.erase();
 607
 608     Char8 buf[BUFSIZE];
 609
 610     if(!iStream.good())
 611     {
 612         FWARNING(("SHLChunk::readProgram: stream is not good!\n"));
 613
 614         return false;
 615     }
 616
 617     do
 618     {
 619         iStream.read(buf, BUFSIZE);
 620
 621         szTarget.append(buf, iStream.gcount());
 622     }
 623     while(!iStream.eof());
 624
 625     return true;
 626 }
 627
 628 bool ComputeShaderChunk::subUniformVariable(const Char8 *name)
 629 {
 630     if(_sfVariables.getValue() != NULL)
 631     {
 632         return _sfVariables.getValue()->subUniformVariable(
 633             name,
 634             editMFVariableLocations(),
 635             editMFProceduralVariableLocations());
 636
 637     }
 638
 639     return false;
 640 }
 641
 642 void ComputeShaderChunk::clearUniformVariables(void)
 643 {
 644     if(_sfVariables.getValue() != NULL)
 645     {
 646         _sfVariables.getValue()->clearUniformVariables();
 647     }
 648
 649     editMFVariableLocations          ()->clear();
 650     editMFProceduralVariableLocations()->clear();
 651 }
 652
 653 bool ComputeShaderChunk::addOSGVariable(const Char8 *name)
 654 {
 655     if(_sfVariables.getValue() == NULL)
 656     {
 657         ShaderProgramVariablesUnrecPtr pVar =
 658             ShaderProgramVariables::createDependent(
 659                 this->getFieldFlags()->_bNamespaceMask);
 660
 661         setVariables(pVar);
 662
 663         if(_mfComputeShader.size() > 0)
 664         {
 665             _mfComputeShader[0]->setVariables(this->getVariables());
 666         }
 667     }
 668
 669     return _sfVariables.getValue()->addOSGVariable(
 670         name,
 671         editMFProceduralVariableLocations());
 672 }
 673
 674 bool ComputeShaderChunk::addProceduralVariable(
 675     const Char8          *name,
 676           ProcVarFunctor  pFunc,
 677           UInt32          uiDependency)
 678 {
 679     if(_sfVariables.getValue() == NULL)
 680     {
 681         ShaderProgramVariablesUnrecPtr pParam =
 682             ShaderProgramVariables::createDependent(
 683                 this->getFieldFlags()->_bNamespaceMask);
 684
 685         setVariables(pParam);
 686
 687         if(_mfComputeShader.size() > 0)
 688         {
 689             _mfComputeShader[0]->setVariables(this->getVariables());
 690         }
 691     }
 692
 693     return _sfVariables.getValue()->addProceduralVariable(
 694         name,
 695         pFunc,
 696         uiDependency,
 697         editMFProceduralVariableLocations());
 698 }
 699
 700 bool ComputeShaderChunk::updateNodeProceduralVariable(
 701     const Char8             *name,
 702           ProcVarNodeFunctor pFunc,
 703           UInt32             uiDependency)
 704 {
 705     if(_sfVariables.getValue() == NULL)
 706     {
 707         ShaderProgramVariablesUnrecPtr pParam =
 708             ShaderProgramVariables::createDependent(
 709                 this->getFieldFlags()->_bNamespaceMask);
 710
 711         setVariables(pParam);
 712
 713         if(_mfComputeShader.size() > 0)
 714         {
 715             _mfComputeShader[0]->setVariables(this->getVariables());
 716         }
 717     }
 718
 719     return _sfVariables.getValue()->updateNodeProceduralVariable(name,
 720                                                                  pFunc,
 721                                                                  uiDependency);
 722 }
 723
 724 bool ComputeShaderChunk::addNodeProceduralVariable(
 725     const Char8              *name,
 726           ProcVarNodeFunctor  pFunc,
 727           UInt32              uiDependency)
 728 {
 729     if(_sfVariables.getValue() == NULL)
 730     {
 731         ShaderProgramVariablesUnrecPtr pParam =
 732             ShaderProgramVariables::createDependent(
 733                 this->getFieldFlags()->_bNamespaceMask);
 734
 735         setVariables(pParam);
 736
 737         if(_mfComputeShader.size() > 0)
 738         {
 739             _mfComputeShader[0]->setVariables(this->getVariables());
 740         }
 741     }
 742
 743     return _sfVariables.getValue()->addNodeProceduralVariable(
 744         name,
 745         pFunc,
 746         uiDependency,
 747         editMFProceduralVariableLocations());
 748 }
 749
 750 bool ComputeShaderChunk::updateProceduralVariable(
 751     const Char8         *name,
 752           ProcVarFunctor pFunc,
 753           UInt32         uiDependency)
 754 {
 755     if(_sfVariables.getValue() == NULL)
 756     {
 757         ShaderProgramVariablesUnrecPtr pParam =
 758             ShaderProgramVariables::createDependent(
 759                 this->getFieldFlags()->_bNamespaceMask);
 760
 761         setVariables(pParam);
 762
 763         if(_mfComputeShader.size() > 0)
 764         {
 765             _mfComputeShader[0]->setVariables(this->getVariables());
 766         }
 767     }
 768
 769     return _sfVariables.getValue()->updateProceduralVariable(name,
 770                                                              pFunc,
 771                                                              uiDependency);
 772 }
 773
 774 #if 0
 775 void ComputeShaderChunk::updateParameters(
 776     Window                         *win,
 777     const UInt32                         &parameters,
 778     bool                            useProgram,
 779     bool                            force,
 780     bool                            keepProgramActive)
 781 {
 782 }
 783
 784 const UInt32 *ComputeShaderChunk::getMFParameters(void) const
 785 {
 786     static UInt32 foo;
 787
 788     return &foo;
 789 }
 790 #endif
 791
 792 void ComputeShaderChunk::updateVariableLocations(DrawEnv *pEnv,
 793                                                  UInt32   uiProgram)
 794 {
 795     if(uiProgram == 0)
 796         return;
 797
 798     const ShaderProgramVariables::MFVariablesType           *pMFVars     = NULL;
 799     const ShaderProgramVariables::MFProceduralVariablesType *pMFProcVars = NULL;
 800
 801     if(_sfVariables.getValue() != NULL)
 802     {
 803         pMFVars     = _sfVariables.getValue()->getMFVariables          ();
 804         pMFProcVars = _sfVariables.getValue()->getMFProceduralVariables();
 805     }
 806
 807     if(pMFVars != NULL && pMFVars->size() != 0)
 808     {
 809         MFInt32 &vVarLocations = *this->editMFVariableLocations();
 810
 811         OSG_ASSERT(pMFVars->size() == vVarLocations.size());
 812
 813         MFInt32::iterator mLocIt = vVarLocations.begin();
 814
 815         ShaderProgramVariables::MFVariablesType::const_iterator mVarIt  =
 816             pMFVars->begin();
 817         ShaderProgramVariables::MFVariablesType::const_iterator mVarEnd =
 818             pMFVars->end  ();
 819
 820         OSGGETGLFUNC_GL3_ES(glGetUniformLocation,
 821                             osgGlGetUniformLocation,
 822                             ShaderProgram::getFuncIdGetUniformLocation());
 823
 824         for(; mVarIt != mVarEnd; ++mVarIt, ++mLocIt)
 825         {
 826             *mLocIt = osgGlGetUniformLocation(uiProgram,
 827                                               (*mVarIt)->getName().c_str());
 828         }
 829     }
 830
 831     if(pMFProcVars != NULL && pMFProcVars->size() != 0)
 832     {
 833         MFInt32 &vVarLocations = *this->editMFProceduralVariableLocations();
 834
 835         OSG_ASSERT(pMFProcVars->size() == vVarLocations.size());
 836
 837         MFInt32::iterator mLocIt = vVarLocations.begin();
 838
 839         ShaderProgramVariables::MFProceduralVariablesType::const_iterator
 840             mVarIt  = pMFProcVars->begin();
 841         ShaderProgramVariables::MFProceduralVariablesType::const_iterator
 842             mVarEnd = pMFProcVars->end  ();
 843
 844         OSGGETGLFUNC_GL3_ES(glGetUniformLocation,
 845                             osgGlGetUniformLocation,
 846                             ShaderProgram::getFuncIdGetUniformLocation());
 847
 848         for(; mVarIt != mVarEnd; ++mVarIt, ++mLocIt)
 849         {
 850             *mLocIt = osgGlGetUniformLocation(uiProgram,
 851                                               (*mVarIt)->getName().c_str());
 852         }
 853     }
 854 }
 855
 856 void ComputeShaderChunk::updateVariables(DrawEnv *pEnv,
 857                                      UInt32   uiProgram)
 858 {
 859     if(uiProgram == 0)
 860         return;
 861
 862     const ShaderProgramVariables::MFVariablesType       *pMFVars   = NULL;
 863           ShaderProgramVariables::MFVariableChangedType *pMFVarChg = NULL;
 864
 865     if(_sfVariables.getValue() != NULL)
 866     {
 867         pMFVars   = _sfVariables.getValue()->getMFVariables       ();
 868         pMFVarChg = _sfVariables.getValue()->editMFVariableChanged();
 869     }
 870
 871     if(pMFVars == NULL || pMFVars->size() == 0 || pMFVarChg == NULL)
 872     {
 873         return;
 874     }
 875
 876     OSG_ASSERT(pMFVars->size() == pMFVarChg->size());
 877
 878     MFInt32 &vVarLocations = *this->editMFVariableLocations();
 879
 880     OSG_ASSERT(pMFVars->size() == vVarLocations.size());
 881
 882     MFInt32::iterator mLocIt = vVarLocations.begin();
 883
 884     ShaderProgramVariables::MFVariablesType::const_iterator mVarIt  =
 885         pMFVars->begin();
 886     ShaderProgramVariables::MFVariablesType::const_iterator mVarEnd =
 887         pMFVars->end  ();
 888
 889     ShaderProgramVariables::MFVariableChangedType::iterator mVarChgIt =
 890         pMFVarChg->begin();
 891
 892     bool warnUnknown = ShaderVariable::WarnUnknown;
 893
 894     for(; mVarIt != mVarEnd; ++mVarIt, ++mLocIt, ++mVarChgIt)
 895     {
 896         ShaderVariable *pVar = *mVarIt;
 897
 898         if(pVar == NULL)
 899             continue;
 900
 901         if(*mVarChgIt == false)
 902             continue;
 903
 904         *mVarChgIt = false;
 905
 906         osgUniformShaderVariableSwitch(pEnv,    pVar,
 907                                        *mLocIt, uiProgram, warnUnknown);
 908     }
 909 }
 910
 911 void ComputeShaderChunk::updateProceduralVariables(
 912     DrawEnv *pEnv,
 913     UInt32   uiUpdateDependents)
 914 {
 915     UInt32 uiProgram = pEnv->getActiveShader();
 916
 917     if(uiProgram == 0)
 918         return;
 919
 920     const ShaderProgramVariables::MFProceduralVariablesType *pMFVars = NULL;
 921
 922     if(_sfVariables.getValue() != NULL)
 923     {
 924         pMFVars   = _sfVariables.getValue()->getMFProceduralVariables();
 925     }
 926
 927     if(pMFVars == NULL || pMFVars->size() == 0)
 928     {
 929         return;
 930     }
 931
 932     MFInt32 &vVarLocations = *this->editMFProceduralVariableLocations();
 933
 934     OSG_ASSERT(pMFVars->size() == vVarLocations.size());
 935
 936     MFInt32::iterator mLocIt = vVarLocations.begin();
 937
 938     ShaderProgramVariables::MFProceduralVariablesType::const_iterator mVarIt  =
 939         pMFVars->begin();
 940     ShaderProgramVariables::MFProceduralVariablesType::const_iterator mVarEnd =
 941         pMFVars->end  ();
 942
 943     Window *pWin = pEnv->getWindow();
 944
 945     osgSinkUnusedWarning(pWin);
 946
 947     for(; mVarIt != mVarEnd; ++mVarIt, ++mLocIt)
 948     {
 949         ShaderVariable *pVar = *mVarIt;
 950
 951         switch(pVar->getTypeId())
 952         {
 953             case ShaderVariable::SHVTypeOSG:
 954             {
 955                 ShaderVariableOSG *p =
 956                     dynamic_cast<ShaderVariableOSG *>(pVar);
 957
 958                 if(0x0000 == (p->getDependency() & uiUpdateDependents))
 959                     continue;
 960
 961                 if(*mLocIt == -1)
 962                 {
 963                     OSGGETGLFUNCBYID_GL3_ES(
 964                         glGetUniformLocation,
 965                         osgGlGetUniformLocation,
 966                         ShaderProgram::getFuncIdGetUniformLocation(),
 967                         pWin);
 968
 969                     *mLocIt = osgGlGetUniformLocation(uiProgram,
 970                                                       p->getName().c_str());
 971                 }
 972
 973                 p->evaluate(pEnv, *mLocIt);
 974             }
 975             break;
 976
 977             case ShaderVariable::SHVTypeFunctor:
 978             {
 979                 ShaderVariableFunctor *p =
 980                     dynamic_cast<ShaderVariableFunctor *>(pVar);
 981
 982                 if(0x0000 == (p->getDependency() & uiUpdateDependents))
 983                     continue;
 984
 985                 if(*mLocIt == -1)
 986                 {
 987                     OSGGETGLFUNCBYID_GL3_ES(
 988                         glGetUniformLocation,
 989                         osgGlGetUniformLocation,
 990                         ShaderProgram::getFuncIdGetUniformLocation(),
 991                         pWin);
 992
 993                     *mLocIt = osgGlGetUniformLocation(uiProgram,
 994                                                       p->getName().c_str());
 995                 }
 996
 997                 p->evaluate(pEnv, *mLocIt);
 998             }
 999             break;
1000
1001             default:
1002                 break;
1003         }
1004     }
1005 }
1006
1007
1008 OSG_END_NAMESPACE