src/waterdyn3d.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by                                                 *
 *         Pierre-yves JEZEQUEL, Julien MICHOT, Loic MOISAN,               *
 *         Julien PAPILLON, Sebastien PINEAUD, Barthelemy SERRES           *
 *                                                                         *
 *   https://sourceforge.net/projects/anidam                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "waterdyn3d.h"
#include "skyBox.h"
#include "glob.h"

typedef std::vector< osg::ref_ptr<osg::Image> > ImageList;

class findNodeVisitor : public osg::NodeVisitor
{
        private:
                std::string searchName;
                
        public:
                typedef std::vector<osg::Node*> TNodeList;
                TNodeList results;
                findNodeVisitor() : osg::NodeVisitor(TRAVERSE_ALL_CHILDREN){}
                void setSearchName (const std::string &searchName){this->searchName=searchName;results.clear();}
                virtual void apply (osg::Node &searchNode){
                        if (searchNode.getName().compare(0, searchName.length(),searchName)==0)
                                results.push_back (&searchNode);
                        traverse(searchNode);   
                }
};

osg::Node* clip_object_with_plane(osg::Node* subgraph, osg::Vec3 plane_norm, osg::Vec3 plane_point)
{
        osg::Group* rootnode = new osg::Group;
    

    // create wireframe view of the model so the user can see
    // what parts are being culled away.
        osg::StateSet* stateset = new osg::StateSet;
    //osg::Material* material = new osg::Material;
        osg::PolygonMode* polymode = new osg::PolygonMode;
        polymode->setMode(osg::PolygonMode::FRONT_AND_BACK,osg::PolygonMode::LINE);
        stateset->setAttributeAndModes(polymode,osg::StateAttribute::OVERRIDE|osg::StateAttribute::ON);
    


    // more complex approach to managing ClipNode, allowing
    // ClipNode node to be transformed independantly from the subgraph
    // that it is clipping.
    /*
        osg::MatrixTransform* transform= new osg::MatrixTransform;

        osg::ClipNode* clipnode = new osg::ClipNode;
        osg::BoundingSphere bs = subgraph->getBound();
        bs.radius()*= 0.4f;

        osg::BoundingBox bb;
        bb.expandBy(bs);

        clipnode->createClipBox(bb);
        clipnode->setCullingActive(false);

        transform->addChild(clipnode);
        rootnode->addChild(transform);*/
        osg::MatrixTransform* transform= new osg::MatrixTransform;

        osg::ClipNode* clipnode = new osg::ClipNode;
    
        //osg::Vec4 plane_coord(-0.1,0.2,0.3,0.4);
        osg::Plane plane(plane_norm,plane_point);
        //osg::Plane plane(plane_coord);

        clipnode->addClipPlane(new osg::ClipPlane(0,plane));
        clipnode->setCullingActive(false);

        transform->addChild(clipnode);
        rootnode->addChild(transform);


    // create clipped part.
        osg::Group* clipped_subgraph = new osg::Group;

        clipped_subgraph->setStateSet(clipnode->getStateSet());
        clipped_subgraph->addChild(subgraph);
        rootnode->addChild(clipped_subgraph);

        return rootnode;
}

osg::Node* clip_object_with_box(osg::Node* subgraph, osg::BoundingBox bb)
{
        osg::Group* rootnode = new osg::Group;
    

    // create wireframe view of the model so the user can see
    // what parts are being culled away.
        osg::StateSet* stateset = new osg::StateSet;
    //osg::Material* material = new osg::Material;
        osg::PolygonMode* polymode = new osg::PolygonMode;
        polymode->setMode(osg::PolygonMode::FRONT_AND_BACK,osg::PolygonMode::LINE);
        stateset->setAttributeAndModes(polymode,osg::StateAttribute::OVERRIDE|osg::StateAttribute::ON);
    


    // more complex approach to managing ClipNode, allowing
    // ClipNode node to be transformed independantly from the subgraph
    // that it is clipping.

        osg::MatrixTransform* transform= new osg::MatrixTransform;

        osg::ClipNode* clipnode = new osg::ClipNode;
        
        
        clipnode->createClipBox(bb);
        clipnode->setCullingActive(false);

        transform->addChild(clipnode);
        rootnode->addChild(transform);


    // create clipped part.
        osg::Group* clipped_subgraph = new osg::Group;

        clipped_subgraph->setStateSet(clipnode->getStateSet());
        clipped_subgraph->addChild(subgraph);
        rootnode->addChild(clipped_subgraph);

        return rootnode;
}



