Terrain.h

Go to the documentation of this file.

/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * This library 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
 * OpenSceneGraph Public License for more details.
*/

#ifndef OSGTerrain
#define OSGTerrain 1

#include <osg/CoordinateSystemNode>
#include <OpenThreads/ReentrantMutex>

#include <osgTerrain/TerrainTile>
#include <osgTerrain/GeometryPool>

namespace osgTerrain {

class OSGTERRAIN_EXPORT Terrain : public osg::CoordinateSystemNode
{
    public:

        Terrain();

        Terrain(const Terrain&,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);

        META_Node(osgTerrain, Terrain);

        virtual void traverse(osg::NodeVisitor& nv);

        virtual osgTerrain::Terrain* asTerrain() { return this; }
        virtual const osgTerrain::Terrain* asTerrain() const { return this; }


        void setSampleRatio(float ratio);

        float getSampleRatio() const { return _sampleRatio; }


        void setVerticalScale(float scale);

        float getVerticalScale() const { return _verticalScale; }


        void setBlendingPolicy(TerrainTile::BlendingPolicy policy);

        TerrainTile::BlendingPolicy getBlendingPolicy() const { return _blendingPolicy; }

        void setEqualizeBoundaries(bool equalizeBoundaries);

        bool getEqualizeBoundaries() const { return _equalizeBoundaries; }


        void setGeometryPool(GeometryPool* gp) { _geometryPool = gp; }

        GeometryPool* getGeometryPool() { return _geometryPool.get(); }

        const GeometryPool* getGeometryPool() const { return _geometryPool.get(); }



        TerrainTile* getTile(const TileID& tileID);

        const TerrainTile* getTile(const TileID& tileID) const;

        void setTerrainTechniquePrototype(TerrainTechnique* technique) { _terrainTechnique = technique; }

        TerrainTechnique* getTerrainTechniquePrototype() { return _terrainTechnique.get(); }

        const TerrainTechnique* getTerrainTechniquePrototype() const { return _terrainTechnique.get(); }

        void updateTerrainTileOnNextFrame(TerrainTile* terrainTile);

    protected:

        virtual ~Terrain();

        friend class TerrainTile;

        void dirtyRegisteredTiles(int dirtyMask = TerrainTile::ALL_DIRTY);

        void registerTerrainTile(TerrainTile* tile);
        void unregisterTerrainTile(TerrainTile* tile);

        typedef std::map< TileID, TerrainTile* >    TerrainTileMap;
        typedef std::set< TerrainTile* >            TerrainTileSet;

        float                               _sampleRatio;
        float                               _verticalScale;
        TerrainTile::BlendingPolicy         _blendingPolicy;
        bool                                _equalizeBoundaries;
        osg::ref_ptr<GeometryPool>          _geometryPool;

        mutable OpenThreads::ReentrantMutex _mutex;
        TerrainTileSet                      _terrainTileSet;
        TerrainTileMap                      _terrainTileMap;
        TerrainTileSet                      _updateTerrainTileSet;

        osg::ref_ptr<TerrainTechnique>      _terrainTechnique;
};

}

#endif