src/scene3D.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 <string>
#include "scene3D.h"
#include "skyBox.h"
#include "waterdyn3d.h"
#include "Terrain3D.h"

#include <SDL.h>


float dist = 0.0;
int cpt_mvt = 0;
int mvtPorte = 2;
int posPorte = 0;
bool debut_descente_chute = false;
bool debut_descente_nuag = false;

#include "C_Chute.h"
#include "CallbackPorte.h"
#include "CallbackTurbine.h"
#include "keyboardEventHandler.h"



        osg::PositionAttitudeTransform * pat_dam;
         osg::PositionAttitudeTransform * pat1;
         osg::PositionAttitudeTransform * pat2_2;
         osg::Quat* quaternion; 
         osg::Geode * geo2;

 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);   
                }
};

void monter (){
        mvtPorte = LEVER;
}

void descendre (){
        mvtPorte = DESCENDRE;
}

void stop(){
        mvtPorte = ARRETER;
}

using namespace osg;

Scene3D::Scene3D(){
        rootNode = new osg::Group();
        rootStateSet = rootNode->getOrCreateStateSet();
        soundMgr=NULL;
        trees=true;
        fogs=true;
        sound=false;
}

Scene3D::~Scene3D()
{ 
        if(soundMgr!=NULL)
        {
                std::cout<< "suppression de la scene..."<<std::endl;
                delete soundMgr;
        }
}

void Scene3D::attach(osgProducer::Viewer* sceneview){
        sceneview->setSceneData(rootNode.get());
        viewer = sceneview;
}


void Scene3D::update() {
// x_rotator->run();
// y_rotator->run();
// z_rotator->run();
}

void Scene3D::optimize(osg::Node* root)
{
        // run optimization over the scene graph after the soundnodes are added 
        // otherwise in this case the transformation added earlier would dissapear.
        osgUtil::Optimizer optimzer;
        optimzer.optimize(root);
}
void Scene3D::initSound(){
        
        //instanciation d'un objet SoundManager
        Scene3D::soundMgr = new SoundManager(rootNode.get());
        //initialisation du son...
        std::cout<< "initialisation du son..." << std::endl;
        this->sound = Scene3D::soundMgr->init();
}


