DtCDBModelOptions.h

Go to the documentation of this file.

/******************************************************************************
** Copyright(c) 2016 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/

#pragma once


#include <osgEarth/Common>
#include <osgEarth/ModelSource>
#include <osgEarth/URI>
#include <osgEarth/ShaderUtils>

namespace makVrv { namespace oe { namespace CDB
{
    using namespace osgEarth;

    class CDBModelOptions : public ModelSourceOptions // NO EXPORT; header only
    {
    public:

        optional<float>& getRangeFactor()                   { return myRangeFactor; }

        const optional<float>& getRangeFactor() const       { return myRangeFactor; }

        optional<std::string>& getCdbRootDir()              { return myCdbRootDir; }

        const optional<std::string>& getCdbRootDir() const  { return myCdbRootDir; }

        void setCdbRootDir(const std::string& CdbRootDir) { myCdbRootDir = CdbRootDir; }

        optional<bool>& getDebug()                          { return myDebug; }

        const optional<bool>& getDebug() const              { return myDebug; }

        optional<bool>& getDebugModelColor()               { return myDebugModelColor; }

        const optional<bool>& getDebugModelColor() const   { return myDebugModelColor; }

        optional<int>& getCdbDataset()                      { return myCdbDataset; }

        const optional<int>& getCdbDataset() const          { return myCdbDataset; }

        optional<int>& getCdbComponentSelector1()           { return myCdbComponentSelector1; }

        const optional<int>& getCdbComponentSelector1() const   { return myCdbComponentSelector1; }

        optional<int>& getCdbComponentSelector2()               { return myCdbComponentSelector2; }

        const optional<int>& getCdbComponentSelector2() const   { return myCdbComponentSelector2; }

        optional<std::string>& getRenderingMethod()            { return myRenderingMethod; }

        const optional<std::string>& getRenderingMethod() const { return myRenderingMethod; }

        optional<bool>& getNodeCaching()                        { return myNodeCaching; }

        const optional<bool>& getNodeCaching() const            { return myNodeCaching; }

        optional<bool>& getUseReverseDepthBuffer() { return myUseReverseZBuffer; }

        const optional<bool>& getUseReverseDepthBuffer() const { return myUseReverseZBuffer; }

        optional<std::string>& getCacheId()                     { return myCacheId; }

        const optional<std::string>& getCacheId() const         { return myCacheId; }

        optional<std::string>& getSigSizeFile()                 { return mySigSizeFile; }

        const optional<std::string>& getSigSizeFile() const     { return mySigSizeFile; }

        optional<std::string>& getPagingDistanceFile()                 { return myPagingDistanceFile; }

        const optional<std::string>& getPagingDistanceFile() const     { return myPagingDistanceFile; }

        optional<std::string>& getLightDefaultValuesFile()                 { return myLightDefaultValuesFile; }

        const optional<std::string>& getLightDefaultValuesFile() const     { return myLightDefaultValuesFile; }

        optional<std::string>& getGTSpeedTreeFile()                 { return myGTSpeedTreeFile; }

        const optional<std::string>& getGTSpeedTreeFile() const     { return myGTSpeedTreeFile; }

        optional<bool>& getElevationCache()                         { return myElevationCache; }

        const optional<bool>& getElevationCache() const             { return myElevationCache; }

        optional<int>& getTextureMipMapOffet()                      { return myTextureMipMapOffet; }

        const optional<int>& getTextureMipMapOffet() const          { return myTextureMipMapOffet; }

        optional<bool>& getSpeedtreeVRF() { return mySpeedtreeForVRF; }

        const optional<bool>& getSpeedtreeVRF() const { return mySpeedtreeForVRF; }

    public:

        CDBModelOptions(const ConfigOptions& options = ConfigOptions()) : 
            ModelSourceOptions(options),
            myRangeFactor(1.0),
            myDebug(false),
            myDebugModelColor(false),
            myCdbDataset(0),
            myCdbComponentSelector1(0),
            myCdbComponentSelector2(0),            
            myRenderingMethod("INDIRECT_RENDERING"),
            myNodeCaching(false),
            myCacheId(""),
            mySigSizeFile(""),
            myPagingDistanceFile(""),
            myLightDefaultValuesFile(""),
            myGTSpeedTreeFile(""),
            myUseReverseZBuffer(false),
            myElevationCache(true),
            myTextureMipMapOffet(0),
            mySpeedtreeForVRF(false)
        {
            setDriver("cdb");
            fromConfig(_conf);
        }

        virtual ~CDBModelOptions() { }

    public:

       Config getConfig() const 
       {
            Config conf = ModelSourceOptions::getConfig();
            conf.updateIfSet("range_factor",            myRangeFactor);
            conf.updateIfSet("cdb_root",                myCdbRootDir);
            conf.updateIfSet("debug",                   myDebug);
            conf.updateIfSet("debug_modelcolor",        myDebugModelColor);
            conf.updateIfSet("cdb_dataset",             myCdbDataset);
            conf.updateIfSet("cdb_component_selector1", myCdbComponentSelector1);
            conf.updateIfSet("cdb_component_selector2", myCdbComponentSelector2);
            conf.updateIfSet("rendering_method",        myRenderingMethod);
            conf.updateIfSet("node_caching",            myNodeCaching);
            conf.updateIfSet("use_reverse_depth",       myUseReverseZBuffer);
            conf.updateIfSet("cacheid",                 myCacheId);
            conf.updateIfSet("sigsize_file",            mySigSizeFile);
            conf.updateIfSet("pagingdistance_file",     myPagingDistanceFile);
            conf.updateIfSet("lightdefaultvalues_file", myLightDefaultValuesFile);
            conf.updateIfSet("speedtree_catalog",       myGTSpeedTreeFile);
            conf.updateIfSet("elevation_cache",         myElevationCache);
            conf.updateIfSet("texture_mipmap_offset",   myTextureMipMapOffet);
            conf.updateIfSet("speedtree_enabled",       mySpeedtreeForVRF);
            return conf;
        }

    protected:

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

    private:

        void fromConfig(const Config& conf) {
            conf.getIfSet("range_factor",            myRangeFactor);
            conf.getIfSet("cdb_root",                myCdbRootDir);
            conf.getIfSet("debug",                   myDebug);
            conf.getIfSet("debug_modelcolor",        myDebugModelColor);
            conf.getIfSet("cdb_dataset",             myCdbDataset);
            conf.getIfSet("cdb_component_selector1", myCdbComponentSelector1);
            conf.getIfSet("cdb_component_selector2", myCdbComponentSelector2);
            conf.getIfSet("rendering_method",        myRenderingMethod);
            conf.getIfSet("node_caching",            myNodeCaching);
            conf.getIfSet("use_reverse_depth",       myUseReverseZBuffer);
            conf.getIfSet("cacheid",                 myCacheId);
            conf.getIfSet("sigsize_file",            mySigSizeFile);
            conf.getIfSet("pagingdistance_file",     myPagingDistanceFile);
            conf.getIfSet("lightdefaultvalues_file", myLightDefaultValuesFile);
            conf.getIfSet("speedtree_catalog",       myGTSpeedTreeFile);
            conf.getIfSet("elevation_cache",         myElevationCache);
            conf.getIfSet("texture_mipmap_offset",   myTextureMipMapOffet);
            conf.getIfSet("speedtree_enabled",       mySpeedtreeForVRF);
        }

        optional<float>         myRangeFactor;
        optional<std::string>   myCdbRootDir;
        optional<bool>          myDebug;
        optional<bool>          myDebugModelColor;
        optional<int>           myCdbDataset;
        optional<int>           myCdbComponentSelector1;
        optional<int>           myCdbComponentSelector2;
        optional<std::string>   myRenderingMethod;
        optional<bool>          myNodeCaching;
        optional<bool>          myUseReverseZBuffer;
        optional<std::string>   myCacheId;
        optional<std::string>   mySigSizeFile;              
        optional<std::string>   myPagingDistanceFile;
        optional<std::string>   myLightDefaultValuesFile;
        optional<std::string>   myGTSpeedTreeFile;
        optional<bool>          myElevationCache;
        optional<int>           myTextureMipMapOffet;
        optional<bool>          mySpeedtreeForVRF;

    };
} } } // namespace makVrv::oe::CDB