/home/cube/sources/osgearth/src/osgEarth/TerrainEngineNode

Go to the documentation of this file.

/* -*-c++-*- */
/* osgEarth - Dynamic map generation toolkit for OpenSceneGraph
 * Copyright 2008-2010 Pelican Mapping
 * http://osgearth.org
 *
 * osgEarth is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>
 */
#ifndef OSGEARTH_MAP_ENGINE_NODE_H
#define OSGEARTH_MAP_ENGINE_NODE_H 1

#include <osgEarth/Map>
#include <osgEarth/ShaderUtils>
#include <osg/CoordinateSystemNode>
#include <osg/Geode>
#include <osg/NodeCallback>

namespace osgEarth
{
    class TextureCompositor;

    class OSGEARTH_EXPORT TerrainEngineNode : public osg::CoordinateSystemNode
    {
    public:
        const Map* getMap() const { return _map.get(); }

        virtual const TerrainOptions& getTerrainOptions() const =0;

        TextureCompositor* getTextureCompositor() const { return _texCompositor.get(); }

    public: // Runtime properties

        void setVerticalScale( float value );

        float getVerticalScale() const { return _verticalScale; }

        void setElevationSamplingRatio( float value );

        float getElevationSamplingRatio() const { return _elevationSamplingRatio; }

    protected:
        TerrainEngineNode();

        TerrainEngineNode( const TerrainEngineNode& rhs, const osg::CopyOp& op =osg::CopyOp::DEEP_COPY_ALL );

        virtual ~TerrainEngineNode();

    public: // osg::Node overrides
        virtual osg::BoundingSphere computeBound() const;
        virtual void traverse( osg::NodeVisitor& );

    protected: // implementation events
        virtual void onVerticalScaleChanged() { }
        virtual void onElevationSamplingRatioChanged() { }

    protected:
        friend class TerrainEngineNodeFactory;

        virtual void validateTerrainOptions( TerrainOptions& options );

    private:
        friend struct TerrainEngineNodeCallbackProxy;

        void onMapInfoEstablished( const MapInfo& mapInfo ); // not virtual!
        //void onMapProfileEstablished( const Profile* profile );
        void onMapModelChanged( const MapModelChange& change );

    protected:
        virtual void preInitialize( const Map* map, const TerrainOptions& options );
        virtual void postInitialize( const Map* map, const TerrainOptions& options );
        friend class MapNode;

        // allow subclasses direct access for convenience.
        osg::ref_ptr<TextureCompositor> _texCompositor;

    private:
        friend struct MapNodeMapLayerController;

        virtual void updateImageUniforms();

    private:
        UpdateLightingUniformsHelper _updateLightingUniformsHelper;
        float _verticalScale;
        float _elevationSamplingRatio;
        
        struct ImageLayerController : public ImageLayerCallback
        {
            ImageLayerController( const Map* map );

            void onEnabledChanged( TerrainLayer* layer );
            void onOpacityChanged( ImageLayer* layer );

            ArrayUniform _layerOpacityUniform;
            ArrayUniform _layerEnabledUniform;
            ArrayUniform _layerRangeUniform;

            //osg::ref_ptr< ArrayUniform > _layerOpacityUniform;

            //osg::ref_ptr< ArrayUniform > _layerEnabledUniform;

            //osg::ref_ptr< ArrayUniform > _layerRangeUniform;

        private:
            MapFrame _mapf;
        };

        osg::ref_ptr<ImageLayerController> _imageLayerController;
        osg::ref_ptr<const Map> _map;
        osg::ref_ptr<osg::Uniform> _startFrameTimeUniform;
        osg::ref_ptr<osg::Uniform> _cameraElevationUniform;
        
        enum InitStage {
            INIT_NONE,
            INIT_PREINIT_COMPLETE,
            INIT_POSTINIT_COMPLETE
        };
        InitStage _initStage;
    };

    class TerrainEngineNodeFactory
    {
    public:
        static TerrainEngineNode* create( Map* map, const TerrainOptions& options );
    };

    class TerrainDecorator : public osg::Group
    {
    public:
        virtual void onInstall( TerrainEngineNode* engine ) { }
        virtual void onUninstall( TerrainEngineNode* engine ) { }
    };

} // namespace osgEarth

#endif // OSGEARTH_ENGINE_OSGTERRAIN_ENGINE_NODE_H