src/Terrain3D.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 "Terrain3D.h"
#include <stdlib.h>
#include <time.h>
#include <osg/Billboard>
#include <osg/AlphaFunc>
#include <osg/BlendFunc>


Terrain3D::Terrain3D(char* path, osg::Group* terrain,int nbTree)
{
        float perc[4];
        // On lit le fichier contenant les hauteurs de la map
        osg::Image * heights = osgDB::readImageFile(path);
        if(!heights)
        {
                printf("Erreur lors du chargement de la heigtmap\n");
                ok = false;
                return;
        }

        std::cout << "Heightmap chargée" << std::endl;
        

        // On alloue une heightmap
        HeightMap = new osg::HeightField();
        if(!HeightMap) 
        {
                printf("Erreur lors de l'allocation de la heightmap\n");
                ok = false;
                return;
        }

        // On alloue un bitmap
        SDL_Surface* TextureFinale = SDL_CreateRGBSurface(SDL_HWSURFACE,heights->s(), heights->t(), 32, 0, 0, 0, 0);
        if(!TextureFinale)
        {
                printf("Erreur lors de l'allocation de la texture de terrain\n");
                ok = false;
                return;
        }

        // On charge les différentes textures

                // texture de prairie
        SDL_Surface* terre = SDL_LoadBMP("data/Heightmap/terre.bmp");
        if(!terre)
        {
                printf("Erreur lors de la récupération de la texture de terre\n");
                ok = false;
                return;
        }

        SDL_Surface* prairies = SDL_LoadBMP("data/Heightmap/grassm.bmp");
        if(!prairies)
        {
                printf("Erreur lors de la récupération de la texture de prairie\n");
                ok = false;
                return;
        }

        SDL_Surface* rocheuses = SDL_LoadBMP("data/Heightmap/rock.bmp");
        if(!rocheuses)
        {
                printf("Erreur lors de la récupération de la texture de montagne\n");
                ok = false;
                return;
        }

        SDL_Surface* neige = SDL_LoadBMP("data/Heightmap/snow.bmp");
        if(!neige)
        {
                printf("Erreur lors de la récupération de la texture de neige\n");
                ok = false;
                return;
        }

        std::cout << "Textures chargées" << std::endl;
        
        // On dimensionne la heightmap
        printf("Heightmap : width=%d\theight=%d\n", heights->s(), heights->t());
        HeightMap->allocate(heights->s(), heights->t());

        // On affecte toutes les hauteurs
        for(int row=0; row<heights->s(); row++)
                for(int column=0; column<heights->t(); column++)
                {
                        // Recuperation des participations de couleurs pour le pixel courant 
                        int tmpi =      (int ) (( ((float) column)/TextureFinale->h) * heights->s()) ;
                        int tmpj =      (int ) (( ((float) row)/TextureFinale->w) * heights->t()) ;
                        RemplitPerc(perc,heights->data(column,row)[0]);

                        // On recupere les couleurs 
                        tmpi = column%terre->h;
                        tmpj = row%terre->w;

                        double b = perc[0] * GetPixelColor(terre,tmpi,tmpj,0);
                        double g = perc[0] * GetPixelColor(terre,tmpi,tmpj,1);
                        double r = perc[0] * GetPixelColor(terre,tmpi,tmpj,2);

                        tmpi =  column%prairies->h;
                        tmpj =  row%prairies->w;

                        b += perc[1] * GetPixelColor(prairies,tmpi,tmpj,0);
                        g += perc[1] * GetPixelColor(prairies,tmpi,tmpj,1);
                        r += perc[1] * GetPixelColor(prairies,tmpi,tmpj,2);

                        tmpi =  column%rocheuses->h;
                        tmpj =  row%rocheuses->w;

                        b += perc[2] * GetPixelColor(rocheuses,tmpi,tmpj,0);
                        g += perc[2] * GetPixelColor(rocheuses,tmpi,tmpj,1);
                        r += perc[2] * GetPixelColor(rocheuses,tmpi,tmpj,2);

                        tmpi =  column%neige->h;
                        tmpj =  row%neige->w;

                        b += perc[3] * GetPixelColor(neige,tmpi,tmpj,0);
                        g += perc[3] * GetPixelColor(neige,tmpi,tmpj,1);
                        r += perc[3] * GetPixelColor(neige,tmpi,tmpj,2);

                        // On a notre composante RGB, on la place ensuite dans la texture de terrain
                        SetPixel(TextureFinale, row, column, SDL_MapRGB(TextureFinale->format, (unsigned char)r, (unsigned char)g, (unsigned char)b));
                        if(row==(heights->s()-1) ||column == (heights->t()-1) || row==0 || column==0)
                        {
                                SetPixel(TextureFinale, row, column, SDL_MapRGB(TextureFinale->format, 0,0,0));
                                HeightMap->setHeight(row, heights->t()-column-1, -10);
                        } else
                        // On affecte la hauteur au point de la heigtmap
                                HeightMap->setHeight(row, heights->t()-column-1, heights->data(column,row)[0]);
                        
                }

        std::cout << "Textures crées" << std::endl;

        // On sauvegarde la texture de terrain
        SDL_SaveBMP(TextureFinale, "data/Heightmap/TextTerrain.bmp");

/*      osg::HeightField* HM = new osg::HeightField();
        HM->allocate((HeightMap->getNumColumns()*2)-1, (HeightMap->getNumRows()*2)-1);
        //HM->setXInterval(HM->getXInterval()/2);
        //HM->setYInterval(HM->getYInterval()/2);
        
        for(int row=0; row<(HeightMap->getNumRows()-1); row++)
                for(int column=0; column<(HeightMap->getNumColumns()-1); column++)
                {
                        HM->setHeight(row*2, column*2, HeightMap->getHeight(row,column));
                        HM->setHeight(1+row*2,column*2, (-HeightMap->getHeight(row,column)+HeightMap->getHeight(row+1,column))/2+HeightMap->getHeight(row,column));
                        HM->setHeight(row*2,1+column*2, (-HeightMap->getHeight(row,column)+HeightMap->getHeight(row,column+1))/2+HeightMap->getHeight(row,column));
                        HM->setHeight(1+row*2,1+column*2, (-HeightMap->getHeight(row,column)+HeightMap->getHeight(row+1,column+1))/2+HeightMap->getHeight(row,column));
                }
        HeightMap = HM;*/

        // On place la HeightMap dans une Geode
        osg::ShapeDrawable * HMDrawable = new osg::ShapeDrawable(HeightMap);
        HeightMapGeode = new osg::Geode();
        HeightMapGeode->addDrawable(HMDrawable);

        // On la texture
        TextureHeightMap();

        std::cout << "Heightmap terminée. " << std::endl;

        if(nbTree>0)
        {
                std::cout << "Génération des arbres. " << std::endl;

                osg::Texture2D *treeTexture = new osg::Texture2D;
                treeTexture->setImage(osgDB::readImageFile("data/Textures/Arbre3.png"));
                
                osg::Texture2D *treeTexture2 = new osg::Texture2D;
                treeTexture2->setImage(osgDB::readImageFile("data/Textures/Arbre2.png"));
                
                osg::Texture2D *treeTexture3 = new osg::Texture2D;
                treeTexture3->setImage(osgDB::readImageFile("data/Textures/falltree.png"));
                
                osg::Texture2D *treeTexture4 = new osg::Texture2D;
                treeTexture4->setImage(osgDB::readImageFile("data/Textures/arbre.png"));
                
                osg::Texture2D *grassTexture = new osg::Texture2D;
                grassTexture->setImage(osgDB::readImageFile("data/Textures/grass1.tga"));
                
                osg::Texture2D *grassTexture1 = new osg::Texture2D;
                grassTexture1->setImage(osgDB::readImageFile("data/Textures/grass2.tga"));
                
                osg::Texture2D *grassTexture2 = new osg::Texture2D;
                grassTexture2->setImage(osgDB::readImageFile("data/Textures/grass3.tga"));
                
                osg::Texture2D *grassTexture3 = new osg::Texture2D;
                grassTexture3->setImage(osgDB::readImageFile("data/Textures/grass4.tga"));
                
                osg::Texture2D *grassTexture4 = new osg::Texture2D;
                grassTexture4->setImage(osgDB::readImageFile("data/Textures/grass5.tga"));

                // Puis on lui ajoute des arbres
                srand(time(NULL));

                
                addTrees(terrain,grassTexture,2,1.0,1.1,nbTree,83,92);
                addTrees(terrain,grassTexture1,2,1.0,1.0,nbTree,83,90);
                addTrees(terrain,grassTexture2,2,2.0,1.0,nbTree,83,96);
                addTrees(terrain,grassTexture4,2,1.0,1.0,nbTree,83,95);
                addTrees(terrain,treeTexture,3,1.2,1.2,nbTree/2,90,125);
                addTrees(terrain,treeTexture2,3,2.0,1.5,nbTree,83,120);
                addTrees(terrain,treeTexture3,3,1.0,1.3,nbTree/4,85,110);
                addTrees(terrain,treeTexture4,3,1.2,1.2,nbTree,83,110);
        }
        
        std::cout << "Génération terminée." << std::endl;
        ok = true;
}