void Scene3D::createScene() 
{
        
        std::cout << "Création de la scene.." <<std::endl;

        osg::Group* terrain = new osg::Group;
        int nbtrees = 700;
    if(!trees) nbtrees=0;

        Terrain3D* t3D = new Terrain3D("Heightmap\\heightmap.bmp",terrain,nbtrees); 
        if(!t3D->Ok())
        {
                std::cout <<"Erreur lors de la création de la HeightMap" << std::endl;
                
                //return 1;
        }
        std::cout <<"Terrain créé!\n";
        //terrain = t3D->getGeode();
        terrain->addChild(t3D->getGeode());
        
        float xMin=0;
        float xMax=512;
        float yMin=0;
        float yMax=512;
        float z=-10;
        
        
        osg::Geode* terrain_geode = new osg::Geode();
        
        osg::Geometry* underterrain_geometry = new osg::Geometry;
        osg::Vec3Array* coords = new osg::Vec3Array(4);
        (*coords)[0].set(xMin,yMax,z);
        (*coords)[1].set(xMin,yMin,z);
        (*coords)[2].set(xMax,yMin,z);
        (*coords)[3].set(xMax,yMax,z);
        underterrain_geometry->setVertexArray(coords);
        osg::Vec3Array* norms = new osg::Vec3Array(1);
        (*norms)[0].set(0.0f,0.0f,1.0f);
        underterrain_geometry->setNormalArray(norms);
        underterrain_geometry->setNormalBinding(osg::Geometry::BIND_OVERALL);
        osg::Vec4Array* colours = new osg::Vec4Array(1);
        (*colours)[0].set(0.0f,0.0f,0.0f,0.9f);
        underterrain_geometry->setColorArray(colours);
        underterrain_geometry->setColorBinding(osg::Geometry::BIND_OVERALL);
        underterrain_geometry->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS,0,4));
        
        terrain_geode->addDrawable(underterrain_geometry);
        
        
        
        
        terrain->addChild(terrain_geode);
        
        
        
        osg::PositionAttitudeTransform * pat = new osg::PositionAttitudeTransform();
        pat->addChild(terrain);
        osg::Quat*  quaternion = new osg::Quat();
        quaternion->makeRotate(0.50,0,0,1);
        pat->setAttitude(*quaternion);
        pat->setScale(osg::Vec3(0.2,0.2,0.15));
        pat->setPosition(osg::Vec3(29,-14,-9));
        
        terrain = pat;

                
        //rootNode->addChild(n);
        
        std::cout << "Création des plans d'eau et du barrage..." <<std::endl;
        osg::Group* scene_all = initWater(rootNode,this->viewer,terrain,fogs);
        
        
        std::cout << "Création des chutes d'eau......";
        
        osg::Group* scene_particles = new osg::Group();
        creerChutesEtAnim(scene_particles);
        pat = new osg::PositionAttitudeTransform();
        pat->addChild(scene_particles);
        //pat->setScale(osg::Vec3(5,5,5));
        pat->setPosition(osg::Vec3(13.855,1.6,-15.42));

        //scene_all->addChild(pat);
        
        osg::PositionAttitudeTransform* pat2 = new osg::PositionAttitudeTransform();
        pat2->addChild(scene_all);
        //pat2->setScale(osg::Vec3(0.1,0.1,0.1));
        //pat2->setPosition(osg::Vec3(330,280,-60));
        
        std::cout << "........ [OK]" <<std::endl;
        
        
        SkyBox * sb = new SkyBox();
        osg::Node * n = sb->createSkyBox();
        
        osg::PositionAttitudeTransform* pat3 = new osg::PositionAttitudeTransform();
        pat3->addChild(pat);
        pat3->addChild(pat2);
        pat3->addChild(n);
        viewer->setSceneData(pat3);
        
        osg::Node * helico = osgDB::readNodeFile("Models/helicopter/as350b2.x");
        osg::Node * fishBoat = osgDB::readNodeFile("Models/boat/fishing-boat.3ds");
        osg::Node * fishBoat2 = osgDB::readNodeFile("Models/boat/dory.3ds");
        osg::Node * house = osgDB::readNodeFile("Models/objets/house01.3DS");
        
        rootNode->addChild(addObject(house,osg::Vec3d(-48,55,-7),osg::Vec3d(0.02, 0.02, 0.02)));
        
        //rootNode->addChild(addObject(fishBoat,osg::Vec3d(10,14,-8.8),osg::Vec3d(0.01, 0.01, 0.01)));
        rootNode->addChild(addObject(fishBoat2,osg::Vec3d(40,24,-8.83),osg::Vec3d(0.01, 0.01, 0.01)));
        
        //Ajout des nuages
        //setClouds(rootNode.get(),100);
        
        
        //Ajout de l'hélico
        osg::Vec3 center(29,-14,29);
        float radius = 100.0f;
        osg::Vec3 center1(10,-24,-9);
        osg::Vec3 center2(24,-10,29);
        std::cout << "Ajout de l'helico" << std::endl;
        
        float scale=1.5f;
        rootNode->addChild(this->createMovingModel(helico,scale,"data/Sounds/helicopter.wav",center,radius*0.8f,0.7));

        std::cout << "Objets ok." <<std::endl;
        
        if(this->sound)
        {
                
                addSoundSource("data/Sounds/waterfall1.wav",15,-3.5,-15.0,1.5f,20);
                
                        
                std::cout << "Sounds ok." <<std::endl;
                
        }
        
        std::cout << "Création des lumières......";
        
        
        //return;
        
                //Create 3 rotators, each with a unique PAT, and each with a unique axis
                //x_rotator = new Rotator(*x_model_pat, Rotator::X_AXIS);
                //y_rotator = new Rotator(*y_model_pat, Rotator::Y_AXIS);
                //z_rotator = new Rotator(*z_model_pat, Rotator::Z_AXIS);
                
                // Create the lights
                // Extract the light manager from the module registry, and initalize
                // with the osg::Group node that contains the rest of our scene data.
        lightManager.init(rootNode.get());
        {
                osg::Light * 
                                light = lightManager.getOrCreateLight(LightManager::ONE);
                // We turn off ambient light as it is on slightly as default by osg::Light.
                light->setAmbient(osg::Vec4d(0.7, 0.7, 0.7, 0.7));
                light->setDiffuse(osg::Vec4d(0.6, 0.5, 0.3, 1.0));      //Sun light
                light->setPosition(osg::Vec4d(10.0, 0.0, 500.0, 1.0));
                        
                /*
                This determines how far the light will travel away from the light
                source, by defining the level of attenuation. Note that this is
                quadratic, meaning the light power is inversely proportional to
                the distance squared. There is also constant and linear attenuation,
                but those do not really provide a realistic method for attenuation.
                */
                light->setConstantAttenuation(0.05);
                //light->setLinearAttenuation(0.05);
                //light->setQuadraticAttenuation(0.05);
        }
        
        //Create second light
        {
                osg::Light * 
                                light = lightManager.getOrCreateLight(LightManager::TWO);
                light->setAmbient(osg::Vec4d(1.0, .5, 0.0, 1.0));
                light->setDiffuse(osg::Vec4d(1.0, 0.8, 0.0, 1.0));      //Green light
                light->setPosition(osg::Vec4d(-300.0, 0.0, 10.0, 1.0));
                light->setConstantAttenuation(0.05);
                //light->setLinearAttenuation(0.05);
                //light->setQuadraticAttenuation(0.05);
        }
                
        //Create third light
        {
                osg::Light * 
                                light = lightManager.getOrCreateLight(LightManager::THREE);
                light->setAmbient(osg::Vec4d(0.0, 0.0, 0.0, 1.0));
                light->setDiffuse(osg::Vec4d(0.0, 1.0, 1.0, 1.0));      //Blue Light
                light->setPosition(osg::Vec4d(-90.0, 30.0, 5.0, 1.0));
                light->setConstantAttenuation(0.05);
                //light->setLinearAttenuation(0.05);
                light->setQuadraticAttenuation(0.05);
        }
        std::cout << ".......[OK]." <<std::endl;
        
        
        //this->setSky();
        //this->setSkyLightColor(osg::Vec4(0.24,0.23,0.14,1));
        std::cout << "Scene: done." <<std::endl;
        //rootStateSet->setMode(GL_LIGHTING, osg::StateAttribute::ON);
}

