/* -*-c++-*- */
/* osgEarth - Geospatial SDK for OpenSceneGraph
* Copyright 2008-2012 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.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*
* 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 OSGEARTHUTIL_LOD_BLENDING_H
#define OSGEARTHUTIL_LOD_BLENDING_H

#include <osgEarthUtil/Common>
#include <osgEarth/TerrainEffect>
#include <osg/Uniform>
#include <osg/Node>
#include <osg/observer_ptr>

namespace osgEarth { namespace Util
{
    class LODBlendingOptions : public ConfigOptions
    {
    public:
        LODBlendingOptions( const ConfigOptions& opt =ConfigOptions() ) :
            ConfigOptions( opt ),
            _delay         ( 0.0f ),
            _duration      ( 0.25f ),
            _vscale        ( 1.0f ),
            _blendImagery  ( true ),
            _blendElevation( true )
        {
            fromConfig( _conf );
        }

    public:

        /** Sets the delay (in seconds) between the time the tile appears
            and when it starts its transition */
        optional<float>& delay() { return _delay; }
        const optional<float>& delay() const { return _delay; }

        /** Sets the duration of the transition */
        optional<float>& duration() { return _duration; }
        const optional<float>& duration() const { return _duration; }

        /** Vertical scale factor to apply to elevation */
        optional<float>& verticalScale() { return _vscale; }
        const optional<float>& verticalScale() const { return _vscale; }

        /** Whether to blend imagery (default=true) */
        optional<bool>& blendImagery() { return _blendImagery; }
        const optional<bool>& blendImagery() const { return _blendImagery; }

        /** Whether to blend elevation (default=true) */
        optional<bool>& blendElevation() { return _blendElevation; }
        const optional<bool>& blendElevation() const { return _blendElevation; }

    public:
        Config getConfig() const {
            Config conf = ConfigOptions::getConfig();
            conf.set("delay", _delay);
            conf.set("duration", _duration);
            conf.set("vertical_scale", _vscale);
            conf.set("blend_imagery", _blendImagery);
            conf.set("blend_elevation", _blendElevation);
            return conf;
        }

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

    private:
        void fromConfig( const Config& conf ) {
            conf.get("delay", _delay);
            conf.get("duration", _duration);
            conf.get("vertical_scale", _vscale);
            conf.get("blend_imagery", _blendImagery);
            conf.get("blend_elevation", _blendElevation);
        }

    private:
        optional<float> _delay;
        optional<float> _duration;
        optional<float> _vscale;
        optional<bool>  _blendImagery;
        optional<bool>  _blendElevation;

    };

    /**
     * Terrain effect that blends terrain levels of detail for a 
     * smooth transition effect. Operates on elevation data and
     * image data.
     *
     * Known limitation: LOD blending requires either (a) a fully-textured
     * terrain, by way of a base layer that completely covers the map; or
     * (b) a transparent globe color. It will not work properly with
     * untextures (but colored) terrain tiles.
     */
    class OSGEARTHUTIL_EXPORT LODBlending : public TerrainEffect,
                                            public LODBlendingOptions
    {
    public:
        /** construct a new blending effect */
        LODBlending();

        LODBlending(const LODBlendingOptions& options);

    public: // TerrainEffect interface

        void onInstall(TerrainEngineNode* engine);
        void onUninstall(TerrainEngineNode* engine);


    protected:
        virtual ~LODBlending() { }
        void init();

        osg::ref_ptr<osg::Uniform>   _delayUniform;
        osg::ref_ptr<osg::Uniform>   _durationUniform;
        osg::ref_ptr<osg::Uniform>   _vscaleUniform;
    };

} } // namespace osgEarth::Util

#endif // OSGEARTHUTIL_LOD_BLENDING_H