void Terrain3D::RemplitPerc(float *perc, unsigned char haut)
{
        /* On utilise la fonction rand pour mettre de l'aleatoire */
        int add = haut + (rand()%30)-15;

        if(add<0)
                add = 0;

        if(add>255)
                add = 255;

        haut = add;
        /* Que de la terre */
        if(haut<60)
        {
                perc[0] = 1.0f;
                perc[1] = 0.0f;
                perc[2] = 0.0f;
                perc[3] = 0.0f;
        }
        /* Mélange entre terre et prairie */
        else if(haut<80)
        {
                perc[0] = 1.0f - (haut-60.0f)/20.0f;
                perc[1] = (haut-60.0f)/20.0f;
                perc[2] = 0.0f;
                perc[3] = 0.0f;
        }
        /* Que de la prairie */
        else if(haut<100)
        {
                perc[0] = 0.0f;
                perc[1] = 1.0f;
                perc[2] = 0.0f;
                perc[3] = 0.0f;
        }
        /* Melange entre prairie et roche */
        else if(haut<150)
        {
                perc[0] = 0.0f;
                perc[1] = 1.0f - (haut-100.0f)/50.0f;
                perc[2] = (haut-100.0f)/50.0f;
                perc[3] = 0.0f;
        }
        /* Que de la roche */
        else if(haut<180)
        {
                perc[0] = 0.0f;
                perc[1] = 0.0f;
                perc[2] = 1.0f;
                perc[3] = 0.0f;
        }
        /* Melange entre roche et la neige */
        else if(haut<220)
        {
                perc[0] = 0.0f;
                perc[1] = 0.0f;
                perc[2] = 1.0f - (haut-180.0f)/40.0f;
                perc[3] = (haut-180.0f)/40.0f;
        }
        /* Que de la neige */
        else
        {
                perc[0] = 0.0f;
                perc[1] = 0.0f;
                perc[2] = 0.0f;
                perc[3] = 1.0f;
        }
}