void Scene3D::setSky()
{
                // Create the root node
        root = new osg::MatrixTransform();  
        rootStateSet = root->getOrCreateStateSet();
        
        // Fog
        osg::Fog* fog = new osg::Fog();  
        fog->setMode(osg::Fog::LINEAR);
        fog->setDensity(0.9f);  
        rootStateSet->setAttribute(fog, osg::StateAttribute::ON);  
        rootStateSet->setMode(GL_FOG, osg::StateAttribute::ON);  
        
        // Sunlight
        osg::Light* light = new osg::Light;    
        light->setLightNum(0);  
        skyLight = new osg::LightSource();
        skyLight->setLight(light);
        skyLight->setLocalStateSetModes(osg::StateAttribute::ON); 
        rootStateSet->setAssociatedModes(light, osg::StateAttribute::ON);
        
        // Backlight
        osg::Light* light2 = new osg::Light;
        light2->setLightNum(1);
        backLight = new osg::LightSource();
        backLight->setLight(light2);
        backLight->setLocalStateSetModes(osg::StateAttribute::ON); 
        rootStateSet->setAssociatedModes(light2, osg::StateAttribute::ON);  
        
        /*
        osg::LightModel* lightModel = new osg::LightModel();
        lightModel->setAmbientIntensity(osg::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
        lightModel->setLocalViewer(false);
        lightModel->setTwoSided(false);
        lightModel->setColorControl(osg::LightModel::SEPARATE_SPECULAR_COLOR);
        rootStateSet->setAttribute(lightModel);
        rootStateSet->setMode(GL_LIGHTING, osg::StateAttribute::ON);
        */      
        
        // Create the Skydome node
        skyDome = new osg::MatrixTransform();  
        skyDome->addChild(new osg::Node());
        clouds = new osg::MatrixTransform();  
        clouds->addChild(new osg::Node());
        // Don't load graphics for the skydome yet, this will be done in setSkyDome()
        
        // Create the Sky node and add the SkyLight, Clouds and SkyDome nodes as it's children
        sky = new osg::MatrixTransform();
        sky->addChild(skyLight.get());
        sky->addChild(backLight.get());
        sky->addChild(skyDome.get());
        sky->addChild(clouds.get());
        
        // Add the Sky Node as a child to the root node
        root->asGroup()->addChild(sky.get());   
        rootNode->addChild(root.get());
}

void Scene3D::setVisibilityRange(float range) 
{
        osg::Fog* fog = dynamic_cast<osg::Fog*>(rootStateSet->getAttribute(osg::StateAttribute::FOG));
        fog->setStart(0.0f);
        fog->setEnd(range);  
}



void Scene3D::setClouds(osg::Node* node, float height) 
{
        osg::Fog* fog = dynamic_cast<osg::Fog*>(rootStateSet->getAttribute(osg::StateAttribute::FOG));
        float visibilityRange = fog->getEnd();
        clouds->setMatrix(osg::Matrix::scale(visibilityRange*0.9, height, visibilityRange*0.9));
        clouds->removeChild(0, 1);  
        osg::StateSet* stateset = node->getOrCreateStateSet();
        stateset->setMode(GL_LIGHTING, osg::StateAttribute::OFF | osg::StateAttribute::OVERRIDE);
        clouds->addChild(node); 
}


void Scene3D::setSkyLightColor(const osg::Vec4& color) 
{ 
        osg::Light* light = dynamic_cast<osg::Light*>(skyLight->getLight());
        light->setDiffuse(color);   
        light->setAmbient(color * 0.4);
        
        osg::Light* light2 = dynamic_cast<osg::Light*>(backLight->getLight());
        light2->setDiffuse(color * 0.4);
        light2->setAmbient(color * 0.0);
}


void Scene3D::setSkyLightPosition(const osg::Vec2& headingAzimuth) 
{  
        
        // Get current visibilityRange
        osg::Fog* fog = dynamic_cast<osg::Fog*>(rootStateSet->getAttribute(osg::StateAttribute::FOG));
        float visibilityRange = fog->getEnd();  
        
        osg::Matrix matrix;
        matrix.preMult(osg::Matrix::rotate(-osg::DegreesToRadians(headingAzimuth.x()), osg::Vec3(0.0f, 1.0f, 0.0f)));    
        matrix.preMult(osg::Matrix::rotate(osg::DegreesToRadians(headingAzimuth.y()), osg::Vec3(1.0f, 0.0f, 0.0f)));    
        matrix.preMult(osg::Matrix::translate(osg::Vec3(0.0f, 0.0f, -visibilityRange)));
        
        osg::Light* light = dynamic_cast<osg::Light*>(skyLight->getLight());  
        light->setPosition(osg::Vec4(matrix.getTrans(), 1.0f));
        
        osg::Light* light2 = dynamic_cast<osg::Light*>(backLight->getLight());  
        light2->setPosition(-osg::Vec4(matrix.getTrans(), 1.0f));
}


