/home/cube/sources/osgearth/src/osgEarth/MapNode

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_MAPNODE_H
#define OSGEARTH_MAPNODE_H 1

#include <osgEarth/Common>
#include <osgEarth/Map>
#include <osgEarth/MapNodeOptions>
#include <osgEarth/OverlayDecorator>
#include <osgEarth/TerrainEngineNode>
#include <osg/CoordinateSystemNode>
#include <osgSim/OverlayNode>

namespace osgEarth
{
    class OSGEARTH_EXPORT MapNode : public osg::Group
    {
    public:

        class TileRangeData : public osg::Referenced
        {
        public:
            TileRangeData(double minRange, double maxRange):
              _minRange( minRange ),
              _maxRange( maxRange )
            {
            }

            double _minRange;
            double _maxRange;
        };

        MapNode();

        MapNode( const MapNodeOptions& options );

        MapNode( Map* map );

        MapNode( Map* map, const MapNodeOptions& options );

        static MapNode* load( class osg::ArgumentParser& arguments );

    public:

        virtual const char* libraryName() const { return "osgEarth"; }
        virtual const char* className() const { return "MapNode"; }

        Map* getMap();

        static MapNode* findMapNode( osg::Node* graph );   

        bool isGeocentric() const;

        osg::Group* getModelLayerGroup() const;

        void addTerrainDecorator( osg::Group* decorator );

        void removeTerrainDecorator( osg::Group* decorator );

        osg::Group* getOverlayGroup() { return _overlayModels.get(); }
        
        void updateOverlayGraph();

        const MapNodeOptions& getMapNodeOptions() const;

        TerrainEngineNode* getTerrainEngine() const;

        Config& externalConfig() { return _externalConf; }
        const Config& externalConfig() const { return _externalConf; }

    public: //override osg::Node

        virtual osg::BoundingSphere computeBound() const;

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

    protected:    

        virtual ~MapNode();

    private:

        unsigned int _id;
        osg::ref_ptr<Map> _map;
        osg::ref_ptr< osg::Group > _models;
        osg::ref_ptr< osg::Group > _overlayModels;
        osg::ref_ptr< OverlayDecorator > _overlayDecorator;
        MapNodeOptions _mapNodeOptions;
        Config _externalConf;

        // keep track of nodes created by model layers
        typedef std::map<ModelLayer*,osg::Node*> ModelLayerNodeMap;
        ModelLayerNodeMap _modelLayerNodes;
        osg::Group* _maskLayerNode;

        osg::ref_ptr< osgSim::OverlayNode > _pendingOverlayNode;
        bool _pendingOverlayAutoSetTextureUnit;

        unsigned _lastNumBlacklistedFilenames;

        osg::ref_ptr<TerrainEngineNode> _terrainEngine;
        bool _terrainEngineInitialized;

        osg::ref_ptr<osg::Group> _terrainEngineContainer;

    public: // MapCallback proxy

        void onModelLayerAdded( ModelLayer*, unsigned int );
        void onModelLayerRemoved( ModelLayer* );
                void onModelLayerMoved( ModelLayer* layer, unsigned int oldIndex, unsigned int newIndex );
#if 0
        void onMaskLayerAdded( MaskLayer* );
        void onMaskLayerRemoved( MaskLayer* );
#endif

    public:
        void onModelLayerOverlayChanged( ModelLayer* layer );

    private:

        osg::ref_ptr< ModelLayerCallback > _modelLayerCallback;
        osg::ref_ptr< MapCallback > _mapCallback;
    
        void init();
        void adjustEventTraversalCount( int delta );
    };

} // namespace osgEarth

#endif // OSGEARTH_MAPNODE_H