unsigned char Terrain3D::GetPixelColor(SDL_Surface *image, int i, int j,int k)
{
        Uint8 *p = (Uint8*)image->pixels + j * image->pitch + i * image->format->BytesPerPixel;
        unsigned char r, g, b;
        SDL_GetRGB(*(Uint32*)p,image->format,&r,&g,&b);
        switch(k)
        {
                case 0:
                        return b;
                case 1:
                        return g;
                case 2:
                        return r;
                default:
                        return 0;
        }
}

void Terrain3D::SetPixel(SDL_Surface* Surface, int x, int y, Uint32 pixel)
{
    /* p est l'adresse du pixel que l'on veut modifier */
    Uint8 *p = (Uint8*)Surface->pixels + y * Surface->pitch + x * Surface->format->BytesPerPixel;

    switch(Surface->format->BytesPerPixel)
    {
    case 1:
        *p = pixel;
        break;

    case 2:
        *(Uint16*)p = pixel;
        break;

    case 3:
        if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
        {
            p[0] = (pixel >> 16) & 0xff;
            p[1] = (pixel >> 8) & 0xff;
            p[2] = pixel & 0xff;
        }

        else
        {
            p[0] = pixel & 0xff;
            p[1] = (pixel >> 8) & 0xff;
            p[2] = (pixel >> 16) & 0xff;
        }
        break;

    case 4:
        *(Uint32 *)p = pixel;
        break;
    }
}