osg::Node* Scene3D::addObject(osg::Node* node,osg::Vec3d pos,osg::Vec3d scale)
{
        // Update texture matrix for cubemaps
        struct TexMatCallback : public osg::NodeCallback
        {
                public:
                
                TexMatCallback(osg::TexMat& tm) :
                        _texMat(tm)
                {
                }
                
                virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
                {
                        osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(nv);
                        if (cv)
                        {
                        const osg::Matrix& MV = cv->getModelViewMatrix();
                        const osg::Matrix R = osg::Matrix::rotate( osg::DegreesToRadians(112.0f), 0.0f,0.0f,1.0f)*
                                                osg::Matrix::rotate( osg::DegreesToRadians(90.0f), 1.0f,0.0f,0.0f);
                
                        osg::Quat q = MV.getRotate();
                        const osg::Matrix C = osg::Matrix::rotate( q.inverse() );
                
                        _texMat.setMatrix( C*R );
                        }
                
                        traverse(node,nv);
                }
                
                osg::TexMat& _texMat;
        };
        
        osg::StateSet* stateset = new osg::StateSet();
        
        osg::PositionAttitudeTransform * 
        position = new osg::PositionAttitudeTransform();
        position->setPosition(pos);
        position->setScale(scale);
        position->addChild(node);
        
        osg::TexMat* texMat = new osg::TexMat;
        stateset->setTextureAttribute(0, texMat);
        
        osg::TexEnvCombine *te0 = new osg::TexEnvCombine;    
        te0->setCombine_RGB(osg::TexEnvCombine::REPLACE);
        te0->setSource0_RGB(osg::TexEnvCombine::TEXTURE0);
        te0->setOperand0_RGB(osg::TexEnvCombine::SRC_COLOR);
        
        osg::TexEnvCombine *te1 = new osg::TexEnvCombine;    
        
        te1->setCombine_RGB(osg::TexEnvCombine::INTERPOLATE);
        te1->setSource0_RGB(osg::TexEnvCombine::TEXTURE1);
        te1->setOperand0_RGB(osg::TexEnvCombine::SRC_COLOR);
        te1->setSource1_RGB(osg::TexEnvCombine::PREVIOUS);
        te1->setOperand1_RGB(osg::TexEnvCombine::SRC_COLOR);
        te1->setSource2_RGB(osg::TexEnvCombine::PRIMARY_COLOR);
        te1->setOperand2_RGB(osg::TexEnvCombine::SRC_COLOR);
        stateset->setTextureAttributeAndModes(0, te0, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE);
        stateset->setTextureAttributeAndModes(1, te1, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE);
        
        osg::Group* group = new osg::Group;
        group->addChild(position);
        //group->setCullCallback(new TexMatCallback(*texMat));
        group->setStateSet( stateset );
        stateset->setMode(GL_LIGHTING, osg::StateAttribute::ON);
        return group;
}

void Scene3D::addSoundSource (const std::string & strFile, float x,float y, float z,float factor, float dist)
{

// Nécessaire pour s'assurer de l'update du listener
    osg::ref_ptr<osgAL::SoundRoot> sound_root = new osgAL::SoundRoot;


// Sa position dans le graphe n'est pas importante.
// IL faut juste que le cullTraversal soit appelé après chaque chgement sur le sounManager.
    rootNode->addChild(sound_root.get());


    // Creationde la transformation à la quelle on va attacher le sounNode
    osg::ref_ptr<osg::PositionAttitudeTransform> sound_transform = new osg::PositionAttitudeTransform;
    rootNode->addChild(sound_transform.get());
    sound_transform->setPosition(osg::Vec3(x,y,z));

    // Creation de la sphère qui matérialise le son
    /*
    osg::ref_ptr<osg::Geode> geode = new osg::Geode;
    osg::TessellationHints* hints = new osg::TessellationHints;
    hints->setDetailRatio(0.5f);
    geode->addDrawable(new osg::ShapeDrawable(new osg::Sphere(osg::Vec3(0.0f,0.0f,0.0f),2),hints));
    sound_transform->addChild(geode.get());
    */
    osg::ref_ptr<osgAL::SoundNode> sound_node = new osgAL::SoundNode;
    sound_transform->addChild(sound_node.get());        
    std::cerr << "Son d'ambiance : "<< strFile <<"... chargé." << std::endl;

        osg::ref_ptr<openalpp::Sample> sample = osgAL::SoundManager::instance()->getSample(strFile.c_str(), true);
        //std::cerr << "Loading sample: " << strFile << std::endl;
        
        // Creation du SOundState avec le nom du fichier que nous chargeons.
        osg::ref_ptr<osgAL::SoundState> sound_state = new osgAL::SoundState(strFile);
        sound_state->setSample(sample.get());
        sound_state->setGain(factor);
        sound_state->setReferenceDistance(dist*.1);
        sound_state->setRolloffFactor(3);
        sound_state->setPlay(true);
        sound_state->setLooping(true);
        
        // Allocation d'une source materielle pour ce soundState de priorité 10)
        sound_state->allocateSource(10, false);
        
        // Ajout du soundState au sound manager pour le retrouver ensuite
        osgAL::SoundManager::instance()->addSoundState(sound_state.get());
        
        sound_state->apply();
        sound_node->setSoundState(sound_state.get());

}
osg::Drawable* Scene3D::createShrub(const float & scale, osg::StateSet* bbState)
{
        // Taille du shrub
        float width = 1.5f;
        float height = 3.0f;
        
        // Mise à l'échelle
        width *= scale;
        height *= scale;
        
        // Initialisation d'un Geometry
        osg::Geometry* shrubQuad = new osg::Geometry;
        
        // Declare an array of vertices, assign values so we can create a
        // quadrilateral centered relative to the Z axis
        osg::Vec3Array* shrubVerts = new osg::Vec3Array(4);
        (*shrubVerts)[0] = osg::Vec3(-width/2.0f, 0, 0);
        (*shrubVerts)[1] = osg::Vec3( width/2.0f, 0, 0);
        (*shrubVerts)[2] = osg::Vec3( width/2.0f, 0, height);
        (*shrubVerts)[3] = osg::Vec3(-width/2.0f, 0, height);
        shrubQuad->setVertexArray(shrubVerts);
        
        // Déclaration et assignation des coordonnées texture
        osg::Vec2Array* shrubTexCoords = new osg::Vec2Array(4);
        (*shrubTexCoords)[0].set(0.0f,0.0f);
        (*shrubTexCoords)[1].set(1.0f,0.0f);
        (*shrubTexCoords)[2].set(1.0f,1.0f);
        (*shrubTexCoords)[3].set(0.0f,1.0f);
        shrubQuad->setTexCoordArray(0,shrubTexCoords);
        
        // Ajout de primitives (QUADS) au geometry
        shrubQuad->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS,0,4));
        
        // S'assurer que le géometry est dans l'état correct
        shrubQuad->setStateSet(bbState);
        
        return shrubQuad;
}               

