Examples/Advanced/DeferredShading/deferredshading.cpp

   1
   2 // Work In Progress
   3 //
   4 // This demonstates the use of the DeferredShadingStage and the
   5 // Shader/TrapezoidalShadowMapEngine with it.
   6 //
   7 // The program must be run from the Examples/Advanced/DeferredShading directory
   8 // so that it can find the files with the GLSL source for the shader programs.
   9 //
  10 // Please take a look at the keyboard glut callback for the interface
  11 //
  12 // Work In Progress
  13
  14 #ifdef OSG_BUILD_ACTIVE
  15
  16 #include <OSGGL.h>
  17 #include <OSGGLUT.h>
  18 #include <OSGGLUTWindow.h>
  19 #include <OSGSceneFileHandler.h>
  20 #include <OSGSimpleGeometry.h>
  21 #include <OSGSimpleSceneManager.h>
  22 #include <OSGSimpleTexturedMaterial.h>
  23
  24 #include <OSGDeferredShadingStage.h>
  25 #include <OSGDirectionalLight.h>
  26 #include <OSGPointLight.h>
  27 #include <OSGSpotLight.h>
  28
  29 #include <OSGShaderShadowMapEngine.h>
  30 #include <OSGTrapezoidalShadowMapEngine.h>
  31
  32 // OpenSG Shaders
  33 #include <OSGShaderProgram.h>
  34 #include <OSGShaderProgramChunk.h>
  35
  36 #else // OSG_BUILD_INTEGRATED
  37
  38 #include <OpenSG/OSGGL.h>
  39 #include <OpenSG/OSGGLUT.h>
  40 #include <OpenSG/OSGGLUTWindow.h>
  41 #include <OpenSG/OSGSceneFileHandler.h>
  42 #include <OpenSG/OSGSimpleGeometry.h>
  43 #include <OpenSG/OSGSimpleSceneManager.h>
  44 #include <OpenSG/OSGSimpleTexturedMaterial.h>
  45
  46 #include <OpenSG/OSGDeferredShadingStage.h>
  47 #include <OpenSG/OSGDirectionalLight.h>
  48 #include <OpenSG/OSGPointLight.h>
  49 #include <OpenSG/OSGSpotLight.h>
  50
  51 #include <OpenSG/OSGShaderShadowMapEngine.h>
  52 #include <OpenSG/OSGTrapezoidalShadowMapEngine.h>
  53
  54 // OpenSG Shaders
  55 #include <OpenSG/OSGShaderProgram.h>
  56 #include <OpenSG/OSGShaderProgramChunk.h>
  57
  58 #endif // OSG_BUILD_INTEGRATED
  59
  60 #include <iostream>
  61
  62 OSG_USING_NAMESPACE
  63
  64 enum ShadowTypeE
  65 {
  66     ST_NONE      = 0,
  67     ST_STANDARD  = 1,
  68     ST_TRAPEZOID = 2
  69 };
  70
  71 struct LightInfo
  72 {
  73     LightEngine::LightTypeE    lightType;
  74     ShadowTypeE                shadowType;
  75     LightUnrecPtr              light;
  76     NodeUnrecPtr               lightN;
  77     NodeUnrecPtr               beaconN;
  78
  79     ShaderProgramUnrecPtr      lightVP;
  80     ShaderProgramUnrecPtr      lightFP;
  81     ShaderProgramChunkUnrecPtr lightSH;
  82
  83     LightInfo(void) :
  84         lightType (LightEngine::Spot),
  85         shadowType(ST_NONE          ),
  86         light     (NULL             ),
  87         lightN    (NULL             ),
  88         beaconN   (NULL             ),
  89
  90         lightVP   (NULL             ),
  91         lightFP   (NULL             ),
  92         lightSH   (NULL             )
  93     {
  94     }
  95
  96 };
  97
  98 std::ostream &operator << (std::ostream &os, const LightInfo &li);
  99
 100 struct GlobalValues
 101 {
 102     SimpleSceneManagerRefPtr       mgr;
 103     GLUTWindowUnrecPtr             glutWin;
 104
 105     NodeUnrecPtr                   rootN;
 106
 107     NodeUnrecPtr                   dsStageN;
 108     DeferredShadingStageUnrecPtr   dsStage;
 109
 110     NodeUnrecPtr                   sceneN;
 111     NodeUnrecPtr                   objN;
 112
 113     std::vector<LightInfo>         lightInfos;
 114
 115     bool                           animateLights;
 116     bool                           colorLights;
 117
 118     LightEngine::LightTypeE        newLightType;
 119     ShadowTypeE                    newShadowType;
 120
 121     Int32                          currentLight;
 122
 123     UInt32                         shadowMapWidth;
 124     UInt32                         shadowMapHeight;
 125
 126     GlobalValues(void) :
 127         mgr            (NULL             ),
 128         glutWin        (NULL             ),
 129
 130         rootN          (NULL             ),
 131
 132         dsStageN       (NULL             ),
 133         dsStage        (NULL             ),
 134
 135         sceneN         (NULL             ),
 136         objN           (NULL             ),
 137
 138         lightInfos     (                 ),
 139
 140         animateLights  (false            ),
 141         colorLights    (false            ),
 142
 143         newLightType   (LightEngine::Spot),
 144         newShadowType  (ST_NONE          ),
 145
 146         currentLight   (0                ),
 147
 148         shadowMapWidth (128              ),
 149         shadowMapHeight(128              )
 150     {
 151     }
 152 };
 153
 154 GlobalValues *gv;
 155
 156 const std::string dsGBufferVPFile         ("DSGBuffer.vp.glsl"         );
 157 const std::string dsGBufferFPFile         ("DSGBuffer.fp.glsl"         );
 158
 159 const std::string dsAmbientVPFile         ("DSAmbient.vp.glsl"         );
 160 const std::string dsAmbientFPFile         ("DSAmbient.fp.glsl"         );
 161
 162 const std::string dsDirLightVPFile        ("DSDirLight.vp.glsl"        );
 163 const std::string dsDirLightFPFile        ("DSDirLight.fp.glsl"        );
 164 const std::string dsDirLightShadowFPFile  ("DSDirLightShadow.fp.glsl"  );
 165
 166 const std::string dsPointLightVPFile      ("DSPointLight.vp.glsl"      );
 167 const std::string dsPointLightFPFile      ("DSPointLight.fp.glsl"      );
 168 const std::string dsPointLightShadowFPFile("DSPointLightShadow.fp.glsl");
 169
 170 const std::string dsSpotLightVPFile       ("DSSpotLight.vp.glsl"       );
 171 const std::string dsSpotLightFPFile       ("DSSpotLight.fp.glsl"       );
 172 const std::string dsSpotLightShadowFPFile ("DSSpotLightShadow.fp.glsl" );
 173
 174 const std::string dsUnknownFile           ("unknownFile");
 175
 176 void initialize(int  argc, char *argv[]);
 177 void cleanup   (void                   );
 178
 179 void           buildDSStage  (void                       );
 180 NodeTransitPtr loadScene     (const std::string &fileName);
 181 NodeTransitPtr buildTestScene(UInt32 nX, UInt32 nZ);
 182
 183 void addLight (LightEngine::LightTypeE lightType, ShadowTypeE shadowType);
 184 void setShadow(UInt32                  lightIdx,  ShadowTypeE shadowType);
 185 void setColorLights(bool colLights);
 186
 187 int  setupGLUT (int *argc, char *argv[]);
 188 void keyboard(unsigned char k, int , int );
 189
 190 int main(int argc, char *argv[])
 191 {
 192     initialize(argc, argv);
 193
 194     keyboard('+', 0, 0);
 195 //    keyboard('+', 0, 0);
 196     keyboard('.', 0, 0);
 197
 198     keyboard('a', 0, 0);
 199
 200     commitChanges();
 201
 202     glutMainLoop();
 203
 204     return 0;
 205 }
 206
 207
 208 void initialize(int argc, char *argv[])
 209 {
 210     osgInit(argc, argv);
 211
 212     gv = new GlobalValues;
 213     gv->animateLights   = false;
 214     gv->colorLights     = false;
 215     gv->newLightType    = LightEngine::Spot;
 216     gv->newShadowType   = ST_NONE;
 217     gv->currentLight    = -1;
 218     gv->shadowMapWidth  = 1024;
 219     gv->shadowMapHeight = 1024;
 220
 221     int glutWinId = setupGLUT(&argc, argv);
 222
 223     gv->glutWin = GLUTWindow::create();
 224     gv->glutWin->setGlutId(glutWinId);
 225     gv->glutWin->init     (         );
 226
 227     gv->mgr = SimpleSceneManager::create();
 228
 229      // tell the manager what to manage
 230     gv->mgr->setWindow(gv->glutWin);
 231
 232     // HACK: force creation of internal SSM objects (vp, cam, bg etc)
 233     gv->mgr->setRoot(NULL);
 234
 235     gv->mgr->getWindow()->getPort(0)->setSize(0.1f, 0.f, 0.8f, 1.f);
 236
 237     // create a "scene" to show
 238     if(argc >= 2)
 239     {
 240         std::string fileName = argv[1];
 241
 242         gv->sceneN = makeCoredNode<Group>();
 243
 244         gv->objN   = loadScene(fileName);
 245         gv->sceneN->addChild(gv->objN);
 246     }
 247
 248     if(gv->sceneN == NULL)
 249     {
 250         gv->sceneN = makeCoredNode<Group>();
 251         gv->objN   = buildTestScene(5, 5);
 252
 253         gv->sceneN->addChild(gv->objN);
 254     }
 255
 256     gv->rootN = makeCoredNode<Group>();
 257
 258     buildDSStage();
 259
 260     gv->dsStageN->addChild(gv->sceneN  );
 261     gv->rootN   ->addChild(gv->dsStageN);
 262
 263     gv->mgr->setRoot(gv->rootN);
 264     gv->mgr->showAll();
 265 }
 266
 267 void cleanup(void)
 268 {
 269     gv->mgr = NULL;
 270
 271     delete gv;
 272     gv = NULL;
 273
 274     osgExit();
 275 }
 276
 277
 278 // creates the deferred shading stage and configures the required buffers.
 279 // this assumes that all materials in the scene are regular enough as to be
 280 // written with a single shader to the buffers (e.g. everything has a single
 281 // diffuse texture).
 282 // alternatively the GBufferProgram can be left empty and all materials in the
 283 // scene are set up to write to the correct buffers.
 284 void buildDSStage(void)
 285 {
 286     ShaderProgramUnrecPtr      vpGBuffer = ShaderProgram::createVertexShader  ();
 287     ShaderProgramUnrecPtr      fpGBuffer = ShaderProgram::createFragmentShader();
 288
 289     ShaderProgramUnrecPtr      vpAmbient = ShaderProgram::createVertexShader  ();
 290     ShaderProgramUnrecPtr      fpAmbient = ShaderProgram::createFragmentShader();
 291
 292     ShaderProgramChunkUnrecPtr shGBuffer = ShaderProgramChunk::create();
 293     ShaderProgramChunkUnrecPtr shAmbient = ShaderProgramChunk::create();
 294
 295     gv->dsStage  = DeferredShadingStage::create();
 296     gv->dsStageN = makeNodeFor(gv->dsStage);
 297
 298     gv->dsStage->setCamera(gv->mgr->getCamera());
 299
 300     // positions (RGB) + ambient (A) term buffer
 301     gv->dsStage->editMFPixelFormats()->push_back(Image::OSG_RGBA_PF          );
 302     gv->dsStage->editMFPixelTypes  ()->push_back(Image::OSG_FLOAT32_IMAGEDATA);
 303
 304     // normals (RGB) buffer
 305     gv->dsStage->editMFPixelFormats()->push_back(Image::OSG_RGB_PF           );
 306     gv->dsStage->editMFPixelTypes  ()->push_back(Image::OSG_FLOAT32_IMAGEDATA);
 307
 308     // diffuse (RGB) buffer
 309     gv->dsStage->editMFPixelFormats()->push_back(Image::OSG_RGB_PF);
 310     gv->dsStage->editMFPixelTypes  ()->push_back(Image::OSG_UINT8_IMAGEDATA);
 311
 312     // G Buffer shader (one for the whole scene)
 313     vpGBuffer->readProgram(dsGBufferVPFile.c_str());
 314     fpGBuffer->readProgram(dsGBufferFPFile.c_str());
 315
 316     fpGBuffer->addUniformVariable<Int32>("tex0", 0);
 317
 318     shGBuffer->addShader(vpGBuffer);
 319     shGBuffer->addShader(fpGBuffer);
 320
 321     gv->dsStage->setGBufferProgram(shGBuffer);
 322
 323     // ambient shader
 324     vpAmbient->readProgram(dsAmbientVPFile.c_str());
 325     fpAmbient->readProgram(dsAmbientFPFile.c_str());
 326
 327     fpAmbient->addUniformVariable<Int32>("texBufNorm", 1);
 328
 329     shAmbient->addShader(vpAmbient);
 330     shAmbient->addShader(fpAmbient);
 331
 332     gv->dsStage->setAmbientProgram(shAmbient);
 333 }
 334
 335 std::string mapShadowType(ShadowTypeE shadowType)
 336 {
 337     std::string shadow = "unknown";
 338
 339     switch(shadowType)
 340     {
 341     case ST_NONE:
 342         shadow = "None";
 343         break;
 344
 345     case ST_STANDARD:
 346         shadow = "Standard";
 347         break;
 348
 349     case ST_TRAPEZOID:
 350         shadow = "Trapezoidal";
 351         break;
 352     };
 353
 354     return shadow;;
 355 }
 356
 357 std::string mapLightType(LightEngine::LightTypeE lightType)
 358 {
 359     std::string light = "unknown";
 360
 361     switch(lightType)
 362     {
 363     case LightEngine::Directional:
 364         light = "Directional";
 365         break;
 366
 367     case LightEngine::Point:
 368         light = "Point";
 369         break;
 370
 371     case LightEngine::Spot:
 372         light = "Spot";
 373         break;
 374     };
 375
 376     return light;
 377 }
 378
 379 // file containing vertex shader code for the light type
 380 const std::string &getLightVPFile(
 381     LightEngine::LightTypeE lightType,
 382     ShadowTypeE             shadowType)
 383 {
 384     switch(lightType)
 385     {
 386     case LightEngine::Directional:
 387         return dsDirLightVPFile;
 388
 389     case LightEngine::Point:
 390         return dsPointLightVPFile;
 391
 392     case LightEngine::Spot:
 393         return dsSpotLightVPFile;
 394     };
 395
 396     return dsUnknownFile;
 397 }
 398
 399 // file containing fragment shader code for the light type
 400 const std::string &getLightFPFile(
 401     LightEngine::LightTypeE lightType,
 402     ShadowTypeE             shadowType)
 403 {
 404     switch(lightType)
 405     {
 406     case LightEngine::Directional:
 407         if(shadowType == ST_NONE)
 408             return dsDirLightFPFile;
 409         else
 410             return dsDirLightShadowFPFile;
 411
 412     case LightEngine::Point:
 413         if(shadowType == ST_NONE)
 414             return dsPointLightFPFile;
 415         else
 416             return dsPointLightShadowFPFile;
 417
 418     case LightEngine::Spot:
 419         if(shadowType == ST_NONE)
 420             return dsSpotLightFPFile;
 421         else
 422             return dsSpotLightShadowFPFile;
 423     };
 424
 425     return dsUnknownFile;
 426 }
 427
 428
 429 // adds a light of given type to the scene and makes it cast shadows
 430 // of the given type.
 431 void addLight(LightEngine::LightTypeE lightType, ShadowTypeE shadowType)
 432 {
 433     LightInfo         li;
 434     TransformUnrecPtr beacon = Transform::create();
 435     li.beaconN = makeNodeFor(beacon);
 436
 437     li.lightVP    = ShaderProgram     ::createVertexShader  ();
 438     li.lightFP    = ShaderProgram     ::createFragmentShader();
 439     li.lightSH    = ShaderProgramChunk::create              ();
 440     li.lightType  = lightType;
 441     li.shadowType = shadowType;
 442
 443     switch(lightType)
 444     {
 445     case LightEngine::Directional:
 446     {
 447         DirectionalLightUnrecPtr dirL = DirectionalLight::create();
 448
 449         li.light = dirL;
 450     }
 451     break;
 452
 453     case LightEngine::Point:
 454     {
 455         PointLightUnrecPtr pointL = PointLight::create();
 456         pointL->setConstantAttenuation(1.0);
 457         //pointL->setLinearAttenuation  (1.e-5);
 458         //pointL->setQuadraticAttenuation(2.e-5);
 459
 460         li.light = pointL;
 461     }
 462     break;
 463
 464     case LightEngine::Spot:
 465     {
 466         SpotLightUnrecPtr spotL = SpotLight::create();
 467         spotL->setPosition (Pnt3f(0.f, 0.f,  0.f));
 468         spotL->setDirection(Vec3f(0.f, 0.f, -1.f));
 469         spotL->setSpotCutOff(Pi/6.f);
 470         spotL->setSpotExponent(3.f);
 471         spotL->setConstantAttenuation(1.0);
 472         //spotL->setLinearAttenuation  (1.e-5);
 473         //spotL->setQuadraticAttenuation(2.e-5);
 474
 475         li.light = spotL;
 476     }
 477     break;
 478     };
 479
 480     li.light->setBeacon(li.beaconN);
 481     li.lightN = makeNodeFor(li.light);
 482
 483     li.lightFP->addUniformVariable<Int32>("texBufPos",  0);
 484     li.lightFP->addUniformVariable<Int32>("texBufNorm", 1);
 485     li.lightFP->addUniformVariable<Int32>("texBufDiff", 2);
 486
 487     li.lightSH->addShader(li.lightVP);
 488     li.lightSH->addShader(li.lightFP);
 489
 490     gv->rootN->addChild(li.beaconN);
 491     //gv->rootN->addChild(li.lightN );
 492
 493     gv->dsStage->editMFLights       ()->push_back(li.light  );
 494     gv->dsStage->editMFLightPrograms()->push_back(li.lightSH);
 495
 496     gv->lightInfos.push_back(li);
 497
 498     setShadow(gv->lightInfos.size() - 1, shadowType);
 499
 500     setColorLights(gv->colorLights);
 501
 502     // add a coordinate system to show light position
 503 //    OSG::NodeUnrecPtr lightAxisN = OSG::makeCoordAxis(2.f);
 504 //    li.beaconN->addChild(lightAxisN);
 505 }
 506
 507 void subLight(UInt32 lightIdx)
 508 {
 509     OSG_ASSERT(lightIdx < gv->lightInfos                    .size());
 510     OSG_ASSERT(lightIdx < gv->dsStage->getMFLights       ()->size());
 511     OSG_ASSERT(lightIdx < gv->dsStage->getMFLightPrograms()->size());
 512
 513     gv->dsStage->editMFLights       ()->erase(lightIdx);
 514 //        gv->dsStage->editMFLights       ()->begin() + lightIdx);
 515     gv->dsStage->editMFLightPrograms()->erase(lightIdx);
 516 //        gv->dsStage->editMFLightPrograms()->begin() + lightIdx);
 517
 518     LightInfo &li = gv->lightInfos[lightIdx];
 519     gv->rootN->subChild(li.beaconN);
 520
 521     //gv->rootN->subChild(li.lightN );
 522
 523     gv->lightInfos.erase(gv->lightInfos.begin() + lightIdx);
 524
 525     setColorLights(gv->colorLights);
 526 }
 527
 528 void setShadow(UInt32 lightIdx, ShadowTypeE shadowType)
 529 {
 530     OSG_ASSERT(lightIdx < gv->lightInfos                    .size());
 531     OSG_ASSERT(lightIdx < gv->dsStage->getMFLights       ()->size());
 532     OSG_ASSERT(lightIdx < gv->dsStage->getMFLightPrograms()->size());
 533
 534     LightInfo &li = gv->lightInfos[lightIdx];
 535
 536 //    li.lightSH->removeObjFromVertexShader  (li.lightVP);
 537 //    li.lightSH->removeObjFromFragmentShader(li.lightFP);
 538
 539     switch(shadowType)
 540     {
 541     case ST_NONE:
 542     {
 543         li.light->setLightEngine(NULL);
 544
 545         gv->dsStage->editMFLights       ();
 546         gv->dsStage->editMFLightPrograms();
 547
 548         li.shadowType = ST_NONE;
 549     }
 550     break;
 551
 552     case ST_STANDARD:
 553     {
 554         ShaderShadowMapEngineUnrecPtr shadowEng =
 555             ShaderShadowMapEngine::create();
 556
 557         shadowEng->setWidth (gv->shadowMapWidth );
 558         shadowEng->setHeight(gv->shadowMapHeight);
 559         shadowEng->setOffsetFactor( 4.5f);
 560         shadowEng->setOffsetBias  (16.f );
 561         shadowEng->setForceTextureUnit(3);
 562
 563         gv->dsStage->editMFLights       ();
 564         gv->dsStage->editMFLightPrograms();
 565
 566         li.light->setLightEngine(shadowEng);
 567         li.shadowType = ST_STANDARD;
 568     }
 569     break;
 570
 571     case ST_TRAPEZOID:
 572     {
 573         if(li.lightType != LightEngine::Directional)
 574         {
 575             TrapezoidalShadowMapEngineUnrecPtr shadowEng =
 576                 TrapezoidalShadowMapEngine::create();
 577
 578             shadowEng->setWidth (gv->shadowMapWidth );
 579             shadowEng->setHeight(gv->shadowMapHeight);
 580             shadowEng->setOffsetFactor( 4.5f);
 581             shadowEng->setOffsetBias  (16.f );
 582             shadowEng->setForceTextureUnit(3);
 583
 584             gv->dsStage->editMFLights       ();
 585             gv->dsStage->editMFLightPrograms();
 586
 587             li.light->setLightEngine(shadowEng);
 588             li.shadowType = ST_TRAPEZOID;
 589         }
 590         else
 591         {
 592             std::cout << "TSM not supported for diretional lights."
 593                       << std::endl;
 594         }
 595     }
 596     break;
 597     };
 598
 599     std::string vpFile = getLightVPFile(li.lightType, li.shadowType);
 600     std::string fpFile = getLightFPFile(li.lightType, li.shadowType);
 601
 602     std::cerr << "vpFile [" << vpFile << "]" <<std::endl;
 603     std::cerr << "fpFile [" << fpFile << "]" <<std::endl;
 604
 605     li.lightVP->readProgram(vpFile.c_str());
 606     li.lightFP->readProgram(fpFile.c_str());
 607
 608     li.lightFP->addUniformVariable<Int32>("texBufPos",  0);
 609     li.lightFP->addUniformVariable<Int32>("texBufNorm", 1);
 610     li.lightFP->addUniformVariable<Int32>("texBufDiff", 2);
 611
 612 //    li.lightSH->addVertexShader  (li.lightVP);
 613 //    li.lightSH->addFragmentShader(li.lightFP);
 614 }
 615
 616 void setColorLights(bool colLights)
 617 {
 618     if(gv->lightInfos.size() > 1)
 619     {
 620         if(colLights == true)
 621         {
 622             // set colorful
 623             for(UInt32 i = 0; i < gv->lightInfos.size(); ++i)
 624             {
 625                 gv->lightInfos[i].light->setDiffuse(
 626                     Color4f(       Real32(i+1) / gv->lightInfos.size(),
 627                             0.f,
 628                             1.f - (Real32(i+1) / gv->lightInfos.size()),
 629                             1.f));
 630             }
 631         }
 632         else
 633         {
 634             // set lights to grey
 635             for(UInt32 i = 0; i < gv->lightInfos.size(); ++i)
 636             {
 637                 gv->lightInfos[i].light->setDiffuse(
 638                     Color4f(1.f / gv->lightInfos.size(),
 639                             1.f / gv->lightInfos.size(),
 640                             1.f / gv->lightInfos.size(),
 641                             1.f                         ));
 642             }
 643         }
 644     }
 645     else if(gv->lightInfos.empty() == false)
 646     {
 647         gv->lightInfos[0].light->setDiffuse(Color4f(1.f, 1.f, 1.f, 1.f));
 648     }
 649
 650     // trigger update
 651     gv->dsStage->editMFLights();
 652
 653     gv->colorLights = colLights;
 654 }
 655
 656 void updateLightBeacon(OSG::UInt32 lightIdx, OSG::Time t)
 657 {
 658     OSG_ASSERT(lightIdx < gv->lightInfos                    .size());
 659     OSG_ASSERT(lightIdx < gv->dsStage->getMFLights       ()->size());
 660     OSG_ASSERT(lightIdx < gv->dsStage->getMFLightPrograms()->size());
 661
 662     Transform *beacon = dynamic_cast<Transform *>(
 663         gv->lightInfos[lightIdx].beaconN->getCore());
 664
 665     if(beacon == NULL)
 666         return;
 667
 668     Pnt3f bbMin;
 669     Pnt3f bbMax;
 670     Pnt3f bbCenter;
 671
 672     gv->objN->updateVolume();
 673     gv->objN->getVolume().getBounds(bbMin, bbMax);
 674     gv->objN->getVolume().getCenter(bbCenter    );
 675
 676     UInt32 numLights  = gv->lightInfos.size();
 677     Real32 lightFract = Real32(lightIdx + 1) / Real32(numLights);
 678
 679     Vec3f  bbDiag    = (bbMax - bbMin);
 680     Real32 bbDiagLen = bbDiag.length();
 681
 682     Real32 angle1     = osgMod(t / 10.0, Real64(2.f * Pi));
 683     Real32 angle2     = (2.f * Pi / numLights);
 684     Real32 shiftVal   = 0.5f * osgSin(4.f * (lightFract * angle2 + angle1)) + 0.25;
 685
 686     // translate to "above" center of the model
 687     Matrix matXform0;
 688     matXform0.setTranslate(bbCenter.subZero() +
 689                            Vec3f(0.f, shiftVal * bbDiag[1] * 1.1, 0.f));
 690
 691     // rotate around y
 692     Matrix matXform1;
 693     Quaternion rot1(Vec3f(0.f, 1.f, 0.f), (lightIdx + 1) * angle2 + angle1);
 694     matXform1.setRotate(rot1);
 695
 696     // translate 0.5 * bb diag along x
 697     Matrix matXform2;
 698     matXform2.setTranslate(Vec3f(0.5f * bbDiagLen, 0.f, 0.f));
 699
 700     matXform0.mult(matXform1);
 701     matXform0.mult(matXform2);
 702
 703     // align to face center
 704     Pnt3f  lightAt(bbCenter - Vec3f(0.f, 0.25 * bbDiag[1], 0.f));
 705     Matrix matXform0Inv;
 706     matXform0Inv.invertFrom(matXform0);
 707     matXform0Inv.mult      (lightAt, lightAt);
 708
 709     Matrix matXform3;
 710     Quaternion rot2(Vec3f(0.f, 0.f, -1.),
 711                     lightAt.subZero()         );
 712     matXform3.setRotate(rot2);
 713
 714     matXform0.mult(matXform3);
 715
 716     // shift towards center
 717     //Matrix matXform4;
 718     //matXform4.setTranslate(Vec3f(0.f, 0.f, shiftVal * bbDiagLen));
 719
 720     //matXform0.mult(matXform4);
 721
 722
 723     beacon->setMatrix(matXform0);
 724 }
 725
 726 NodeTransitPtr loadScene(const std::string &fileName)
 727 {
 728     NodeTransitPtr retVal;
 729     NodeUnrecPtr   fileSceneN = SceneFileHandler::the()->read(fileName.c_str());
 730
 731     if(fileSceneN == NULL)
 732         return retVal;
 733
 734     commitChanges();
 735
 736     fileSceneN->updateVolume();
 737     const BoxVolume &bvol = fileSceneN->getVolume();
 738     Pnt3f            pmin;
 739     Pnt3f            pmax;
 740     bvol.getBounds(pmin, pmax);
 741     Vec3f            vdiag = pmax - pmin;
 742     Real32           diag  = vdiag.length();
 743
 744     TransformUnrecPtr xform  = Transform::create();
 745     NodeUnrecPtr      xformN = makeNodeFor(xform);
 746
 747     Matrix matXForm;
 748     Matrix mat;
 749     matXForm.setRotate(Quaternion(Vec3f(1.f, 0.f, 0.f), -Pi/2));
 750
 751     mat.setTranslate(Vec3f(0.f, 0.f, - 0.4 * diag));
 752
 753     matXForm.mult(mat);
 754
 755     xform->setMatrix(matXForm);
 756
 757     GeometryUnrecPtr plane  = makePlaneGeo(4.f * diag, 4.f * diag, 1, 1);
 758     NodeUnrecPtr     planeN = makeNodeFor(plane);
 759
 760     UInt8 pixelData[] =
 761     {
 762         128, 128, 128, 255, 255, 255,
 763         255, 255, 255, 128, 128, 128
 764     };
 765
 766     ImageUnrecPtr texImg = Image::create();
 767     texImg->set(Image::OSG_RGB_PF, 2, 2, 1, 1, 1, 0.0, pixelData);
 768
 769     SimpleTexturedMaterialUnrecPtr smat = SimpleTexturedMaterial::create();
 770     smat->setImage(texImg);
 771     smat->setMinFilter(GL_NEAREST);
 772     smat->setMagFilter(GL_NEAREST);
 773
 774 //    plane->setMaterial(smat);
 775     plane->setMaterial(getDefaultMaterial());
 776
 777     xformN    ->addChild(planeN);
 778     gv->sceneN->addChild(xformN);
 779
 780     retVal = fileSceneN;
 781
 782     return retVal;
 783 }
 784
 785 NodeTransitPtr buildTestScene(UInt32 nX, UInt32 nZ)
 786 {
 787     Real32 stepX  = 10.f;
 788     Real32 stepZ  = 10.f;
 789
 790     Real32 startX = - stepX * (nX-1) / 2.;
 791     Real32 startZ = - stepZ * (nZ-1) / 2.;
 792
 793     NodeTransitPtr   groupN  = makeCoredNode<Group>();
 794 //    GeometryUnrecPtr objGeo  = makeBoxGeo(1.f, 1.f, 1.f, 1, 1, 1);
 795 //    GeometryUnrecPtr objGeo  = makeLatLongSphereGeo(16, 16, 1.f);
 796     GeometryUnrecPtr objGeo  = makeSphereGeo(2, 1.f);
 797
 798     for(UInt32 iX = 0; iX < nX; ++iX)
 799     {
 800         for(UInt32 iZ = 0; iZ < nZ; ++iZ)
 801         {
 802             NodeUnrecPtr      objGeoN = makeNodeFor(objGeo);
 803             TransformUnrecPtr xform   = Transform::create();
 804             NodeUnrecPtr      xformN  = makeNodeFor(xform);
 805
 806             Matrix matXForm;
 807             Vec3f  vecTrans(startX + iX * stepX,
 808                             4.f * osgCos(Pi/5.f * Real32(iX + iZ)),
 809                             startZ + iZ * stepZ                          );
 810
 811             std::cout << "iX " << iX << " iZ " << iZ << " vecTrans " << vecTrans << std::endl;
 812             matXForm.setTranslate(vecTrans);
 813             xform->setMatrix(matXForm);
 814
 815             xformN->addChild(objGeoN);
 816             groupN->addChild(xformN );
 817
 818             // add a 2nd layer of objects
 819             NodeUnrecPtr      objGeoN2 = makeNodeFor(objGeo);
 820             TransformUnrecPtr xform2   = Transform::create();
 821             NodeUnrecPtr      xformN2  = makeNodeFor(xform2);
 822
 823             Matrix matXForm2;
 824             matXForm2.setTranslate(Vec3f(startX + iX * stepX,
 825                                          15.f,
 826                                          startZ + iZ * stepZ ));
 827             xform2->setMatrix(matXForm2);
 828
 829             xformN2->addChild(objGeoN2);
 830             groupN ->addChild(xformN2 );
 831         }
 832     }
 833
 834     // ground plane
 835     TransformUnrecPtr xform   = Transform::create();
 836     NodeUnrecPtr      xformN  = makeNodeFor(xform);
 837
 838     Matrix matXForm;
 839     matXForm.setTranslate(Vec3f(0.f, -5.f, 0.f));
 840     matXForm.setRotate   (Quaternion(Vec3f(1.f, 0.f, 0.f), -PiHalf));
 841     xform->setMatrix(matXForm);
 842
 843     NodeUnrecPtr planeGeoN = makePlane(nX * stepX, nZ * stepZ, 1, 1);
 844
 845     xformN->addChild(planeGeoN);
 846     groupN->addChild(xformN   );
 847
 848
 849     // back box
 850     xform   = Transform::create();
 851     xformN  = makeNodeFor(xform);
 852
 853     matXForm.setIdentity();
 854     matXForm.setTranslate(Vec3f(0.f, 15.f, -20.f));
 855     xform->setMatrix(matXForm);
 856
 857     NodeUnrecPtr boxGeoN = makeBox(nX * stepX, 35.f, 2.f, 1, 1, 1);
 858
 859     xformN->addChild(boxGeoN);
 860     groupN->addChild(xformN );
 861
 862     return groupN;
 863 }
 864
 865 std::ostream &operator << (std::ostream &os, const LightInfo &li)
 866 {
 867     os <<   "lightType " << mapLightType(li.lightType)
 868        << " " << (li.light->getOn() ? "on" : "off")
 869        << " shadowType " << mapShadowType(li.shadowType);
 870
 871     return os;
 872 }
 873
 874 //
 875 // GLUT callback functions
 876 //
 877
 878 // react to size changes
 879 void reshape(int w, int h)
 880 {
 881     gv->mgr->resize(w, h);
 882     glutPostRedisplay();
 883 }
 884
 885 void display(void)
 886 {
 887 //    static OSG::Time   tStart  = OSG::getSystemTime();
 888     static OSG::Time   tLast   = OSG::getSystemTime();
 889     static OSG::Time   tAnim   = OSG::getSystemTime();
 890     static OSG::Time   tFrames = OSG::getSystemTime();
 891     static OSG::UInt32 frames  = 0;
 892
 893     OSG::Time tNow = OSG::getSystemTime();
 894
 895     if(gv->animateLights == true)
 896     {
 897         tAnim += (tNow - tLast);
 898     }
 899
 900     for(UInt32 i = 0; i < gv->lightInfos.size(); ++i)
 901     {
 902         updateLightBeacon(i, tAnim);
 903     }
 904
 905     ++frames;
 906
 907     if(tNow - tFrames > 1.f)
 908     {
 909         std::cout << "delta t: " << (tNow - tFrames) << " frames: " << frames << std::endl;
 910         tFrames = tNow;
 911         frames  = 0;
 912     }
 913
 914     tLast = tNow;
 915
 916     commitChangesAndClear();
 917
 918     gv->mgr->redraw();
 919 }
 920
 921 // react to mouse button presses
 922 void mouse(int button, int state, int x, int y)
 923 {
 924     if (state)
 925         gv->mgr->mouseButtonRelease(button, x, y);
 926     else
 927         gv->mgr->mouseButtonPress(button, x, y);
 928
 929     glutPostRedisplay();
 930 }
 931
 932 // react to mouse motions with pressed buttons
 933 void motion(int x, int y)
 934 {
 935     gv->mgr->mouseMove(x, y);
 936     glutPostRedisplay();
 937 }
 938
 939 void keyboard(unsigned char k, int , int )
 940 {
 941     switch(k)
 942     {
 943     case 27:
 944     {
 945         // exit
 946         cleanup();
 947         exit(0);
 948     }
 949     break;
 950
 951     case '1':
 952     {
 953         // all lights no shadow
 954         for(UInt32 i = 0; i < gv->lightInfos.size(); ++i)
 955         {
 956             setShadow(i, ST_NONE);
 957             std::cout << "changed shadow type for light "
 958                       << i << " " << gv->lightInfos[i]
 959                       << std::endl;
 960         }
 961     }
 962     break;
 963
 964     case '2':
 965     {
 966         // all lights standard shadows
 967         for(UInt32 i = 0; i < gv->lightInfos.size(); ++i)
 968         {
 969             setShadow(i, ST_STANDARD);
 970             std::cout << "changed shadow type for light "
 971                       << i << " " << gv->lightInfos[i]
 972                       << std::endl;
 973         }
 974     }
 975     break;
 976
 977     case '3':
 978     {
 979         // all lights TSM shadows
 980         for(UInt32 i = 0; i < gv->lightInfos.size(); ++i)
 981         {
 982             setShadow(i, ST_TRAPEZOID);
 983             std::cout << "changed shadow type for light "
 984                       << i << " " << gv->lightInfos[i]
 985                       << std::endl;
 986         }
 987     }
 988     break;
 989
 990     case 'a':
 991     {
 992         // toggle lights moving
 993         gv->animateLights = !gv->animateLights;
 994
 995         std::cout << "animating lights: " << gv->animateLights << std::endl;
 996     }
 997     break;
 998
 999     case 'c':
1000     {
1001         // toggle all lights white/colorful
1002         gv->colorLights = !gv->colorLights;
1003
1004         std::cout << "color lights: " << gv->colorLights << std::endl;
1005
1006         setColorLights(gv->colorLights);
1007     }
1008     break;
1009
1010     case 'o':
1011     {
1012         // toggle current light on/off
1013         if(gv->currentLight <  Int32(gv->lightInfos.size()) &&
1014            gv->currentLight >= 0                              )
1015         {
1016             Light *light = gv->lightInfos[gv->currentLight].light;
1017
1018             light->setOn(!light->getOn());
1019
1020             std::cout << gv->lightInfos[gv->currentLight] << std::endl;
1021         }
1022     }
1023     break;
1024
1025     case '+':
1026     {
1027         // add new light
1028         addLight (gv->newLightType, gv->newShadowType);
1029
1030         std::cout << "added light " << (gv->lightInfos.size() - 1) << " "
1031                   << gv->lightInfos.back()
1032                   << std::endl;
1033     }
1034     break;
1035
1036     case '-':
1037     {
1038         // remove current light
1039         if(gv->currentLight <  Int32(gv->lightInfos.size()) &&
1040            gv->currentLight >= 0                              )
1041         {
1042             std::cout << "removing light " << gv->currentLight << " "
1043                       << gv->lightInfos[gv->currentLight]
1044                       << std::endl;
1045
1046             subLight(gv->currentLight);
1047         }
1048     }
1049     break;
1050
1051     case 's':
1052     {
1053         // cycle through shadow types for current light
1054         if(gv->currentLight <  Int32(gv->lightInfos.size()) &&
1055            gv->currentLight >= 0                              )
1056         {
1057             if(gv->lightInfos[gv->currentLight].shadowType == ST_NONE)
1058             {
1059                 setShadow(gv->currentLight, ST_STANDARD);
1060             }
1061             else if(gv->lightInfos[gv->currentLight].shadowType == ST_STANDARD)
1062             {
1063                 setShadow(gv->currentLight, ST_TRAPEZOID);
1064             }
1065             else
1066             {
1067                 setShadow(gv->currentLight, ST_NONE);
1068             }
1069
1070             std::cout << "changed shadow type for light "
1071                       << gv->currentLight << " "
1072                       << gv->lightInfos[gv->currentLight]
1073                       << std::endl;
1074         }
1075     }
1076     break;
1077
1078     case '.':
1079     {
1080         // select previous light
1081         gv->currentLight += 1;
1082         if(gv->currentLight >= Int32(gv->lightInfos.size()))
1083             gv->currentLight = 0;
1084
1085         if(gv->currentLight <  Int32(gv->lightInfos.size()) &&
1086            gv->currentLight >= 0                              )
1087         {
1088             std::cout << "currentLight " << gv->currentLight
1089                       << " (total: " << gv->lightInfos.size() << ") "
1090                       << gv->lightInfos[gv->currentLight]
1091                       << std::endl;
1092         }
1093     }
1094     break;
1095
1096     case ',':
1097     {
1098         // select next light
1099         gv->currentLight -= 1;
1100
1101         if(gv->currentLight < 0)
1102             gv->currentLight = gv->lightInfos.size() - 1;
1103
1104         if(gv->currentLight <  Int32(gv->lightInfos.size()) &&
1105            gv->currentLight >= 0                              )
1106         {
1107             std::cout << "currentLight " << gv->currentLight
1108                       << " (total: " << gv->lightInfos.size() << ") "
1109                       << gv->lightInfos[gv->currentLight]
1110                       << std::endl;
1111         }
1112     }
1113     break;
1114
1115     }
1116
1117     glutPostRedisplay();
1118 }
1119
1120 // just request a redraw
1121 void idle(void)
1122 {
1123     glutPostRedisplay();
1124 }
1125
1126 // setup the GLUT library which handles the windows for us
1127 int setupGLUT(int *argc, char *argv[])
1128 {
1129     glutInit(argc, argv);
1130     glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
1131
1132     int winid = glutCreateWindow("OpenSG");
1133
1134     glutReshapeFunc(reshape);
1135     glutDisplayFunc(display);
1136     glutMouseFunc(mouse);
1137     glutMotionFunc(motion);
1138     glutKeyboardFunc(keyboard);
1139     glutIdleFunc(idle);
1140
1141     glutReshapeWindow(1400, 1050);
1142
1143     return winid;
1144 }