void Terrain3D::TextureHeightMap()
{
        // On charge la texture
        osg::Texture2D* GrassTex = new osg::Texture2D;
        GrassTex->setDataVariance(osg::Object::DYNAMIC);

        osg::Image* GrassImg = osgDB::readImageFile("Heightmap/TextTerrain.bmp");
        if (!GrassImg)
        {
                std::cout << "Texture non trouvée" << std::endl;
                ok = false;
                return;
        }

        // Assign the texture to the image we read from file:
        GrassTex->setImage(GrassImg);

        // Create a new StateSet with default settings:
        osg::StateSet* stateGrass = new osg::StateSet();

        // Assign texture unit 0 of our new StateSet to the texture
        //  we just created and enable the texture.
        stateGrass->setTextureAttributeAndModes(0,GrassTex,osg::StateAttribute::ON);

        // Création de la lumière
        osg::Light* Lumiere = new osg::Light();
        Lumiere->setPosition(osg::Vec4(0,0,50,1));
        Lumiere->setAmbient(osg::Vec4(220,220,220,1));
        Lumiere->setDirection(osg::Vec3(0,-0.25,-1));
        Lumiere->setDiffuse(osg::Vec4(0,120,120,1));
        stateGrass->setAttributeAndModes(Lumiere);

        HeightMapGeode->setStateSet(stateGrass);
}

bool Terrain3D::Ok()
{
        return ok;
}

osg::Geode* Terrain3D::getGeode()
{
        return HeightMapGeode;
}

void Terrain3D::addTrees(osg::Group* rootNode, osg::Texture2D* treeTexture, float scale,float width,float height, int number, float hmin, float hmax)
{
        
        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::AlphaFunc* alphaFunc = new osg::AlphaFunc;
        alphaFunc->setFunction(osg::AlphaFunc::GEQUAL,0.5f);
        
        osg::StateSet* billBoardStateSet = new osg::StateSet;
        
        billBoardStateSet->setMode( GL_LIGHTING, osg::StateAttribute::OFF );
        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 = createBillboardDrawable( scale, billBoardStateSet,width,height);

        // Add these drawables to our billboard at various positions
        
        for(int i=0; i<(number); i++)
        {
                bool place = false;
                while(!place)
                {
                        int c = rand()%HeightMap->getNumColumns();
                        int r = rand()%HeightMap->getNumRows();
        
                        if((HeightMap->getHeight(c,r)>hmin) && (HeightMap->getHeight(c,r)<hmax) ||
                                                r<160 && c<220&& (HeightMap->getHeight(c,r)>hmin-18) && (HeightMap->getHeight(c,r)<hmax))
                        {
                                float x = HeightMap->getOrigin().x() + c * HeightMap->getXInterval();
                                float y = HeightMap->getOrigin().y() + r * HeightMap->getYInterval();
                                float z = HeightMap->getHeight(c,r);
                                shrubBillBoard->addDrawable( shrub1Drawable , osg::Vec3(x,y,z) );
                                place = true;
                        }
                }
        }
        
        
        rootNode->addChild(shrubBillBoard);
        
        
}

osg::Drawable* Terrain3D::createBillboardDrawable(float scale, osg::StateSet* bbState,float width,float height)
{
        // 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;
}               

---