/home/cube/sources/osgearth/src/osgEarth/TerrainOptions

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_TERRAIN_OPTIONS_H
#define OSGEARTH_TERRAIN_OPTIONS_H 1

#include <osgEarth/Common>
#include <osgEarth/Config>
#include <osgEarth/HeightFieldUtils>

namespace osgEarth
{
    class OSGEARTH_EXPORT LoadingPolicy
    {
    public:
        enum Mode {
            MODE_SERIAL,

            MODE_PARALLEL,

            MODE_SEQUENTIAL,

            MODE_PREEMPTIVE,

            MODE_STANDARD = MODE_SERIAL
        };

    public:
        LoadingPolicy( const Config& conf =Config() );
        LoadingPolicy( const Mode& mode );

    public: // Configrable
        virtual Config getConfig() const;
        virtual void fromConfig( const Config& conf );

    public:
        optional<Mode>& mode() { return _mode; }
        const optional<Mode>& mode() const { return _mode; }

        optional<float>& numLoadingThreadsPerCore() { return _numLoadingThreadsPerCore; }
        const optional<float>& numLoadingThreadsPerCore() const { return _numLoadingThreadsPerCore; }

        const optional<int>& numLoadingThreads() const { return _numLoadingThreads; }
        optional<int>& numLoadingThreads() { return _numLoadingThreads; }

        const optional<int>& numCompileThreads() const { return _numCompileThreads; }
        optional<int>& numCompileThreads() { return _numCompileThreads; }

        const optional<float>& numCompileThreadsPerCore() const { return _numCompileThreadsPerCore; }
        optional<float>& numCompileThreadsPerCore() { return _numCompileThreadsPerCore; }

    protected:
        optional<Mode> _mode;
        optional<int>   _numLoadingThreads;
        optional<float> _numLoadingThreadsPerCore;
        optional<int>   _numCompileThreads;
        optional<float> _numCompileThreadsPerCore;
    };

    extern OSGEARTH_EXPORT int computeLoadingThreads(const LoadingPolicy& policy);
    
    class OSGEARTH_EXPORT TerrainOptions : public DriverConfigOptions
    {
    public:
        TerrainOptions( const ConfigOptions& options =ConfigOptions() );
       
        optional<float>& verticalScale() { return _verticalScale; }
        const optional<float>& verticalScale() const { return _verticalScale; }

        optional<float>& heightFieldSampleRatio() { return _heightFieldSampleRatio; }
        const optional<float>& heightFieldSampleRatio() const { return _heightFieldSampleRatio; }

        optional<float>& minTileRangeFactor() { return _minTileRangeFactor; }
        const optional<float>& minTileRangeFactor() const { return _minTileRangeFactor; }

        optional<bool>& normalizeEdges() { return _normalizeEdges; }
        const optional<bool>& normalizeEdges() const { return _normalizeEdges; }

        optional<bool>& combineLayers() { return _combineLayers; }
        const optional<bool>& combineLayers() const { return _combineLayers; }

        optional<LoadingPolicy>& loadingPolicy() { return _loadingPolicy; }
        const optional<LoadingPolicy>& loadingPolicy() const { return _loadingPolicy; }

        optional<float>& attenuationDistance() { return _attenuationDistance; }
        const optional<float>& attentuationDistance() const { return _attenuationDistance; }

        optional<float>& lodTransitionTime() { return _lodTransitionTimeSeconds; }
        const optional<float>& lodTransitionTime() const { return _lodTransitionTimeSeconds; }

        enum CompositingTechnique
        {
            COMPOSITING_AUTO,
            COMPOSITING_TEXTURE_ARRAY,
            COMPOSITING_MULTITEXTURE_GPU,
            COMPOSITING_MULTITEXTURE_FFP,
            COMPOSITING_MULTIPASS
        };

        optional<CompositingTechnique>& compositingTechnique() { return _compositingTech; }
        const optional<CompositingTechnique>& compositingTechnique() const { return _compositingTech; }

        optional<int>& maxLOD() { return _maxLOD; }
        const optional<int>& maxLOD() const { return _maxLOD; }

        optional<bool>& enableLighting() { return _enableLighting; }
        const optional<bool>& enableLighting() const { return _enableLighting; }  
    
        optional<ElevationInterpolation>& elevationInterpolation(void) { return _elevationInterpolation; }
        const optional<ElevationInterpolation>& elevationInterpolation(void) const { return _elevationInterpolation;}

        optional<bool>& enableMipmapping() { return _enableMipmapping; }
        const optional<bool>& enableMipmapping() const { return _enableMipmapping; }
   
    public:
        virtual Config getConfig() const;

    protected:
        virtual void mergeConfig( const Config& conf ) {
            DriverConfigOptions::mergeConfig( conf );
            fromConfig( conf );
        }

    private:
        void fromConfig( const Config& conf );
            
        optional<float> _verticalScale;
        optional<float> _heightFieldSampleRatio;
        optional<float> _minTileRangeFactor;
        optional<bool> _normalizeEdges;
        optional<bool> _combineLayers;
        optional<LoadingPolicy> _loadingPolicy;
        optional<CompositingTechnique> _compositingTech;
        optional<int> _maxLOD;
        optional<bool> _enableLighting;
        optional<float> _attenuationDistance;
        optional<bool> _lodBlending;
        optional<float> _lodTransitionTimeSeconds;
        optional<bool>  _enableMipmapping;
#if 0
        optional<osg::Texture::FilterMode> _contourMagFilter;
        optional<osg::Texture::FilterMode> _contourMinFilter;
#endif
        optional<ElevationInterpolation> _elevationInterpolation;
    };
}

#endif // OSGEARTH_MAP_ENGINE_PROPERTIES_H