osg::Node* createWaterNode(osg::Node* scene, waterPlan* water1)
{
            
 
        osg::MatrixTransform* rootNode = new osg::MatrixTransform;
        //rootNode->setMatrix(osg::Matrix::rotate(osg::inDegrees(45.0f),1.0f,0.0f,0.0f));
        
    // make sure that the global color mask exists.
        osg::ColorMask* rootColorMask = new osg::ColorMask;
        rootColorMask->setMask(true,true,true,true);        
    
    // set up depth to be inherited by the rest of the scene unless
    // overrideen. this is overridden in bin 3.
        osg::Depth* rootDepth = new osg::Depth;
        rootDepth->setFunction(osg::Depth::LESS);
        rootDepth->setRange(0.0,1.0);

        osg::StateSet* rootStateSet = scene->getOrCreateStateSet();// new osg::StateSet();        
        rootStateSet->setAttribute(rootColorMask);
        rootStateSet->setAttribute(rootDepth);

        rootNode->setStateSet(rootStateSet);


    // bin1  - set up the stencil values and depth for mirror.
        {
    
        // set up the stencil ops so that the stencil buffer get set at
        // the mirror plane 
                osg::Stencil* stencil = new osg::Stencil;
                stencil->setFunction(osg::Stencil::ALWAYS,1,~0u);
                stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP, osg::Stencil::REPLACE);//tout mettre à 1
        
        // switch off the writing to the color bit planes.
                osg::ColorMask* colorMask = new osg::ColorMask;
                colorMask->setMask(false,false,false,false);
        
                osg::StateSet* statesetBin1 = new osg::StateSet();        
                statesetBin1->setRenderBinDetails(1,"RenderBin");
                statesetBin1->setMode(GL_CULL_FACE,osg::StateAttribute::OFF);
                statesetBin1->setAttributeAndModes(stencil,osg::StateAttribute::ON);
                statesetBin1->setAttribute(colorMask);
        
        // set up the mirror group.
                osg::Geode* geode = new osg::Geode;
                geode->addDrawable(water1->getOrCreateDrawable());
                //geode->addDrawable(mirror2);
                geode->setStateSet(statesetBin1);
        
                rootNode->addChild(geode);
        
        }

    // bin one - draw scene without mirror or reflection, unset 
    // stencil values where scene is infront of mirror and hence
    // occludes the mirror. 
        {        
                osg::Stencil* stencil = new osg::Stencil;
                stencil->setFunction(osg::Stencil::ALWAYS,0,~0u);
                stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP, osg::Stencil::REPLACE);//tout mettre à 0

                osg::StateSet* statesetBin2 = new osg::StateSet();        
                statesetBin2->setRenderBinDetails(2,"RenderBin");
                statesetBin2->setAttributeAndModes(stencil,osg::StateAttribute::ON);
        

                osg::Group* groupBin2 = new osg::Group();
                groupBin2->setStateSet(statesetBin2);
                //groupBin2->addChild(scene);
        
                rootNode->addChild(groupBin2);
        }
        
    // bin3  - set up the depth to the furthest depth value
        {
    
        // set up the stencil ops so that only operator on this mirrors stencil value.
                osg::Stencil* stencil = new osg::Stencil;
                stencil->setFunction(osg::Stencil::EQUAL,1,~0u);
                stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP, osg::Stencil::KEEP);//si c 1, on garde, sinon on garde
        
        // switch off the writing to the color bit planes.
                osg::ColorMask* colorMask = new osg::ColorMask;
                colorMask->setMask(false,false,false,false);

        // set up depth so all writing to depth goes to maximum depth.
                osg::Depth* depth = new osg::Depth;
                depth->setFunction(osg::Depth::ALWAYS);
                depth->setRange(1.0,2.0);

                osg::StateSet* statesetBin3 = new osg::StateSet();
                statesetBin3->setRenderBinDetails(3,"RenderBin");
                statesetBin3->setMode(GL_CULL_FACE,osg::StateAttribute::OFF);
                statesetBin3->setAttributeAndModes(stencil,osg::StateAttribute::ON);
                statesetBin3->setAttribute(colorMask);
                statesetBin3->setAttribute(depth);
                
        
                
        // set up the mirror group.
                osg::Geode* geode = new osg::Geode;
                geode->addDrawable(water1->getOrCreateDrawable());
                //geode->addDrawable(mirror2);
                geode->setStateSet(statesetBin3);
        
                rootNode->addChild(geode);
        
        }

    // bin4  - draw the reflection.
        {
    
        // now create the 'reflection' of the loaded model by applying
        // create a Transform which flips the loaded model about the z axis
        // relative to the mirror node, the loadedModel is added to the
        // Transform so now appears twice in the scene, but is shared so there
        // is negligable memory overhead.  Also use an osg::StateSet 
        // attached to the Transform to override the face culling on the subgraph
        // to prevert an 'inside' out view of the reflected model.
        // set up the stencil ops so that only operator on this mirrors stencil value.

                float z=water1->getZ();

        // this clip plane removes any of the scene which when mirror would
        // poke through the mirror.  However, this clip plane should really
        // flip sides once the eye point goes to the back of the mirror...
                osg::ClipPlane* clipplane1 = new osg::ClipPlane;
                clipplane1->setClipPlane(0.0,0.0,-1.0,z);
                clipplane1->setClipPlaneNum(0);
                                
                osg::ClipNode* clipNode = new osg::ClipNode;
                clipNode->addClipPlane(clipplane1);

                osg::StateSet* dstate = clipNode->getOrCreateStateSet();
                dstate->setRenderBinDetails(4,"RenderBin");
                dstate->setMode(GL_CULL_FACE,osg::StateAttribute::OVERRIDE|osg::StateAttribute::OFF);

                osg::Stencil* stencil = new osg::Stencil;
                stencil->setFunction(osg::Stencil::EQUAL,1,~0u);
                stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP, osg::Stencil::KEEP);//si c 1 ou 0 on garde
                dstate->setAttributeAndModes(stencil,osg::StateAttribute::ON);

                
                osg::MatrixTransform* reverseMatrix = new osg::MatrixTransform;
                reverseMatrix->setStateSet(dstate);
                
                reverseMatrix->preMult(osg::Matrix::translate(0.0f,0.0f,-z)*
                                osg::Matrix::scale(1.0f,1.0f,-1.0f)*
                                osg::Matrix::translate(0.0f,0.0f,z));

                reverseMatrix->addChild(scene);

                clipNode->addChild(reverseMatrix);

                rootNode->addChild(clipNode);
    
        }


    // bin5  - draw the textured mirror and blend it with the reflection.
        {
    
        // set up depth so all writing to depth goes to maximum depth.
                osg::Depth* depth = new osg::Depth;
                depth->setFunction(osg::Depth::ALWAYS);

                osg::Stencil* stencil = new osg::Stencil;
                stencil->setFunction(osg::Stencil::EQUAL,1,~0u);
                stencil->setOperation(osg::Stencil::KEEP, osg::Stencil::KEEP, osg::Stencil::ZERO);// si c 1 on met à 0

        // set up additive blending.
                osg::BlendFunc* trans = new osg::BlendFunc;
                trans->setFunction(osg::BlendFunc::SRC_ALPHA,osg::BlendFunc::ONE_MINUS_SRC_ALPHA);
                
                //osg::StateSet* statesetBin5 = new osg::StateSet();//water1->createMirrorTexturedState("Images/eau.bmp");
                
                osg::StateSet* statesetBin5 = water1->getOrCreateGeodeWater(water1->createMirrorTexturedState())->getOrCreateStateSet();

                statesetBin5->setRenderBinDetails(5,"RenderBin");
                statesetBin5->setMode(GL_CULL_FACE,osg::StateAttribute::OFF);
                statesetBin5->setAttributeAndModes(stencil,osg::StateAttribute::ON);
                statesetBin5->setAttributeAndModes(trans,osg::StateAttribute::ON);
                statesetBin5->setAttribute(depth);
                
                
        // set up the mirror group.
                
        
                
                osg::Geode* geode = water1->getOrCreateGeodeWater(statesetBin5);
                
                rootNode->addChild(geode);

        }
        
        return rootNode;
}

