Source/System/State/Shader/Variables/OSGShaderVariableOSG.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *               Copyright (C) 2000-2002 by the OpenSG Forum                 *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 //---------------------------------------------------------------------------
  40 //  Includes
  41 //---------------------------------------------------------------------------
  42
  43 #include <cstdlib>
  44 #include <cstdio>
  45
  46 #include "OSGConfig.h"
  47
  48 #include "OSGShaderVariableOSG.h"
  49 #include "OSGGLFuncProtos.h"
  50 #include "OSGShaderProgram.h"
  51
  52 #include "OSGDrawEnv.h"
  53 #include "OSGWindow.h"
  54 #include "OSGNode.h"
  55
  56 #include "OSGConceptPropertyChecks.h"
  57
  58 OSG_USING_NAMESPACE
  59
  60 // Documentation for this class is emited in the
  61 // OSGShaderVariableOSGBase.cpp file.
  62 // To modify it, please change the .fcd file (OSGShaderVariableOSG.fcd) and
  63 // regenerate the base file.
  64
  65 /***************************************************************************\
  66  *                           Class variables                               *
  67 \***************************************************************************/
  68
  69 /***************************************************************************\
  70  *                           Class methods                                 *
  71 \***************************************************************************/
  72
  73 void ShaderVariableOSG::initMethod(InitPhase ePhase)
  74 {
  75     Inherited::initMethod(ePhase);
  76 }
  77
  78
  79 /***************************************************************************\
  80  *                           Instance methods                              *
  81 \***************************************************************************/
  82
  83 /*-------------------------------------------------------------------------*\
  84  -  private                                                                 -
  85 \*-------------------------------------------------------------------------*/
  86
  87 /*----------------------- constructors & destructors ----------------------*/
  88
  89 ShaderVariableOSG::ShaderVariableOSG(void) :
  90     Inherited()
  91 {
  92     setTypeId(ShaderVariable::SHVTypeOSG);
  93 }
  94
  95 ShaderVariableOSG::ShaderVariableOSG(const ShaderVariableOSG &source) :
  96     Inherited(source)
  97 {
  98 }
  99
 100 ShaderVariableOSG::~ShaderVariableOSG(void)
 101 {
 102 }
 103
 104 /*----------------------------- class specific ----------------------------*/
 105
 106 void ShaderVariableOSG::changed(ConstFieldMaskArg whichField,
 107                                 UInt32            origin,
 108                                 BitVector         details)
 109 {
 110     Inherited::changed(whichField, origin, details);
 111
 112     if(0x0000 != (whichField & NameFieldMask))
 113     {
 114         if(_sfName.getValue() == "OSGWorldMatrix")
 115         {
 116             setOsgVarType(OSGWorldMatrix);
 117             setDependency(SHDObject     );
 118         }
 119         else if(_sfName.getValue() == "OSGInvWorldMatrix")
 120         {
 121             setOsgVarType(OSGInvWorldMatrix);
 122             setDependency(SHDObject        );
 123         }
 124         else if(_sfName.getValue() == "OSGTransInvWorldMatrix")
 125         {
 126             setOsgVarType(OSGTransInvWorldMatrix);
 127             setDependency(SHDObject             );
 128         }
 129         else if(_sfName.getValue() == "OSGCameraOrientation")
 130         {
 131             setOsgVarType(OSGCameraOrientation);
 132             setDependency(SHDScene            );
 133         }
 134         else if(_sfName.getValue() == "OSGCameraPosition")
 135         {
 136             setOsgVarType(OSGCameraPosition);
 137             setDependency(SHDScene         );
 138         }
 139         else if(_sfName.getValue() == "OSGViewMatrix")
 140         {
 141             setOsgVarType(OSGViewMatrix);
 142             setDependency(SHDScene     );
 143         }
 144         else if(_sfName.getValue() == "OSGInvViewMatrix")
 145         {
 146             setOsgVarType(OSGInvViewMatrix);
 147             setDependency(SHDScene        );
 148         }
 149         else if(_sfName.getValue() == "OSGProjectionMatrix")
 150         {
 151             setOsgVarType(OSGProjectionMatrix);
 152             setDependency(SHDScene           );
 153         }
 154         else if(_sfName.getValue() == "OSGModelViewMatrix")
 155         {
 156             setOsgVarType(OSGModelViewMatrix);
 157             setDependency(SHDObject          );
 158         }
 159         else if(_sfName.getValue() == "OSGViewportSize")
 160         {
 161             setOsgVarType(OSGViewportSize);
 162             setDependency(SHDScene       );
 163         }
 164 #ifdef OSG_OGL_COREONLY
 165         else if(_sfName.getValue() == "OSGNormalMatrix")
 166         {
 167             setOsgVarType(OSGNormalMatrix);
 168             setDependency(SHDObject      );
 169         }
 170         else if(_sfName.getValue() == "OSGModelViewProjectionMatrix")
 171         {
 172             setOsgVarType(OSGModelViewProjectionMatrix);
 173             setDependency(SHDObject                   );
 174         }
 175 #endif
 176         else if(_sfName.getValue() == "OSGStereoLeftEye")
 177         {
 178             setOsgVarType(OSGStereoLeftEye);
 179             setDependency(SHDScene        );
 180         }
 181         else if(_sfName.getValue() == "OSGDrawerId")
 182         {
 183             setOsgVarType(OSGDrawerId);
 184             setDependency(SHDScene    );
 185         }
 186         else if(_sfName.getValue() == "OSGDrawableId")
 187         {
 188             setOsgVarType(OSGDrawableId);
 189             setDependency(SHDScene     );
 190         }
 191         else if(_sfName.getValue() == "OSGNodeId")
 192         {
 193             setOsgVarType(OSGNodeId);
 194             setDependency(SHDObject);
 195         }
 196         else if(_sfName.getValue() == "OSGNodeBoxMin")
 197         {
 198             setOsgVarType(OSGNodeBoxMin);
 199             setDependency(SHDObject    );
 200         }
 201         else if(_sfName.getValue() == "OSGNodeBoxMax")
 202         {
 203             setOsgVarType(OSGNodeBoxMax);
 204             setDependency(SHDObject    );
 205         }
 206         else if(_sfName.getValue() == "OSGNodeBoxCenter")
 207         {
 208             setOsgVarType(OSGNodeBoxCenter);
 209             setDependency(SHDObject       );
 210         }
 211         else if(_sfName.getValue() == "OSGNodeWorldBoxMin")
 212         {
 213             setOsgVarType(OSGNodeWorldBoxMin);
 214             setDependency(SHDObject         );
 215         }
 216         else if(_sfName.getValue() == "OSGNodeWorldBoxMax")
 217         {
 218             setOsgVarType(OSGNodeWorldBoxMax);
 219             setDependency(SHDObject         );
 220         }
 221         else if(_sfName.getValue() == "OSGNodeWorldBoxCenter")
 222         {
 223             setOsgVarType(OSGNodeWorldBoxCenter);
 224             setDependency(SHDObject            );
 225         }
 226         else if(_sfName.getValue() == "OSGActiveLightsMask")
 227         {
 228             setOsgVarType(OSGActiveLightsMask);
 229             setDependency(SHDObject          );
 230         }
 231         else if(_sfName.getValue() == "OSGLight0Active")
 232         {
 233             setOsgVarType(OSGLight0Active);
 234             setDependency(SHDObject      );
 235         }
 236         else if(_sfName.getValue() == "OSGLight1Active")
 237         {
 238             setOsgVarType(OSGLight1Active);
 239             setDependency(SHDObject      );
 240         }
 241         else if(_sfName.getValue() == "OSGLight2Active")
 242         {
 243             setOsgVarType(OSGLight2Active);
 244             setDependency(SHDObject      );
 245         }
 246         else if(_sfName.getValue() == "OSGLight3Active")
 247         {
 248             setOsgVarType(OSGLight3Active);
 249             setDependency(SHDObject      );
 250         }
 251         else if(_sfName.getValue() == "OSGLight4Active")
 252         {
 253             setOsgVarType(OSGLight4Active);
 254             setDependency(SHDObject      );
 255         }
 256         else if(_sfName.getValue() == "OSGLight5Active")
 257         {
 258             setOsgVarType(OSGLight5Active);
 259             setDependency(SHDObject      );
 260         }
 261         else if(_sfName.getValue() == "OSGLight6Active")
 262         {
 263             setOsgVarType(OSGLight6Active);
 264             setDependency(SHDObject      );
 265         }
 266         else if(_sfName.getValue() == "OSGLight7Active")
 267         {
 268             setOsgVarType(OSGLight7Active);
 269             setDependency(SHDObject      );
 270         }
 271         else
 272         {
 273             setOsgVarType(OSGUnknown);
 274             setDependency(SHDObject );
 275         }
 276     }
 277 }
 278
 279 void ShaderVariableOSG::dump(      UInt32    ,
 280                              const BitVector ) const
 281 {
 282     SLOG << "Dump ShaderVariableOSG NI" << std::endl;
 283 }
 284
 285 bool ShaderVariableOSG::isProcedural(void) const
 286 {
 287     return true;
 288 }
 289
 290 void ShaderVariableOSG::setName(const std::string &value)
 291 {
 292     Inherited::setName(value);
 293
 294     if(_sfName.getValue() == "OSGWorldMatrix")
 295     {
 296         setOsgVarType(OSGWorldMatrix);
 297         setDependency(SHDObject     );
 298     }
 299     else if(_sfName.getValue() == "OSGInvWorldMatrix")
 300     {
 301         setOsgVarType(OSGInvWorldMatrix);
 302         setDependency(SHDObject        );
 303     }
 304     else if(_sfName.getValue() == "OSGTransInvWorldMatrix")
 305     {
 306         setOsgVarType(OSGTransInvWorldMatrix);
 307         setDependency(SHDObject             );
 308     }
 309     else if(_sfName.getValue() == "OSGCameraOrientation")
 310     {
 311         setOsgVarType(OSGCameraOrientation);
 312         setDependency(SHDScene            );
 313     }
 314     else if(_sfName.getValue() == "OSGCameraPosition")
 315     {
 316         setOsgVarType(OSGCameraPosition);
 317         setDependency(SHDScene         );
 318     }
 319     else if(_sfName.getValue() == "OSGViewMatrix")
 320     {
 321         setOsgVarType(OSGViewMatrix);
 322         setDependency(SHDScene     );
 323     }
 324     else if(_sfName.getValue() == "OSGInvViewMatrix")
 325     {
 326         setOsgVarType(OSGInvViewMatrix);
 327         setDependency(SHDScene        );
 328     }
 329     else if(_sfName.getValue() == "OSGProjectionMatrix")
 330     {
 331         setOsgVarType(OSGProjectionMatrix);
 332         setDependency(SHDScene           );
 333     }
 334     else if(_sfName.getValue() == "OSGModelViewMatrix")
 335     {
 336         setOsgVarType(OSGModelViewMatrix);
 337         setDependency(SHDObject         );
 338     }
 339     else if(_sfName.getValue() == "OSGViewportSize")
 340     {
 341         setOsgVarType(OSGViewportSize);
 342         setDependency(SHDScene       );
 343     }
 344 #ifdef OSG_OGL_COREONLY
 345     else if(_sfName.getValue() == "OSGNormalMatrix")
 346     {
 347         setOsgVarType(OSGNormalMatrix);
 348         setDependency(SHDObject      );
 349     }
 350     else if(_sfName.getValue() == "OSGModelViewProjectionMatrix")
 351     {
 352         setOsgVarType(OSGModelViewProjectionMatrix);
 353         setDependency(SHDObject                   );
 354     }
 355 #endif
 356     else if(_sfName.getValue() == "OSGStereoLeftEye")
 357     {
 358         setOsgVarType(OSGStereoLeftEye);
 359         setDependency(SHDScene        );
 360     }
 361     else if(_sfName.getValue() == "OSGDrawerId")
 362     {
 363         setOsgVarType(OSGDrawerId);
 364         setDependency(SHDScene   );
 365     }
 366     else if(_sfName.getValue() == "OSGDrawableId")
 367     {
 368         setOsgVarType(OSGDrawableId);
 369         setDependency(SHDScene     );
 370     }
 371     else if(_sfName.getValue() == "OSGNodeId")
 372     {
 373         setOsgVarType(OSGNodeId);
 374         setDependency(SHDObject);
 375     }
 376     else if(_sfName.getValue() == "OSGNodeBoxMin")
 377     {
 378         setOsgVarType(OSGNodeBoxMin);
 379         setDependency(SHDObject    );
 380     }
 381     else if(_sfName.getValue() == "OSGNodeBoxMax")
 382     {
 383         setOsgVarType(OSGNodeBoxMax);
 384         setDependency(SHDObject    );
 385     }
 386     else if(_sfName.getValue() == "OSGNodeBoxCenter")
 387     {
 388         setOsgVarType(OSGNodeBoxCenter);
 389         setDependency(SHDObject       );
 390     }
 391     else if(_sfName.getValue() == "OSGNodeWorldBoxMin")
 392     {
 393         setOsgVarType(OSGNodeWorldBoxMin);
 394         setDependency(SHDObject         );
 395     }
 396     else if(_sfName.getValue() == "OSGNodeWorldBoxMax")
 397     {
 398         setOsgVarType(OSGNodeWorldBoxMax);
 399         setDependency(SHDObject         );
 400     }
 401     else if(_sfName.getValue() == "OSGNodeWorldBoxCenter")
 402     {
 403         setOsgVarType(OSGNodeWorldBoxCenter);
 404         setDependency(SHDObject            );
 405     }
 406     else if(_sfName.getValue() == "OSGActiveLightsMask")
 407     {
 408         setOsgVarType(OSGActiveLightsMask);
 409         setDependency(SHDObject          );
 410     }
 411     else if(_sfName.getValue() == "OSGLight0Active")
 412     {
 413         setOsgVarType(OSGLight0Active);
 414         setDependency(SHDObject      );
 415     }
 416     else if(_sfName.getValue() == "OSGLight1Active")
 417     {
 418         setOsgVarType(OSGLight1Active);
 419         setDependency(SHDObject      );
 420     }
 421     else if(_sfName.getValue() == "OSGLight2Active")
 422     {
 423         setOsgVarType(OSGLight2Active);
 424         setDependency(SHDObject      );
 425     }
 426     else if(_sfName.getValue() == "OSGLight3Active")
 427     {
 428         setOsgVarType(OSGLight3Active);
 429         setDependency(SHDObject      );
 430     }
 431     else if(_sfName.getValue() == "OSGLight4Active")
 432     {
 433         setOsgVarType(OSGLight4Active);
 434         setDependency(SHDObject      );
 435     }
 436     else if(_sfName.getValue() == "OSGLight5Active")
 437     {
 438         setOsgVarType(OSGLight5Active);
 439         setDependency(SHDObject      );
 440     }
 441     else if(_sfName.getValue() == "OSGLight6Active")
 442     {
 443         setOsgVarType(OSGLight6Active);
 444         setDependency(SHDObject      );
 445     }
 446     else if(_sfName.getValue() == "OSGLight7Active")
 447     {
 448         setOsgVarType(OSGLight7Active);
 449         setDependency(SHDObject      );
 450     }
 451     else
 452     {
 453         setOsgVarType(OSGUnknown);
 454         setDependency(SHDObject );
 455     }
 456 }
 457
 458 void ShaderVariableOSG::evaluate(DrawEnv *pEnv,
 459                                  Int32   &iLocation)
 460 {
 461     Window *pWin = pEnv->getWindow();
 462
 463     osgSinkUnusedWarning(pWin);
 464
 465     switch(_sfOsgVarType.getValue())
 466     {
 467         case OSGWorldMatrix:
 468         {
 469             Matrix m = pEnv->getObjectToWorld();
 470
 471             if(iLocation > -1)
 472             {
 473                 OSGGETGLFUNCBYID_GL3_ES(
 474                     glUniformMatrix4fv,
 475                     osgGlUniformMatrix4fv,
 476                     ShaderProgram::getFuncIdUniformMatrix4fv(),
 477                     pWin);
 478
 479                 osgGlUniformMatrix4fv(iLocation,
 480                                       1,
 481                                       GL_FALSE,
 482                                       m.getValues());
 483             }
 484         }
 485         break;
 486
 487         case OSGInvWorldMatrix:
 488         {
 489             Matrix m = pEnv->getObjectToWorld();
 490
 491             m.invert();
 492
 493             if(iLocation > -1)
 494             {
 495                 OSGGETGLFUNCBYID_GL3_ES(
 496                     glUniformMatrix4fv,
 497                     osgGlUniformMatrix4fv,
 498                     ShaderProgram::getFuncIdUniformMatrix4fv(),
 499                     pWin);
 500
 501                 osgGlUniformMatrix4fv(iLocation, 1, GL_FALSE, m.getValues());
 502             }
 503         }
 504         break;
 505
 506         case OSGTransInvWorldMatrix:
 507         {
 508             Matrix m = pEnv->getObjectToWorld();
 509
 510             m.invert();
 511             m.transpose();
 512
 513
 514             if(iLocation > -1)
 515             {
 516                 OSGGETGLFUNCBYID_GL3_ES(
 517                     glUniformMatrix4fv,
 518                     osgGlUniformMatrix4fv,
 519                     ShaderProgram::getFuncIdUniformMatrix4fv(),
 520                     pWin);
 521
 522                 osgGlUniformMatrix4fv(iLocation, 1, GL_FALSE, m.getValues());
 523             }
 524         }
 525         break;
 526
 527         case OSGCameraOrientation:
 528         {
 529             Matrix m = pEnv->getCameraToWorld();
 530
 531             m[3].setValues(0, 0, 0, 1);
 532
 533             if(iLocation > -1)
 534             {
 535                 OSGGETGLFUNCBYID_GL3_ES(
 536                     glUniformMatrix4fv,
 537                     osgGlUniformMatrix4fv,
 538                     ShaderProgram::getFuncIdUniformMatrix4fv(),
 539                     pWin);
 540
 541                 osgGlUniformMatrix4fv(iLocation, 1, GL_FALSE, m.getValues());
 542             }
 543         }
 544         break;
 545
 546         case OSGCameraPosition:
 547         {
 548             if(iLocation > -1)
 549             {
 550                 Matrix m = pEnv->getCameraToWorld();
 551
 552                 Vec3f cameraPos(m[3][0], m[3][1], m[3][2]);
 553
 554                 OSGGETGLFUNCBYID_GL3_ES(
 555                     glUniform3fv,
 556                     osgGlUniform3fv,
 557                     ShaderProgram::getFuncIdUniform3fv(),
 558                     pWin);
 559
 560                 osgGlUniform3fv(iLocation, 1, cameraPos.getValues());
 561             }
 562         }
 563         break;
 564
 565         case OSGViewMatrix:
 566         {
 567             Matrix m = pEnv->getCameraViewing();
 568
 569             if(iLocation > -1)
 570             {
 571                 OSGGETGLFUNCBYID_GL3_ES(
 572                     glUniformMatrix4fv,
 573                     osgGlUniformMatrix4fv,
 574                     ShaderProgram::getFuncIdUniformMatrix4fv(),
 575                     pWin);
 576
 577                 osgGlUniformMatrix4fv(iLocation, 1, GL_FALSE, m.getValues());
 578             }
 579         }
 580         break;
 581
 582         case OSGInvViewMatrix:
 583         {
 584             Matrix m = pEnv->getCameraToWorld();
 585
 586             if(iLocation > -1)
 587             {
 588                 OSGGETGLFUNCBYID_GL3_ES(
 589                     glUniformMatrix4fv,
 590                     osgGlUniformMatrix4fv,
 591                     ShaderProgram::getFuncIdUniformMatrix4fv(),
 592                     pWin);
 593
 594                 osgGlUniformMatrix4fv(iLocation, 1, GL_FALSE, m.getValues());
 595             }
 596         }
 597         break;
 598
 599         case OSGProjectionMatrix:
 600         {
 601             Matrix m = pEnv->_openGLState.getProjection();
 602
 603             if(iLocation > -1)
 604             {
 605                 OSGGETGLFUNCBYID_GL3_ES(
 606                     glUniformMatrix4fv,
 607                     osgGlUniformMatrix4fv,
 608                     ShaderProgram::getFuncIdUniformMatrix4fv(),
 609                     pWin);
 610
 611                 osgGlUniformMatrix4fv(iLocation, 1, GL_FALSE, m.getValues());
 612             }
 613         }
 614         break;
 615
 616         case OSGModelViewMatrix:
 617         {
 618             Matrix m = pEnv->_openGLState.getModelView();
 619
 620             if(iLocation > -1)
 621             {
 622                 OSGGETGLFUNCBYID_GL3_ES(
 623                     glUniformMatrix4fv,
 624                     osgGlUniformMatrix4fv,
 625                     ShaderProgram::getFuncIdUniformMatrix4fv(),
 626                     pWin);
 627
 628                 osgGlUniformMatrix4fv(iLocation, 1, GL_FALSE, m.getValues());
 629             }
 630         }
 631         break;
 632
 633         case OSGViewportSize:
 634         {
 635             Vec2f viewportSize(pEnv->getPixelWidth (),
 636                                pEnv->getPixelHeight());
 637
 638             OSGGETGLFUNCBYID_GL3_ES(
 639                 glUniform2fv,
 640                 osgGlUniform2fv,
 641                 ShaderProgram::getFuncIdUniform2fv(),
 642                 pWin);
 643
 644             osgGlUniform2fv(iLocation, 1, viewportSize.getValues());
 645         }
 646         break;
 647
 648 #ifdef OSG_OGL_COREONLY
 649         case OSGNormalMatrix:
 650         {
 651             Matrix m = pEnv->_openGLState.getNormalMatrix();
 652
 653             if(iLocation > -1)
 654             {
 655                 OSGGETGLFUNCBYID_GL3_ES(
 656                     glUniformMatrix4fv,
 657                     osgGlUniformMatrix4fv,
 658                     ShaderProgram::getFuncIdUniformMatrix4fv(),
 659                     pWin);
 660
 661                 osgGlUniformMatrix4fv(iLocation, 1, GL_FALSE, m.getValues());
 662             }
 663         }
 664         break;
 665
 666         case OSGModelViewProjectionMatrix:
 667         {
 668             Matrix m = pEnv->_openGLState.getModelViewProjection();
 669
 670             if(iLocation > -1)
 671             {
 672                 OSGGETGLFUNCBYID_GL3_ES(
 673                     glUniformMatrix4fv,
 674                     osgGlUniformMatrix4fv,
 675                     ShaderProgram::getFuncIdUniformMatrix4fv(),
 676                     pWin);
 677
 678                 osgGlUniformMatrix4fv(iLocation, 1, GL_FALSE, m.getValues());
 679             }
 680         }
 681         break;
 682 #endif
 683
 684         case OSGStereoLeftEye:
 685         {
 686         }
 687         break;
 688
 689         case OSGDrawerId:
 690         {
 691             if(iLocation > -1)
 692             {
 693                 OSGGETGLFUNCBYID_GL3_ES(glUniform1i,
 694                                         osgGlUniform1i,
 695                                         ShaderProgram::getFuncIdUniform1i(),
 696                                         pWin);
 697
 698                 osgGlUniform1i(iLocation,
 699                                GLint(pEnv->getDrawerId()));
 700             }
 701         }
 702         break;
 703
 704         case OSGDrawableId:
 705         {
 706             if(iLocation > -1)
 707             {
 708                 OSGGETGLFUNCBYID_GL3_ES(glUniform1i,
 709                                         osgGlUniform1i,
 710                                         ShaderProgram::getFuncIdUniform1i(),
 711                                         pWin);
 712
 713                 osgGlUniform1i(iLocation,
 714                                GLint(pEnv->getDrawableId()));
 715             }
 716        }
 717         break;
 718
 719         case OSGNodeId:
 720         {
 721             if(iLocation > -1)
 722             {
 723                 if(pEnv->getSGNode() != NULL)
 724                 {
 725                     OSGGETGLFUNCBYID_GL3_ES(
 726                         glUniform1i,
 727                         osgGlUniform1i,
 728                         ShaderProgram::getFuncIdUniform1i(),
 729                         pWin);
 730
 731                     osgGlUniform1i(iLocation,
 732                                    GLint(pEnv->getSGNode()->getId()));
 733                 }
 734             }
 735         }
 736         break;
 737
 738         case OSGNodeBoxMin:
 739         {
 740             if(iLocation > -1)
 741             {
 742                 if(pEnv->getSGNode() != NULL)
 743                 {
 744                     OSGGETGLFUNCBYID_GL3_ES(
 745                         glUniform3f,
 746                         osgGlUniform3f,
 747                         ShaderProgram::getFuncIdUniform3f(),
 748                         pWin);
 749
 750                     const BoxVolume &bvBox = pEnv->getSGNode()->getVolume();
 751
 752                     osgGlUniform3f(iLocation,
 753                                    bvBox.getMin()[0],
 754                                    bvBox.getMin()[1],
 755                                    bvBox.getMin()[2]);
 756                 }
 757             }
 758         }
 759         break;
 760
 761         case OSGNodeBoxMax :
 762         {
 763             if(iLocation > -1)
 764             {
 765                 if(pEnv->getSGNode() != NULL)
 766                 {
 767                     OSGGETGLFUNCBYID_GL3_ES(
 768                         glUniform3f,
 769                         osgGlUniform3f,
 770                         ShaderProgram::getFuncIdUniform3f(),
 771                         pWin);
 772
 773                     const BoxVolume &bvBox = pEnv->getSGNode()->getVolume();
 774
 775                     osgGlUniform3f(iLocation,
 776                                    bvBox.getMax()[0],
 777                                    bvBox.getMax()[1],
 778                                    bvBox.getMax()[2]);
 779                 }
 780             }
 781         }
 782         break;
 783
 784         case OSGNodeBoxCenter:
 785         {
 786             if(iLocation > -1)
 787             {
 788                 if(pEnv->getSGNode() != NULL)
 789                 {
 790                     OSGGETGLFUNCBYID_GL3_ES(
 791                         glUniform3f,
 792                         osgGlUniform3f,
 793                         ShaderProgram::getFuncIdUniform3f(),
 794                         pWin);
 795
 796                     Pnt3f vBoxCenter;
 797
 798                     pEnv->getSGNode()->getVolume().getCenter(vBoxCenter);
 799
 800                     osgGlUniform3f(iLocation,
 801                                    vBoxCenter[0],
 802                                    vBoxCenter[1],
 803                                    vBoxCenter[2]);
 804                 }
 805             }
 806         }
 807         break;
 808
 809
 810         case OSGNodeWorldBoxMin:
 811         {
 812             if(iLocation > -1)
 813             {
 814                 if(pEnv->getSGNode() != NULL)
 815                 {
 816                     OSGGETGLFUNCBYID_GL3_ES(
 817                         glUniform3f,
 818                         osgGlUniform3f,
 819                         ShaderProgram::getFuncIdUniform3f(),
 820                         pWin);
 821
 822                     BoxVolume bvWorldBox;
 823
 824                     pEnv->getSGNode()->getWorldVolume(bvWorldBox);
 825
 826                     osgGlUniform3f(iLocation,
 827                                    bvWorldBox.getMin()[0],
 828                                    bvWorldBox.getMin()[1],
 829                                    bvWorldBox.getMin()[2]);
 830                 }
 831             }
 832         }
 833         break;
 834
 835         case OSGNodeWorldBoxMax :
 836         {
 837             if(iLocation > -1)
 838             {
 839                 if(pEnv->getSGNode() != NULL)
 840                 {
 841                     OSGGETGLFUNCBYID_GL3_ES(
 842                         glUniform3f,
 843                         osgGlUniform3f,
 844                         ShaderProgram::getFuncIdUniform3f(),
 845                         pWin);
 846
 847                     BoxVolume bvWorldBox;
 848
 849                     pEnv->getSGNode()->getWorldVolume(bvWorldBox);
 850
 851                     osgGlUniform3f(iLocation,
 852                                    bvWorldBox.getMax()[0],
 853                                    bvWorldBox.getMax()[1],
 854                                    bvWorldBox.getMax()[2]);
 855                 }
 856             }
 857         }
 858         break;
 859
 860         case OSGNodeWorldBoxCenter:
 861         {
 862             if(iLocation > -1)
 863             {
 864                 if(pEnv->getSGNode() != NULL)
 865                 {
 866                     OSGGETGLFUNCBYID_GL3_ES(
 867                         glUniform3f,
 868                         osgGlUniform3f,
 869                         ShaderProgram::getFuncIdUniform3f(),
 870                         pWin);
 871
 872                     BoxVolume bvWorldBox;
 873                     Pnt3f     vWorldBoxCenter;
 874
 875                     pEnv->getSGNode()->getWorldVolume(bvWorldBox);
 876
 877                     bvWorldBox.getCenter(vWorldBoxCenter);
 878
 879                     osgGlUniform3f(iLocation,
 880                                    vWorldBoxCenter[0],
 881                                    vWorldBoxCenter[1],
 882                                    vWorldBoxCenter[2]);
 883                 }
 884             }
 885         }
 886         break;
 887
 888         case OSGActiveLightsMask:
 889         {
 890             if(iLocation > -1)
 891             {
 892                 OSGGETGLFUNCBYID_GL3_ES(
 893                     glUniform1i,
 894                     osgGlUniform1i,
 895                     ShaderProgram::getFuncIdUniform1i(),
 896                     pWin);
 897
 898                 osgGlUniform1i(iLocation,
 899                                GLint(pEnv->getLightState()));
 900             }
 901         }
 902         break;
 903
 904         case OSGLight0Active:
 905         {
 906             if(iLocation > -1)
 907             {
 908                 OSGGETGLFUNCBYID_GL3_ES(glUniform1i,
 909                                         osgGlUniform1i,
 910                                         ShaderProgram::getFuncIdUniform1i(),
 911                                         pWin);
 912
 913                 osgGlUniform1i(iLocation,
 914                                GLint(pEnv->getLightState() & 0x0001));
 915             }
 916         }
 917         break;
 918
 919         case OSGLight1Active:
 920         {
 921             if(iLocation > -1)
 922             {
 923                 OSGGETGLFUNCBYID_GL3_ES(glUniform1i,
 924                                         osgGlUniform1i,
 925                                         ShaderProgram::getFuncIdUniform1i(),
 926                                         pWin);
 927
 928                 osgGlUniform1i(iLocation,
 929                                GLint(pEnv->getLightState() & 0x0002));
 930             }
 931         }
 932         break;
 933
 934         case OSGLight2Active:
 935         {
 936             if(iLocation > -1)
 937             {
 938                 OSGGETGLFUNCBYID_GL3_ES(glUniform1i,
 939                                         osgGlUniform1i,
 940                                         ShaderProgram::getFuncIdUniform1i(),
 941                                         pWin);
 942
 943                 osgGlUniform1i(iLocation,
 944                                GLint(pEnv->getLightState() & 0x0004));
 945             }
 946         }
 947         break;
 948
 949         case OSGLight3Active:
 950         {
 951             if(iLocation > -1)
 952             {
 953                 OSGGETGLFUNCBYID_GL3_ES(glUniform1i,
 954                                         osgGlUniform1i,
 955                                         ShaderProgram::getFuncIdUniform1i(),
 956                                         pWin);
 957
 958                 osgGlUniform1i(iLocation,
 959                                GLint(pEnv->getLightState() & 0x0008));
 960             }
 961         }
 962         break;
 963
 964         case OSGLight4Active:
 965         {
 966             if(iLocation > -1)
 967             {
 968                 OSGGETGLFUNCBYID_GL3_ES(glUniform1i,
 969                                         osgGlUniform1i,
 970                                         ShaderProgram::getFuncIdUniform1i(),
 971                                         pWin);
 972
 973                 osgGlUniform1i(iLocation,
 974                                GLint(pEnv->getLightState() & 0x0010));
 975             }
 976         }
 977         break;
 978
 979         case OSGLight5Active:
 980         {
 981             if(iLocation > -1)
 982             {
 983                 OSGGETGLFUNCBYID_GL3_ES(glUniform1i,
 984                                         osgGlUniform1i,
 985                                         ShaderProgram::getFuncIdUniform1i(),
 986                                         pWin);
 987
 988                 osgGlUniform1i(iLocation,
 989                                GLint(pEnv->getLightState() & 0x0020));
 990             }
 991         }
 992         break;
 993
 994         case OSGLight6Active:
 995         {
 996             if(iLocation > -1)
 997             {
 998                 OSGGETGLFUNCBYID_GL3_ES(glUniform1i,
 999                                         osgGlUniform1i,
1000                                         ShaderProgram::getFuncIdUniform1i(),
1001                                         pWin);
1002
1003                 osgGlUniform1i(iLocation,
1004                                GLint(pEnv->getLightState() & 0x0040));
1005             }
1006         }
1007         break;
1008
1009         case OSGLight7Active:
1010         {
1011             if(iLocation > -1)
1012             {
1013                 OSGGETGLFUNCBYID_GL3_ES(glUniform1i,
1014                                         osgGlUniform1i,
1015                                         ShaderProgram::getFuncIdUniform1i(),
1016                                         pWin);
1017
1018                 osgGlUniform1i(iLocation,
1019                                GLint(pEnv->getLightState() & 0x0080));
1020             }
1021         }
1022         break;
1023
1024         default:
1025         {
1026         }
1027         break;
1028     }
1029 }