void Scene3D::addTree (const std::string & strFile, float x,float y, float z)
{
        
        osg::Billboard* shrubBillBoard = new osg::Billboard();
                                
        shrubBillBoard->setMode(osg::Billboard::AXIAL_ROT);
        shrubBillBoard->setAxis(osg::Vec3(0.0f,0.0f,1.0f));
        shrubBillBoard->setNormal(osg::Vec3(0.0f,-1.0f,0.0f));
        
        
        osg::Texture2D *treeTexture = new osg::Texture2D;
        treeTexture->setImage(osgDB::readImageFile(strFile));
        
        osg::AlphaFunc* alphaFunc = new osg::AlphaFunc;
        alphaFunc->setFunction(osg::AlphaFunc::GEQUAL,0.5f);
        
        osg::StateSet* billBoardStateSet = new osg::StateSet;
        
        billBoardStateSet->setMode( GL_LIGHTING, osg::StateAttribute::ON );
        billBoardStateSet->setTextureAttributeAndModes                                          (0, treeTexture, osg::StateAttribute::ON );
        billBoardStateSet->setAttributeAndModes
        (new osg::BlendFunc, osg::StateAttribute::ON );
        osg::AlphaFunc* alphaFunction = new osg::AlphaFunc;
        alphaFunction->setFunction(osg::AlphaFunc::GEQUAL,0.05f);
        billBoardStateSet->setAttributeAndModes( alphaFunc, osg::StateAttribute::ON );

        osg::Drawable* shrub1Drawable = createShrub( 30.0f, billBoardStateSet);

        // Add these drawables to our billboard at various positions
        shrubBillBoard->addDrawable( shrub1Drawable , osg::Vec3(x,y,z) );
        rootNode->addChild(shrubBillBoard);

}


osg::ref_ptr<osg::Group> Scene3D::getRootNode()
{
        return rootNode;
}
osg::ref_ptr<osg::MatrixTransform> Scene3D::getRoot()
{
        return root;
}

bool Scene3D::isSoundEnabled()
{
        return sound;
}