osg::StateSet* createMirrorTexturedState(const std::string& filename)
{
        osg::StateSet* dstate = new osg::StateSet;
        
                
        //Modif barth
        dstate->setMode(GL_CULL_FACE,osg::StateAttribute::OFF|osg::StateAttribute::PROTECTED);
    
        return dstate; 
    // set up the texture.
        osg::Image* image = osgDB::readImageFile(filename.c_str());
        if (image)
        {
                osg::Texture2D* texture = new osg::Texture2D;
                texture->setImage(image);
                texture->setWrap(osg::Texture2D::WRAP_S, osg::Texture2D::REPEAT);
                texture->setWrap(osg::Texture2D::WRAP_T, osg::Texture2D::REPEAT);
                dstate->setTextureAttributeAndModes(0,texture,osg::StateAttribute::ON|osg::StateAttribute::PROTECTED);
                
        }
        
        return dstate;
}

osg::Node* createWaterNodeWithoutMirror(osg::Node* scene, osg::Geode* mirrors)
{
        
    // calculate where to place 
        //       <----Width---->
        //      --------O-------- --> X
        //      |               |
        //      |               |   height
        //      |               |
        //      -----------------
        //              |
        //              \/
        //              Y
            
 
        osg::MatrixTransform* rootNode = new osg::MatrixTransform;
        //rootNode->setMatrix(osg::Matrix::rotate(osg::inDegrees(45.0f),1.0f,0.0f,0.0f));
        
        
        osg::BlendFunc* trans = new osg::BlendFunc;
        trans->setFunction(osg::BlendFunc::DST_COLOR,osg::BlendFunc::SRC_ALPHA);

        osg::StateSet* statesetBin5 = createMirrorTexturedState("Textures/eau.bmp");

        statesetBin5->setRenderBinDetails(5,"RenderBin");
        statesetBin5->setMode(GL_CULL_FACE,osg::StateAttribute::OFF);
        statesetBin5->setAttributeAndModes(trans,osg::StateAttribute::ON);
        
        // set up the mirror group.
        osg::Group* grp = new osg::Group;
        grp->addChild(mirrors);
        grp->setStateSet(statesetBin5);
        
        rootNode->addChild(grp);
    
        return rootNode;
}






