Show
Ignore:
Timestamp:
02/09/07 22:31:29 (7 years ago)
Author:
robert
Message:

Cleaned up osgshadow example so that it now relies upon osgShadow for its
shadow implementation

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/examples/osgshadow/osgshadow.cpp

    r6138 r6141  
    11#include <osg/ArgumentParser> 
    2  
    3 #include <osg/LightModel> 
    4 #include <osg/Depth> 
    5 #include <osg/BlendFunc> 
    6 #include <osg/Camera> 
    7 #include <osg/Stencil> 
    8 #include <osg/StencilTwoSided> 
    9 #include <osg/CullFace> 
    10 #include <osg/Geometry> 
    11 #include <osg/Switch> 
    122 
    133#include <osgGA/TrackballManipulator> 
     
    2313#include <osgViewer/StatsHandler> 
    2414 
    25 #include <osgShadow/OccluderGeometry> 
    2615#include <osgShadow/ShadowedScene> 
    2716#include <osgShadow/ShadowVolume> 
     
    314303} 
    315304 
    316  
    317  
    318 class ShadowCallback : public osg::NodeCallback 
    319 { 
    320 public: 
    321  
    322     osg::ref_ptr<osg::Light>    _ambientLight; 
    323     osg::ref_ptr<osg::Light>    _diffuseLight; 
    324      
    325     osg::ref_ptr<osg::StateSet> _ss1; 
    326     osg::ref_ptr<osg::StateSet> _mainShadowStateSet; 
    327     osg::ref_ptr<osg::StateSet> _shadowVolumeStateSet; 
    328     osg::ref_ptr<osg::StateSet> _shadowedSceneStateSet; 
    329  
    330     ShadowCallback(osgShadow::ShadowVolumeGeometry::DrawMode drawMode) 
    331     { 
    332         // first group, render the depth buffer + ambient light contribution 
    333         { 
    334             _ss1 = new osg::StateSet; 
    335  
    336 #if 0 
    337             osg::LightModel* lm1 = new osg::LightModel; 
    338             lm1->setAmbientIntensity(ambient); 
    339             _ss1->setAttribute(lm1); 
    340  
    341             osg::Light* light1 = new osg::Light; 
    342             light1->setAmbient(ambient); 
    343             light1->setDiffuse(zero_colour); 
    344             light1->setPosition(_lightpos); 
    345             _ss1->setAttributeAndModes(light1, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); 
    346 #endif             
    347              
    348             _ss1->setMode(GL_LIGHTING, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); 
    349         } 
    350  
    351         { 
    352             _mainShadowStateSet = new osg::StateSet; 
    353  
    354             osg::Depth* depth = new osg::Depth; 
    355             depth->setWriteMask(false); 
    356             depth->setFunction(osg::Depth::LEQUAL); 
    357             _mainShadowStateSet->setAttribute(depth); 
    358             _mainShadowStateSet->setMode(GL_LIGHTING, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); 
    359         } 
    360  
    361         { 
    362             _shadowVolumeStateSet = new osg::StateSet; 
    363              
    364             osg::Depth* depth = new osg::Depth; 
    365             depth->setWriteMask(false); 
    366             depth->setFunction(osg::Depth::LEQUAL); 
    367             _shadowVolumeStateSet->setAttribute(depth); 
    368             _shadowVolumeStateSet->setMode(GL_LIGHTING, osg::StateAttribute::OFF | osg::StateAttribute::OVERRIDE); 
    369             _shadowVolumeStateSet->setMode(GL_DEPTH_TEST, osg::StateAttribute::ON); 
    370  
    371  
    372             if (drawMode == osgShadow::ShadowVolumeGeometry::STENCIL_TWO_SIDED) 
    373             { 
    374                 osg::StencilTwoSided* stencil = new osg::StencilTwoSided; 
    375                 stencil->setFunction(osg::StencilTwoSided::BACK, osg::StencilTwoSided::ALWAYS,0,~0u); 
    376                 stencil->setOperation(osg::StencilTwoSided::BACK, osg::StencilTwoSided::KEEP, osg::StencilTwoSided::KEEP, osg::StencilTwoSided::DECR_WRAP); 
    377                 stencil->setFunction(osg::StencilTwoSided::FRONT, osg::StencilTwoSided::ALWAYS,0,~0u); 
    378                 stencil->setOperation(osg::StencilTwoSided::FRONT, osg::StencilTwoSided::KEEP, osg::StencilTwoSided::KEEP, osg::StencilTwoSided::INCR_WRAP); 
    379  
    380                 osg::ColorMask* colourMask = new osg::ColorMask(false, false, false, false); 
    381  
    382                 _shadowVolumeStateSet->setAttributeAndModes(stencil,osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); 
    383                 _shadowVolumeStateSet->setAttribute(colourMask, osg::StateAttribute::OVERRIDE); 
    384                 _shadowVolumeStateSet->setMode(GL_CULL_FACE,osg::StateAttribute::OFF); 
    385  
    386  
    387             } 
    388             else 
    389             { 
    390                 osg::Stencil* stencil = new osg::Stencil; 
    391                 stencil->setFunction(osg::Stencil::ALWAYS,0,~0u); 
    392                 stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP, osg::Stencil::KEEP); 
    393  
    394                 osg::ColorMask* colourMask = new osg::ColorMask(false, false, false, false); 
    395  
    396                 _shadowVolumeStateSet->setAttributeAndModes(stencil,osg::StateAttribute::ON); 
    397                 _shadowVolumeStateSet->setAttribute(colourMask); 
    398                 _shadowVolumeStateSet->setMode(GL_CULL_FACE,osg::StateAttribute::ON); 
    399             } 
    400         } 
    401  
    402  
    403         { 
    404             _shadowedSceneStateSet = new osg::StateSet; 
    405  
    406             osg::Depth* depth = new osg::Depth; 
    407             depth->setWriteMask(false); 
    408             depth->setFunction(osg::Depth::LEQUAL); 
    409             _shadowedSceneStateSet->setAttribute(depth); 
    410             _shadowedSceneStateSet->setMode(GL_DEPTH_TEST, osg::StateAttribute::ON); 
    411             // _shadowedSceneStateSet->setMode(GL_LIGHTING, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); 
    412  
    413 #if 0 
    414             osg::LightModel* lm1 = new osg::LightModel; 
    415             lm1->setAmbientIntensity(zero_colour); 
    416             _shadowedSceneStateSet->setAttribute(lm1); 
    417  
    418             osg::Light* light = new osg::Light; 
    419             light->setAmbient(zero_colour); 
    420             light->setDiffuse(diffuse); 
    421             light->setPosition(_lightpos); 
    422  
    423             _shadowedSceneStateSet->setMode(GL_LIGHT0, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); 
    424             _shadowedSceneStateSet->setAttribute(light); 
    425 #endif 
    426  
    427             // set up the stencil ops so that only operator on this mirrors stencil value. 
    428             osg::Stencil* stencil = new osg::Stencil; 
    429             stencil->setFunction(osg::Stencil::EQUAL,0,~0u); 
    430             stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP, osg::Stencil::KEEP); 
    431             _shadowedSceneStateSet->setAttributeAndModes(stencil,osg::StateAttribute::ON); 
    432  
    433             osg::BlendFunc* blend = new osg::BlendFunc; 
    434             blend->setFunction(osg::BlendFunc::ONE, osg::BlendFunc::ONE); 
    435             _shadowedSceneStateSet->setAttributeAndModes(blend, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); 
    436             // _shadowedSceneStateSet->setMode(GL_LIGHTING, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); 
    437         } 
    438  
    439         _ss1->setThreadSafeRefUnref(true); 
    440         _mainShadowStateSet->setThreadSafeRefUnref(true); 
    441         _shadowVolumeStateSet->setThreadSafeRefUnref(true); 
    442         _shadowedSceneStateSet->setThreadSafeRefUnref(true); 
    443  
    444     } 
    445      
    446     virtual void operator()(osg::Node* node, osg::NodeVisitor* nv) 
    447     {  
    448         osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(nv); 
    449         if (!cv)  
    450         { 
    451             traverse(node,nv); 
    452             return; 
    453         } 
    454  
    455         // osg::notify(osg::NOTICE)<<std::endl<<std::endl<<"Cull callback"<<std::endl; 
    456  
    457          
    458         osg::ref_ptr<osgUtil::RenderBin> original_bin = cv->getCurrentRenderBin(); 
    459          
    460         osg::ref_ptr<osgUtil::RenderBin> new_bin = original_bin->find_or_insert(0,"RenderBin"); 
    461  
    462         cv->setCurrentRenderBin(new_bin.get()); 
    463  
    464         traverse(node,nv); 
    465          
    466         cv->setCurrentRenderBin(original_bin.get()); 
    467  
    468         osgUtil::RenderBin::RenderBinList::iterator itr =  new_bin->getRenderBinList().find(1000); 
    469         osg::ref_ptr<osgUtil::RenderBin> shadowVolumeBin; 
    470         if (itr != new_bin->getRenderBinList().end()) 
    471         { 
    472             shadowVolumeBin = itr->second; 
    473              
    474             if (shadowVolumeBin.valid()) 
    475             { 
    476                 // osg::notify(osg::NOTICE)<<"Found shadow volume bin, now removing it"<<std::endl; 
    477                 new_bin->getRenderBinList().erase(itr); 
    478             } 
    479         } 
    480          
    481         if (shadowVolumeBin.valid()) 
    482         {         
    483             original_bin->setStateSet(_ss1.get()); 
    484  
    485             osgUtil::RenderStage* orig_rs = cv->getRenderStage(); 
    486             osgUtil::RenderStage* new_rs = new osgUtil::RenderStage; 
    487             orig_rs->addPostRenderStage(new_rs); 
    488  
    489             new_rs->setViewport(orig_rs->getViewport()); 
    490             new_rs->setClearColor(orig_rs->getClearColor()); 
    491             new_rs->setClearMask(GL_STENCIL_BUFFER_BIT); 
    492             new_rs->setDrawBuffer(orig_rs->getDrawBuffer()); 
    493             new_rs->setReadBuffer(orig_rs->getReadBuffer()); 
    494             new_rs->setColorMask(orig_rs->getColorMask()); 
    495              
    496             new_rs->setPositionalStateContainer(orig_rs->getPositionalStateContainer()); 
    497  
    498             if (shadowVolumeBin.valid()) 
    499             { 
    500                 // new_rs->setStateSet(_mainShadowStateSet.get()); 
    501                 new_rs->getRenderBinList()[0] = shadowVolumeBin; 
    502                 shadowVolumeBin->setStateSet(_shadowVolumeStateSet.get()); 
    503  
    504                 osg::ref_ptr<osgUtil::RenderBin> nested_bin = new_rs->find_or_insert(1,"RenderBin"); 
    505                 nested_bin->getRenderBinList()[0] = new_bin;             
    506                 nested_bin->setStateSet(_shadowedSceneStateSet.get()); 
    507             } 
    508         } 
    509     } 
    510 }; 
    511  
    512  
    513  
    514305int main(int argc, char** argv) 
    515306{ 
     
    543334    } 
    544335 
     336    // default to single threaded during dev work. 
     337    viewer.setThreadingModel(osgViewer::Viewer::SingleThreaded); 
     338     
     339    while (arguments.read("--SingleThreaded")) viewer.setThreadingModel(osgViewer::Viewer::SingleThreaded); 
     340    while (arguments.read("--CullDrawThreadPerContext")) viewer.setThreadingModel(osgViewer::Viewer::CullDrawThreadPerContext); 
     341    while (arguments.read("--DrawThreadPerContext")) viewer.setThreadingModel(osgViewer::Viewer::DrawThreadPerContext); 
     342    while (arguments.read("--CullThreadPerCameraDrawThreadPerContext")) viewer.setThreadingModel(osgViewer::Viewer::CullThreadPerCameraDrawThreadPerContext); 
     343 
     344 
    545345    bool postionalLight = false; 
    546346    while (arguments.read("--positionalLight")) postionalLight = true; 
    547347    while (arguments.read("--directionalLight")) postionalLight = false; 
    548348 
    549     bool addOccluderToScene = false; 
    550     while (arguments.read("--addOccluderToScene")) addOccluderToScene = true; 
    551  
    552349    bool updateLightPosition = true; 
    553350    while (arguments.read("--noUpdate")) updateLightPosition = false; 
     
    556353    while (arguments.read("--base")) createBase = true; 
    557354 
    558     bool doShadow = true; 
    559     while (arguments.read("--noShadow")) doShadow = false; 
    560      
    561     bool cullCallback = false; 
    562     while (arguments.read("-c")) cullCallback = true; 
    563355 
    564356    int screenNum = -1; 
     
    568360    while (arguments.read("--two-sided")) drawMode = osgShadow::ShadowVolumeGeometry::STENCIL_TWO_SIDED; 
    569361    while (arguments.read("--two-pass")) drawMode = osgShadow::ShadowVolumeGeometry::STENCIL_TWO_PASS; 
    570      
    571     bool ShadowVolume = false; 
    572     while (arguments.read("--ShadowVolume")) ShadowVolume = true; 
    573362 
    574363 
     
    599388    } 
    600389 
    601  
    602390    // add the state manipulator 
    603391    viewer.addEventHandler( new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()) ); 
     
    646434    } 
    647435 
    648     // get the bounds of the model. 
    649     cbbv.reset(); 
    650     model->accept(cbbv); 
    651     bb = cbbv.getBoundingBox(); 
    652      
    653     osg::ref_ptr<osg::Group> group = new osg::Group; 
    654  
    655     // set up the occluder 
    656     osg::ref_ptr<osgShadow::OccluderGeometry> occluder = new osgShadow::OccluderGeometry; 
    657     occluder->computeOccluderGeometry(model.get()); 
    658 //    cbbv.getPolytope(occluder->getBoundingPolytope(),0.001); 
    659     cbbv.getBase(occluder->getBoundingPolytope(),0.001); 
    660  
    661     if (addOccluderToScene) 
    662     { 
    663         osg::ref_ptr<osg::Geode> geode = new osg::Geode; 
    664         geode->addDrawable(occluder.get()); 
    665         group->addChild(geode.get()); 
    666     } 
    667      
    668     osg::ref_ptr<osgShadow::ShadowVolumeGeometry> shadowVolume = new osgShadow::ShadowVolumeGeometry; 
    669  
    670     shadowVolume->setUseDisplayList(!updateLightPosition); 
    671  
    672436    osg::Vec4 lightpos; 
    673437     
     
    682446 
    683447 
    684     osg::ref_ptr<osg::Light> light = new osg::Light; 
    685     light->setPosition(lightpos); 
    686  
    687     if (ShadowVolume) 
    688     { 
    689         osg::ref_ptr<osgShadow::ShadowedScene> shadowedScene = new osgShadow::ShadowedScene; 
    690          
    691         shadowedScene->setShadowTechnique(new osgShadow::ShadowVolume); 
    692  
    693         shadowedScene->addChild(model.get()); 
    694          
    695         group->addChild(shadowedScene.get()); 
    696     } 
    697     else if (!doShadow) 
    698     { 
    699         group->addChild(model.get()); 
    700  
    701         osg::ref_ptr<osg::Geode> geode = new osg::Geode; 
    702         occluder->computeShadowVolumeGeometry(lightpos, *shadowVolume); 
    703         geode->addDrawable(shadowVolume.get()); 
    704         group->addChild(geode.get()); 
    705  
    706         osg::StateSet* ss = geode->getOrCreateStateSet(); 
    707         ss->setAttributeAndModes(new osg::CullFace(osg::CullFace::BACK), osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); 
    708  
    709     } 
    710     else if (cullCallback) 
    711     { 
    712      
    713         int shadowVolumeBin = 1000; 
    714      
    715         group->setCullCallback(new ShadowCallback(drawMode)); 
    716  
    717         group->addChild(model.get()); 
    718  
    719         osg::ref_ptr<osg::LightSource> ls = new osg::LightSource; 
    720         ls->setLight(light.get()); 
    721         group->addChild(ls.get()); 
    722  
    723         { 
    724             osg::ref_ptr<osg::Geode> geode = new osg::Geode; 
    725             group->addChild(geode.get()); 
    726  
    727             occluder->computeShadowVolumeGeometry(lightpos, *shadowVolume); 
    728             shadowVolume->setDrawMode(drawMode); 
    729  
    730             if (drawMode == osgShadow::ShadowVolumeGeometry::STENCIL_TWO_SIDED) 
    731             { 
    732                 osg::notify(osg::NOTICE)<<"STENCIL_TWO_SIDED seleteced"<<std::endl; 
    733  
    734                 osg::StateSet* ss_sv1 = geode->getOrCreateStateSet(); 
    735                 ss_sv1->setRenderBinDetails(shadowVolumeBin, "RenderBin"); 
    736                 geode->addDrawable(shadowVolume.get()); 
    737             } 
    738             else 
    739             { 
    740                 osg::notify(osg::NOTICE)<<"STENCIL_TWO_PASSES seleteced"<<std::endl; 
    741  
    742                 osg::StateSet* ss_sv1 = geode->getOrCreateStateSet(); 
    743                 ss_sv1->setRenderBinDetails(shadowVolumeBin, "RenderBin"); 
    744                 geode->addDrawable(shadowVolume.get()); 
    745             } 
    746  
    747         } 
    748  
    749     }     
    750     else 
    751     { 
    752         osg::Vec4 ambient(0.2,0.2,0.2,1.0); 
    753         osg::Vec4 diffuse(0.8,0.8,0.8,1.0); 
    754         osg::Vec4 zero_colour(0.0,0.0,0.0,1.0); 
    755      
    756         // first group, render the depth buffer + ambient light contribution 
    757         { 
    758  
    759             osg::Group* first_model_group = new osg::Group; 
    760             first_model_group->addChild(model.get()); 
    761             group->addChild(first_model_group); 
    762  
    763             osg::StateSet* ss1 = first_model_group->getOrCreateStateSet(); 
    764  
    765             osg::LightModel* lm1 = new osg::LightModel; 
    766             lm1->setAmbientIntensity(ambient); 
    767             ss1->setAttribute(lm1); 
    768  
    769             osg::Light* light1 = new osg::Light; 
    770             light1->setAmbient(ambient); 
    771             light1->setDiffuse(zero_colour); 
    772             light1->setPosition(lightpos); 
    773             ss1->setAttributeAndModes(light1, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); 
    774             ss1->setMode(GL_LIGHTING, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); 
    775          
    776         }     
    777      
    778         // second group 
    779         { 
    780             // use a camera here just to implement a seperate post rendering stage. 
    781             osg::Camera* camera = new osg::Camera; 
    782             camera->setRenderOrder(osg::Camera::POST_RENDER); 
    783             camera->setClearMask(GL_STENCIL_BUFFER_BIT); 
    784             group->addChild(camera); 
    785  
    786             osg::StateSet* ss_camera = camera->getOrCreateStateSet(); 
    787  
    788             osg::Depth* depth = new osg::Depth; 
    789             depth->setWriteMask(false); 
    790             depth->setFunction(osg::Depth::LEQUAL); 
    791             ss_camera->setAttribute(depth); 
    792  
    793             { 
    794                 osg::ref_ptr<osg::Geode> geode = new osg::Geode; 
    795                 occluder->computeShadowVolumeGeometry(lightpos, *shadowVolume); 
    796                 shadowVolume->setDrawMode(drawMode); 
    797                  
    798  
    799                 if (drawMode == osgShadow::ShadowVolumeGeometry::STENCIL_TWO_SIDED) 
    800                 { 
    801                     osg::notify(osg::NOTICE)<<"STENCIL_TWO_SIDED seleteced"<<std::endl; 
    802  
    803                     osg::StencilTwoSided* stencil = new osg::StencilTwoSided; 
    804                     stencil->setFunction(osg::StencilTwoSided::BACK, osg::StencilTwoSided::ALWAYS,0,~0u); 
    805                     stencil->setOperation(osg::StencilTwoSided::BACK, osg::StencilTwoSided::KEEP, osg::StencilTwoSided::KEEP, osg::StencilTwoSided::DECR_WRAP); 
    806                     stencil->setFunction(osg::StencilTwoSided::FRONT, osg::StencilTwoSided::ALWAYS,0,~0u); 
    807                     stencil->setOperation(osg::StencilTwoSided::FRONT, osg::StencilTwoSided::KEEP, osg::StencilTwoSided::KEEP, osg::StencilTwoSided::INCR_WRAP); 
    808  
    809  
    810                     osg::ColorMask* colourMask = new osg::ColorMask(false, false, false, false); 
    811  
    812                     osg::StateSet* ss_sv1 = geode->getOrCreateStateSet(); 
    813                     ss_sv1->setRenderBinDetails(0, "RenderBin"); 
    814                     ss_sv1->setAttributeAndModes(stencil,osg::StateAttribute::ON); 
    815                     ss_sv1->setAttribute(colourMask); 
    816                     ss_sv1->setMode(GL_CULL_FACE,osg::StateAttribute::OFF); 
    817                      
    818                     geode->addDrawable(shadowVolume.get()); 
    819                      
    820                     camera->addChild(geode.get()); 
    821  
    822                 } 
    823                 else 
    824                 { 
    825                     osg::notify(osg::NOTICE)<<"STENCIL_TWO_PASSES seleteced"<<std::endl; 
    826  
    827                     osg::Stencil* stencil = new osg::Stencil; 
    828                     stencil->setFunction(osg::Stencil::ALWAYS,0,~0u); 
    829                     stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP, osg::Stencil::KEEP); 
    830  
    831                     osg::ColorMask* colourMask = new osg::ColorMask(false, false, false, false); 
    832  
    833                     osg::StateSet* ss_sv1 = geode->getOrCreateStateSet(); 
    834                     ss_sv1->setRenderBinDetails(0, "RenderBin"); 
    835                     ss_sv1->setAttributeAndModes(stencil,osg::StateAttribute::ON); 
    836                     ss_sv1->setAttribute(colourMask); 
    837                     ss_sv1->setMode(GL_CULL_FACE,osg::StateAttribute::ON); 
    838                      
    839                     geode->addDrawable(shadowVolume.get()); 
    840                      
    841                     camera->addChild(geode.get()); 
    842                 } 
    843  
    844             } 
    845  
    846  
    847             // render scene graph adding contribution of light 
    848             { 
    849                 osg::Group* second_model_group = new osg::Group; 
    850                 second_model_group->addChild(model.get()); 
    851  
    852  
    853                 osg::StateSet* ss1 = second_model_group->getOrCreateStateSet(); 
    854                 ss1->setRenderBinDetails(5, "RenderBin"); 
    855  
    856                 osg::LightModel* lm1 = new osg::LightModel; 
    857                 lm1->setAmbientIntensity(zero_colour); 
    858                 ss1->setAttribute(lm1); 
    859  
    860  
    861                 osg::LightSource* lightsource = new osg::LightSource; 
    862                 lightsource->setLight(light.get()); 
    863                 light->setAmbient(zero_colour); 
    864                 light->setDiffuse(diffuse); 
    865                 light->setPosition(lightpos); 
    866                 second_model_group->addChild(lightsource); 
    867  
    868                 ss1->setMode(GL_LIGHT0, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); 
    869  
    870                 // set up the stencil ops so that only operator on this mirrors stencil value. 
    871                 osg::Stencil* stencil = new osg::Stencil; 
    872                 stencil->setFunction(osg::Stencil::EQUAL,0,~0u); 
    873                 stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP, osg::Stencil::KEEP); 
    874                 ss1->setAttributeAndModes(stencil,osg::StateAttribute::ON); 
    875  
    876                 osg::BlendFunc* blend = new osg::BlendFunc; 
    877                 blend->setFunction(osg::BlendFunc::ONE, osg::BlendFunc::ONE); 
    878                 ss1->setAttributeAndModes(blend, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); 
    879                 ss1->setMode(GL_LIGHTING, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); 
    880  
    881                 camera->addChild(second_model_group); 
    882             } 
    883                      
    884         } 
    885  
    886     } 
    887  
    888  
    889     viewer.setSceneData(group.get()); 
     448    osg::ref_ptr<osgShadow::ShadowedScene> shadowedScene = new osgShadow::ShadowedScene; 
     449     
     450    osg::ref_ptr<osgShadow::ShadowVolume> shadowVolume = new osgShadow::ShadowVolume; 
     451    shadowedScene->setShadowTechnique(shadowVolume.get()); 
     452    shadowVolume->setDynamicShadowVolumes(updateLightPosition); 
     453 
     454    osg::ref_ptr<osg::LightSource> ls = new osg::LightSource; 
     455    ls->getLight()->setPosition(lightpos); 
     456 
     457    shadowedScene->addChild(model.get()); 
     458    shadowedScene->addChild(ls.get()); 
     459 
     460    viewer.setSceneData(shadowedScene.get()); 
    890461     
    891462    // create the windows and run the threads. 
     
    905476            else 
    906477            { 
    907                 lightpos.set(sinf(t),cosf(t),0.8f,0.0f); 
     478                lightpos.set(sinf(t),cosf(t),1.0f,0.0f); 
    908479            } 
    909             light->setPosition(lightpos); 
    910             occluder->computeShadowVolumeGeometry(lightpos, *shadowVolume); 
     480            ls->getLight()->setPosition(lightpos); 
    911481        } 
    912482