void Scene3D::creerChutesEtAnim(osg::Group* scene)
{
        
        keyboardEventHandler* keh = new keyboardEventHandler();
        viewer->getEventHandlerList().push_front(keh); 
        keh->addFunction('u',monter);
        keh->addFunction('d',descendre);
        keh->addFunction('s',stop);
        
        
        
        float espacement_portes = 0.55;
        osg::Group* grp_particules_porte_turbine = new osg::Group();
        
        //scene->addChild(grp_particules);
        osg::PositionAttitudeTransform* pat ;
        
        
        
        
        

        osg::Group * node_emitter = new osg::Group;

        osg::Group* grp_particules = new osg::Group();

        C_Chute *chute = new C_Chute(grp_particules,node_emitter,"dust23.rgb");
        chute->type = CHU;
        chute->lifeTime = 1;
        chute->mass = 0.7;
        chute->range_min = -0.07;
        chute->range_max = 0;
        //chute->nbGenerate = 250;
        chute->nbGenerate = 0;
        chute->radiusRangeMin = -0.08;
        chute->radiusRangeMax = 0.08;
        chute->enableShooter = true;
        chute->speedRangeMin = 2;
        chute->speedRangeMax = 3;
        chute->thetaRangeMax = 0.1;
        chute->thetaRangeMin = -0.1;
        chute->phiRangeMax = 0;
        chute->phiRangeMin = 0;
        chute->vecAcceleration = osg::Vec3(0,0,-5);
        //chute->Creer_Chute(35.380,-20.516,15.893);
        chute->Creer_Chute(0,-0.05,1);

        C_Chute *chute2 = new C_Chute(grp_particules,node_emitter,"dust23.rgb");
        chute2->type = CHU;
        chute2->lifeTime = 1;
        chute2->mass = 0.7;
        chute2->range_min = -0.07;
        chute2->range_max = 0;
        //chute->nbGenerate = 250;
        chute2->nbGenerate = 0;
        chute2->radiusRangeMin = -0.08;
        chute2->radiusRangeMax = 0.08;
        chute2->enableShooter = true;
        chute2->speedRangeMin = 2;
        chute2->speedRangeMax = 3;
        chute2->thetaRangeMax = 0.1;
        chute2->thetaRangeMin = -0.1;
        chute2->phiRangeMax = 0;
        chute2->phiRangeMin = 0;
        chute2->vecAcceleration = osg::Vec3(0,0,-5);
        //chute->Creer_Chute(35.380,-20.516,15.893);
        chute2->Creer_Chute(0.5625,-0.05,1);

        C_Chute *chute3 = new C_Chute(grp_particules,node_emitter,"dust23.rgb");
        chute3->type = CHU;
        chute3->lifeTime = 1;
        chute3->mass = 0.7;
        chute3->range_min = -0.07;
        chute3->range_max = 0;
        //chute->nbGenerate = 250;
        chute3->nbGenerate = 0;
        chute3->radiusRangeMin = -0.08;
        chute3->radiusRangeMax = 0.08;
        chute3->enableShooter = true;
        chute3->speedRangeMin = 2;
        chute3->speedRangeMax = 3;
        chute3->thetaRangeMax = 0.1;
        chute3->thetaRangeMin = -0.1;
        chute3->phiRangeMax = 0;
        chute3->phiRangeMin = 0;
        chute3->vecAcceleration = osg::Vec3(0,0,-5);
        //chute->Creer_Chute(35.380,-20.516,15.893);
        chute3->Creer_Chute(1.125,-0.05,1);

        C_Chute *chutehz = new C_Chute(grp_particules,node_emitter,"dust23.rgb");
        chutehz->type = HZ;
        chutehz->lifeTime = 2.1;
        chutehz->mass = 0.02;
        chutehz->range_min = -0.07;
        chutehz->range_max = 0;
        //chute3->nbGenerate = 250;
        chutehz->nbGenerate = 0;
        chutehz->radiusRangeMin = -0.1;
        chutehz->radiusRangeMax = 0.1;
        chutehz->enableShooter = true;
        chutehz->speedRangeMin = 2;
        chutehz->speedRangeMax = 3;
        chutehz->thetaRangeMax = 0.2;
        chutehz->thetaRangeMin = -0.2;
        chutehz->phiRangeMax = 0;
        chutehz->phiRangeMin = 0;
        chutehz->vecAcceleration = osg::Vec3(0,-10,0);
        chutehz->Creer_Chute(0,-0.12,-1.6);
        
        C_Chute *chutehz2 = new C_Chute(grp_particules,node_emitter,"dust23.rgb");
        chutehz2->type = HZ;
        chutehz2->lifeTime = 2.1;
        chutehz2->mass = 0.02;
        chutehz2->range_min = -0.07;
        chutehz2->range_max = 0;
        //chute3->nbGenerate = 250;
        chutehz2->nbGenerate = 0;
        chutehz2->radiusRangeMin = -0.1;
        chutehz2->radiusRangeMax = 0.1;
        chutehz2->enableShooter = true;
        chutehz2->speedRangeMin = 2;
        chutehz2->speedRangeMax = 3;
        chutehz2->thetaRangeMax = 0.2;
        chutehz2->thetaRangeMin = -0.2;
        chutehz2->phiRangeMax = 0;
        chutehz2->phiRangeMin = 0;
        chutehz2->vecAcceleration = osg::Vec3(0,-10,0);
        chutehz2->Creer_Chute(0.5625,-0.12,-1.7);

        C_Chute *chutehz3 = new C_Chute(grp_particules,node_emitter,"dust23.rgb");
        chutehz3->type = HZ;
        chutehz3->lifeTime = 2.1;
        chutehz3->mass = 0.02;
        chutehz3->range_min = -0.07;
        chutehz3->range_max = 0;
        //chute3->nbGenerate = 250;
        chutehz3->nbGenerate = 0;
        chutehz3->radiusRangeMin = -0.1;
        chutehz3->radiusRangeMax = 0.1;
        chutehz3->enableShooter = true;
        chutehz3->speedRangeMin = 2;
        chutehz3->speedRangeMax = 3;
        chutehz3->thetaRangeMax = 0.2;
        chutehz3->thetaRangeMin = -0.2;
        chutehz3->phiRangeMax = 0;
        chutehz3->phiRangeMin = 0;
        chutehz3->vecAcceleration = osg::Vec3(0,-10,0);
        chutehz3->Creer_Chute(1.125,-0.12,-1.7);
        
        C_Chute *chutenuag = new C_Chute (grp_particules,node_emitter,"nuage.rgb");
        chutenuag->type = NUAG;
        chutenuag->lifeTime = 1;
        chutenuag->mass = 0.05;
        chutenuag->range_min = -0.03;
        chutenuag->range_max = 0.0;
        //chutenuag->nbGenerate = 200;
        chutenuag->nbGenerate = 0;
        chutenuag->enableShooter = true;
        chutenuag->radiusRangeMin = 0.0;
        chutenuag->radiusRangeMax = 0.05;
        chutenuag->thetaRangeMin = 0;//osg::PI/2;
        chutenuag->thetaRangeMax = 2*osg::PI;//3*osg::PI/2;
        chutenuag->phiRangeMin = 0;//osg::PI/2;
        chutenuag->phiRangeMax = 2*osg::PI;//3*osg::PI/2;
        chutenuag->speedRangeMin = 0.2;
        chutenuag->speedRangeMax = 1;
        chutenuag->enableAcc = false;
        //chutenuag->Creer_Chute(35.380,-21.5,17.2);    
        chutenuag->Creer_Chute(0,-0.5,2.1);     

        C_Chute *chutenuag2 = new C_Chute (grp_particules,node_emitter,"nuage.rgb");
        chutenuag2->type = NUAG;
        chutenuag2->lifeTime = 1;
        chutenuag2->mass = 0.05;
        chutenuag2->range_min = -0.03;
        chutenuag2->range_max = 0.0;
        //chutenuag->nbGenerate = 200;
        chutenuag2->nbGenerate = 0;
        chutenuag2->enableShooter = true;
        chutenuag2->radiusRangeMin = 0.0;
        chutenuag2->radiusRangeMax = 0.05;
        chutenuag2->thetaRangeMin = 0;//osg::PI/2;
        chutenuag2->thetaRangeMax = 2*osg::PI;//3*osg::PI/2;
        chutenuag2->phiRangeMin = 0;//osg::PI/2;
        chutenuag2->phiRangeMax = 2*osg::PI;//3*osg::PI/2;
        chutenuag2->speedRangeMin = 0.2;
        chutenuag2->speedRangeMax = 1;
        chutenuag2->enableAcc = false;
        //chutenuag->Creer_Chute(35.380,-21.5,17.2);    
        chutenuag2->Creer_Chute(0.5625,-0.5,2.1);       

        C_Chute *chutenuag3 = new C_Chute (grp_particules,node_emitter,"nuage.rgb");
        chutenuag3->type = NUAG;
        chutenuag3->lifeTime = 1;
        chutenuag3->mass = 0.05;
        chutenuag3->range_min = -0.03;
        chutenuag3->range_max = 0.0;
        chutenuag3->nbGenerate = 200;
        //chutenuag3->nbGenerate = 0;
        chutenuag3->enableShooter = true;
        chutenuag3->radiusRangeMin = 0.0;
        chutenuag3->radiusRangeMax = 0.05;
        chutenuag3->thetaRangeMin = 0;//osg::PI/2;
        chutenuag3->thetaRangeMax = 2*osg::PI;//3*osg::PI/2;
        chutenuag3->phiRangeMin = 0;//osg::PI/2;
        chutenuag3->phiRangeMax = 2*osg::PI;//3*osg::PI/2;
        chutenuag3->speedRangeMin = 0.2;
        chutenuag3->speedRangeMax = 1;
        chutenuag3->enableAcc = false;
        //chutenuag->Creer_Chute(35.380,-21.5,17.2);    
        chutenuag3->Creer_Chute(1.125,-0.5,2.1);        
        //R�cup�ration de tous les objets depuis le .3ds
        

        
        osg::Vec3 posis_part(-6.91,-2+1.2,7.75);
        
        pat = new osg::PositionAttitudeTransform();
        pat->addChild(grp_particules);
        pat->setPosition(posis_part);//+2.05
        //osg::Quat quaternion3;        quaternion3.makeRotate(1.57,1,0,0); pat->setAttitude(quaternion3);
        grp_particules_porte_turbine->addChild(pat);
        
        
        
        
        //scene->addChild(grp_particules);

        

        pat = new osg::PositionAttitudeTransform();
        pat->addChild(node_emitter);
        //pat->setPosition(osg::Vec3(-6.91,-2+2.05,8.52));//+2.05
        osg::Quat quaternion2;
        quaternion2.makeRotate(1.57,1,0,0);
        pat->setAttitude(quaternion2);
        pat->setPosition(posis_part);//+2.05
        //toto->setPosition(osg::Vec3(10,10,10));
        grp_particules_porte_turbine->addChild(pat);

        
        
        
        
        
        //R�cup�ration de tous les objets depuis le .3ds
        osg::Node * barrage = osgDB::readNodeFile("Models/barrage/essai44.3ds");
        
        //Barrage
        findNodeVisitor fnv;
        /*
        fnv.setSearchName("barrageHaut");
        barrage->accept(fnv);
        pat = new osg::PositionAttitudeTransform();
        pat->addChild(fnv.results[0]);
        pat->setPivotPoint(osg::Vec3(0,0,0));
        scene->addChild(pat);
        */
        
        osg::PositionAttitudeTransform* pat_porte_turbine = new osg::PositionAttitudeTransform();
        //pat_porte_turbine->setScale(osg::Vec3(10,10,10));
        //pat_porte_turbine->setPosition(osg::Vec3(80,0,10));
        osg::Quat quaternion3;  quaternion3.makeRotate(1.57,1,0,0);
        pat_porte_turbine->setAttitude(quaternion3);

        //Porte 1
        fnv.setSearchName("porte1");
        barrage->accept(fnv);
        osg::Geode * geo1 = dynamic_cast <osg::Geode * > (fnv.results[0]);
        pat1 = new osg::PositionAttitudeTransform();
        pat1->addChild(geo1);
        
        osg::StateSet * st = geo1->getOrCreateStateSet();
        osg::Image* image = osgDB::readImageFile("Models/barrage/metal4.gif");
        if (image)
        {
                osg::Texture2D* texture = new osg::Texture2D;
                texture->setImage(image);
                st->setTextureAttributeAndModes(0,texture,osg::StateAttribute::ON);
                
        }else std::cout<<"Erreur, impossible d'ouvrir la texture de la porte";
        
        pat_porte_turbine->addChild(pat1);
        
        //grp_particules->addChild(pat1);

        int colorindex=0;
        if(geo1)
        {
                osg::Drawable * draw1 = geo1->getDrawable(0);
                draw1->setUserData(new CallbackPorte(colorindex,draw1));
                geo1->setUpdateCallback(new geodePorteCallback());
        }

        
        //Turbine 1
        fnv.setSearchName("turbine1");
        barrage->accept(fnv);
        geo2 = dynamic_cast <osg::Geode * > (fnv.results[0]);
        
        pat2_2 = new osg::PositionAttitudeTransform();
        quaternion = new osg::Quat();
        pat2_2->setPosition(osg::Vec3(0.02,0,0));
        pat2_2->addChild(geo2);
        
        pat_porte_turbine->addChild(pat2_2);
        
        st = pat2_2->getOrCreateStateSet();
        image = osgDB::readImageFile("Models/barrage/metal4.gif");
        if (image)
        {
                osg::Texture2D* texture = new osg::Texture2D;
                texture->setImage(image);
                st->setTextureAttributeAndModes(0,texture,osg::StateAttribute::ON);
                
        }else std::cout<<"Erreur, impossible d'ouvrir la texture de la turbine";
        
        // couleur sous la mer
        osg::Vec4 dark_blue = osg::Vec4(0.0, 0.0, 0.15, 0.9);
        
        FogCube* 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(-50,50,-50,50,-50,50);
        fogcube->addFog(pat_porte_turbine);
        
        grp_particules_porte_turbine->addChild(pat_porte_turbine);
        pat = new osg::PositionAttitudeTransform();
        pat->addChild(pat_porte_turbine);
        pat->setPosition(osg::Vec3(espacement_portes,0,0));
        grp_particules_porte_turbine->addChild(pat);
        pat = new osg::PositionAttitudeTransform();
        pat->addChild(pat_porte_turbine);
        pat->setPosition(osg::Vec3(espacement_portes*2.0,0,0));
        grp_particules_porte_turbine->addChild(pat);
        //grp_particules->addChild(pat2_2);
        
        scene->addChild(grp_particules_porte_turbine);
        
        
        if(geo2)
        {
                osg::Drawable * draw2 = geo2->getDrawable(0);
                draw2->setUserData(new CallbackTurbine(colorindex,draw2));
                geo2->setUpdateCallback(new geodeTurbineCallback());
        }
        
}