osg::Group* initWater(osg::ref_ptr<osg::Group> scene,osgProducer::Viewer* viewer, osg::Node* terrainNode, bool isfog)
{
        osg::ref_ptr<osg::Group> scene_all = new osg::Group();
        scene_all->addChild(scene.get());
        
        
        //osg::ref_ptr<osg::Group> scene_dam_et_waters = new osg::Group();
        
        
        
        bool fog=false;

        // ** Ajout d'éléments à la scène ** //
        
        float xmin_water1=-80;
        float xmax_water1=100;
        float ymin_water1=0;
        float ymax_water1=100;
        float z_water1=-8.8;
        
        float xmin_water2=10;
        float xmax_water2=20;
        float ymin_water2=1;
        float ymax_water2=-50;
        float z_water2=-15.8;
        
        osg::Vec3 plan_water1 = osg::Vec3(0,0,-1);
        osg::Vec3 plan_water2 = osg::Vec3(0,0,-1);
        osg::Vec3 point_water1 = osg::Vec3(0,0,3.2);
        osg::Vec3 point_water2 = osg::Vec3(0,0,4.0);
        osg::BoundingBox bb_water1(xmin_water1,33.5,z_water1,xmax_water1,ymax_water1+100,z_water1+20.0);
        osg::Vec3 plan_water1_upper;
        plan_water1_upper.set(plan_water1.x(),plan_water1.y(),plan_water1.z());
        
//      terrainNode = createScene2(); //osgDB::readNodeFile("lz.osg");
//      osg::Node * terrainNode2 = createScene2(); //osgDB::readNodeFile("lz.osg");
        
        
        //osg::Node * terrainNode2 = createScene(); //osgDB::readNodeFile("lz.osg");
        //osg::Node * terrainNode2 =terrainNode; //(osg::Node*) terrainNode->clone(osg::CopyOp::DEEP_COPY_DRAWABLES);
        
        //osg::Node *terrainNodeUnderWater1 = clip_object_with_plane(terrainNode, plan_water1, point_water1);//clip_object_with_box(terrainNode, bb_water1);

        osg::LOD * lod ;
        osg::PositionAttitudeTransform * pat;
        FogCube* fogcube ;
        // couleur sous la mer
        osg::Vec4 dark_blue = osg::Vec4(0.0, 0.0, 0.15, 0.9);

        if(isfog)
        {
                osg::Node *terrainNodeUnderWater1 = clip_object_with_box(terrainNode, bb_water1);
                
                
                
                std::cout << "Création du brouillard sur le terrain immergé..." <<std::endl;
                
                fogcube = new FogCube();
                fogcube->setMode(osg::Fog::LINEAR);
                fogcube->setColor(dark_blue);
                fogcube->setDensity(0.075);
                fogcube->setCube(xmin_water1,xmax_water1,ymin_water1,ymax_water1,-10,0.0);
                fogcube->setStart(2.0);
                fogcube->setEnd(50.0);
                fogcube->addFog(terrainNodeUnderWater1);
                //fogcube->addDynamicFogCoords(terrainNodeUnderWater1);
                        
                
                
                lod = new osg::LOD;
                lod->setRangeMode(osg::LOD::DISTANCE_FROM_EYE_POINT);
                lod->setCenterMode(osg::LOD::USE_BOUNDING_SPHERE_CENTER);

                //tout pres : 0 - 500
                pat = new osg::PositionAttitudeTransform();
                pat->addChild(terrainNodeUnderWater1);
                pat->setScale(osg::Vec3(1.5,1.5,2.5));
                pat->setPosition(osg::Vec3(-50,-50,-17.9));
                lod->addChild(pat,0,70.0);
                //500 -1000
                pat = new osg::PositionAttitudeTransform();
                pat->addChild(terrainNodeUnderWater1);
                pat->setScale(osg::Vec3(1.5,1.5,2.5));
                pat->setPosition(osg::Vec3(-50,-50,-17.2));
                lod->addChild(pat,70.0,350.0);
                // 1000 - 100000
                pat = new osg::PositionAttitudeTransform();
                pat->addChild(terrainNodeUnderWater1);
                pat->setScale(osg::Vec3(1.5,1.5,2.5));
                pat->setPosition(osg::Vec3(-50,-50,-16.8));
                lod->addChild(pat,350.0,10000.0);
                //ajout du lod a la scene
                scene_all->addChild(lod);
        }
        
        
        pat = new osg::PositionAttitudeTransform();
        pat->addChild(terrainNode);
        pat->setScale(osg::Vec3(1.5,1.5,2.5));
        pat->setPosition(osg::Vec3(-50,-50,-18));
        scene->addChild(pat);
        
        std::cout << "Création du barrage..." <<std::endl;
        osg::Node * damNode = osgDB::readNodeFile("Models/barrage/dam.osg");
        
        findNodeVisitor fnv;
        fnv.setSearchName("barrageHaut");
        damNode->accept(fnv);
        osg::Node *damNodeTop =fnv.results[0] ;
        fnv.setSearchName("barrageDerriere");
        damNode->accept(fnv);
        osg::Node *damNodeUnderWater1 =fnv.results[0] ;
        fnv.setSearchName("barrageDevantFinal");
        damNode->accept(fnv);
        osg::Node *damNodeNotUnderWater1 =fnv.results[0] ;
        fnv.setSearchName("barrageDevant2");
        damNode->accept(fnv);
        osg::Node *damNodeNotUnderWater2 =fnv.results[0] ;
        
        osg::Group* gr_dam = new osg::Group();
        gr_dam->addChild(damNodeTop);
        gr_dam->addChild(damNodeUnderWater1);
        gr_dam->addChild(damNodeNotUnderWater1);
        gr_dam->addChild(damNodeNotUnderWater2);
        
        /*
        fnv.setSearchName("porte1");
        damNode->accept(fnv);
        gr_dam->addChild(fnv.results[0]);
        fnv.setSearchName("turbine1");
        damNode->accept(fnv);
        gr_dam->addChild(fnv.results[0]);
        */
        
        if(isfog)
        {
                std::cout << "Création des fog sur la parties immergées du barrage..." <<std::endl;
                fogcube = new FogCube();
                fogcube->setMode(osg::Fog::LINEAR);
                fogcube->setColor(dark_blue);
                fogcube->setStart(0.0);
                fogcube->setEnd(40.0);
                fogcube->setDensity(0.075);
                //fogcube->addFog(damNode);
                fogcube->setCube(xmin_water1,xmax_water1,ymin_water1,ymax_water1,0,50.0);
                fogcube->addDynamicFogCoords(damNodeUnderWater1);
        }
        
        pat_dam = new osg::PositionAttitudeTransform();
        pat_dam->addChild(gr_dam);
        osg::Quat*  quaternion = new osg::Quat();
        quaternion->makeRotate(1.57,1,0,0);
        pat_dam->setAttitude(*quaternion);
        //pat_dam->setScale(osg::Vec3(10,10,10));
        pat_dam->setPosition(osg::Vec3(-21.5,16.5,5.0));
        scene_all->addChild(pat_dam);
        
        
        
        
        std::cout << "Création du plan d'eau 1..." <<std::endl;
        waterPlan* water1 = new waterPlan();
        water1->setDeplacementWater(osg::Vec4f(-0.04,0.02,0.02,0.02));
        water1->setPlan(xmin_water1,xmax_water1,ymin_water1,ymax_water1,z_water1);
        water1->createMirrorSurfaceForTheDam(14.3);

        
        osg::ref_ptr<osg::Node> sceneAndWater = createWaterNode(scene.get(),water1);
        scene_all->addChild(sceneAndWater.get());
        
                
        if(isfog)
        {
                osg::Geode * p = water1->createGeodeUnderWater(14.3,-0.05);
                osg::Node * plan_dessous_water1 = createWaterNodeWithoutMirror(scene_all.get(),p);
                fogcube = new FogCube();
                fogcube->setMode(osg::Fog::LINEAR);
                fogcube->setColor(dark_blue);
                fogcube->setStart(0.0);
                fogcube->setEnd(10.0);
                fogcube->setDensity(0.075);
                //fogcube->setCube(xmin_water1,xmax_water1,ymin_water1,ymax_water1,0,100.0);
                fogcube->addFog(p);
                
                lod = new osg::LOD;
                lod->setRangeMode(osg::LOD::DISTANCE_FROM_EYE_POINT);
                lod->setCenterMode(osg::LOD::USE_BOUNDING_SPHERE_CENTER);
                lod->addChild(plan_dessous_water1,0,400.0);
                scene_all->addChild(lod);
        }
        //scene_all->addChild(plan_dessous_water1);
        
        
        
        std::cout << "Création du plan d'eau 2..." <<std::endl;
        waterPlan* water2 = new waterPlan();
        water2->setDeplacementWater(osg::Vec4f(-0.02,0.03,0.02,0.02));
        water2->setTexture("",3);
        water2->setPlan(xmin_water2,xmax_water2,ymin_water2,ymax_water2,z_water2);
        water2->createMirrorSurface();
        scene_all->addChild(water2->getOrCreateGeodeWater(water2->createMirrorTexturedState()));
        //osg::Group* scene2 = (osg::Group*)scene->clone(osg::CopyOp::DEEP_COPY_ALL);
        //scene_all->addChild(createWaterNode(scene2,water2));
        
        
        /*
        fogcube = new FogCube();
        fogcube->setMode(osg::Fog::LINEAR);
        fogcube->setColor(osg::Vec4(0.0, 0.1, 0.3, 0.3));
        fogcube->setDensity(0.075);
        fogcube->setStart(0.0);
        fogcube->setEnd(50.0);
        fogcube->setCube(-1000,1000,-1000,1000,0,50.0);
        fogcube->setStart(0.0);
        fogcube->setEnd(5000.0);
        fogcube->addDynamicFogCoords(water1->createNewGeodeWater(NULL)->get);
        */
                
        
        
        // set the scene to render
        viewer->setSceneData(scene_all.get());
        viewer->setRealizeCallback((osgProducer::OsgCameraGroup::RealizeCallback*)waterPlan::getStateCallback(water1->getOrCreateGeodeWater(),water2->getOrCreateGeodeWater())); 
        
        return scene_all.get();
        
        
        /*
        
        
        keyboardEventHandler* keh = new keyboardEventHandler();
        viewer.getEventHandlerList().push_front(keh); 

        keh->addFunction('a',toggleAA);

   //   keh->addFunction('k',keyboardEventHandler::KEY_DOWN,rotateTurretRight);
        keh->addFunction('k',keyboardEventHandler::KEY_UP,stopTurretRotation);
        keh->addFunction('j',rotateTurretLeft);
        keh->addFunction('j',keyboardEventHandler::KEY_UP,stopTurretRotation);

        
        */
        
}

---