osg::AnimationPath* createAnimationPath(const osg::Vec3& center,float radius,double looptime,float speed)
{
    // set up the animation path 
        osg::AnimationPath* animationPath = new osg::AnimationPath;
        animationPath->setLoopMode(osg::AnimationPath::LOOP);
    
        int numSamples = 240;
        float yaw = 0.0f;
        float yaw_delta = 2.0f*osg::PI/((float)numSamples-1.0f);
        float roll = osg::inDegrees(-20.0f);
    
        double time=0.0f;
        double time_delta = looptime/(double)numSamples*(1/speed);
        for(int i=0;i<numSamples;++i)
        {
                osg::Vec3 position(center+osg::Vec3(sinf(yaw)*radius,cosf(yaw)*radius,0.0f));
                osg::Quat rotation(osg::Quat(roll,osg::Vec3(0.0,1.0,0.0))*osg::Quat(-(yaw+osg::inDegrees(180.0f)),osg::Vec3(0.0,0.0,1.0)));
        
                animationPath->insert(time,osg::AnimationPath::ControlPoint(position,rotation));

                yaw += yaw_delta;
                time += time_delta;

        }
        return animationPath;    
}

osg::Node* Scene3D::createMovingModel(Node* n,float scale,const std::string & soundFile,const osg::Vec3& center, float radius, float speed)
{
        float animationLength = 30.0f;

        osg::AnimationPath* animationPath = createAnimationPath(center,radius,animationLength,speed);

        osg::Group* model = new osg::Group;

        if (n)
        {
                const osg::BoundingSphere& bs = n->getBound();

        //float size = radius/bs.radius()*0.3f;
                osg::MatrixTransform* positioned = new osg::MatrixTransform;
                positioned->setDataVariance(osg::Object::STATIC);
                positioned->setMatrix(osg::Matrix::translate(-bs.center())*
                                osg::Matrix::scale(scale,scale,scale)*
                                osg::Matrix::rotate(osg::inDegrees(-90.0f),0.0f,0.0f,1.0f));

                positioned->addChild(n);

                if(sound && soundFile!=""){
        // Create a sound node
                        osg::ref_ptr<osgAL::SoundNode> sound_node = soundMgr->createSound(soundFile);

        // Add the sound node
                        positioned->addChild(sound_node.get());
                }       

                osg::PositionAttitudeTransform* xform = new osg::PositionAttitudeTransform;    
                xform->setUpdateCallback(new osg::AnimationPathCallback(animationPath,0.0,1.0));
                xform->addChild(positioned);

                model->addChild(xform);
        }
 
        return model;
}

---