DtCDBModelOptions.h

Go to the documentation of this file.

/******************************************************************************
** Copyright(c) 2025 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;
            }

            // Can be set from the GUI or the API (this will overwrite the earth file
            // value)
            void setRenderingMethod(const std::string& method)
            {
               myRenderingMethod = method;
            }

            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;
            }

            optional<bool>& getEnableCache()
            {
               return myEnableCache;
            }

            const optional<bool>& getEnableCache() const
            {
               return myEnableCache;
            }

            optional<bool>& getEnableIntersections()
            {
               return myEnableIntersections;
            }

            const optional<bool>& getEnableIntersections() const
            {
               return myEnableIntersections;
            }

            optional<float>& getModelScaling()
            {
               return myModelScaling;
            }

            const optional<float>& getModelScaling() const
            {
               return myModelScaling;
            }

            optional<std::string>& getMsFile()
            {
               return myMsFile;
            }

            const optional<std::string>& getMsFile() const
            {
               return myMsFile;
            }

            void setMsFile(const std::string& MsFile)
            {
               myMsFile = MsFile;
            }

            optional<std::string>& getMsColorFile()
            {
               return myMsColorFile;
            }

            const optional<std::string>& getMsColorFile() const
            {
               return myMsColorFile;
            }

            void setMsColorFile(const std::string& MsColorFile)
            {
               myMsColorFile = MsColorFile;
            }

            optional<std::string>& getName()
            {
               return myName;
            }

            const optional<std::string>& getName() const
            {
               return myName;
            }
         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),
               myEnableCache(true),
               myEnableIntersections(true),
               myModelScaling(1.0),
               myName("")
            {
               setDriver("cdb");
               fromConfig(_conf);
            }

            virtual ~CDBModelOptions() { }

         public:

            Config getConfig() const
            {
               Config conf = ModelSourceOptions::getConfig();
               conf.set("range_factor", myRangeFactor);
               conf.set("cdb_root", myCdbRootDir);
               conf.set("debug", myDebug);
               conf.set("debug_modelcolor", myDebugModelColor);
               conf.set("cdb_dataset", myCdbDataset);
               conf.set("cdb_component_selector1", myCdbComponentSelector1);
               conf.set("cdb_component_selector2", myCdbComponentSelector2);
               conf.set("rendering_method", myRenderingMethod);
               conf.set("node_caching", myNodeCaching);
               conf.set("use_reverse_depth", myUseReverseZBuffer);
               conf.set("cacheid", myCacheId);
               conf.set("sigsize_file", mySigSizeFile);
               conf.set("pagingdistance_file", myPagingDistanceFile);
               conf.set("lightdefaultvalues_file", myLightDefaultValuesFile);
               conf.set("speedtree_catalog", myGTSpeedTreeFile);
               conf.set("elevation_cache", myElevationCache);
               conf.set("texture_mipmap_offset", myTextureMipMapOffet);
               conf.set("speedtree_enabled", mySpeedtreeForVRF);
               conf.set("enable_cache", myEnableCache);
               conf.set("enable_intersections", myEnableIntersections);
               conf.set("model_scaling", myModelScaling);
               conf.set("msfile", myMsFile);
               conf.set("mscolorfile", myMsColorFile);
               conf.set("name", myName);
               return conf;
            }

         protected:

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

         private:

            void fromConfig(const Config& conf) {
               conf.get("range_factor", myRangeFactor);
               conf.get("cdb_root", myCdbRootDir);
               conf.get("debug", myDebug);
               conf.get("debug_modelcolor", myDebugModelColor);
               conf.get("cdb_dataset", myCdbDataset);
               conf.get("cdb_component_selector1", myCdbComponentSelector1);
               conf.get("cdb_component_selector2", myCdbComponentSelector2);
               conf.get("rendering_method", myRenderingMethod);
               conf.get("node_caching", myNodeCaching);
               conf.get("use_reverse_depth", myUseReverseZBuffer);
               conf.get("cacheid", myCacheId);
               conf.get("sigsize_file", mySigSizeFile);
               conf.get("pagingdistance_file", myPagingDistanceFile);
               conf.get("lightdefaultvalues_file", myLightDefaultValuesFile);
               conf.get("speedtree_catalog", myGTSpeedTreeFile);
               conf.get("elevation_cache", myElevationCache);
               conf.get("texture_mipmap_offset", myTextureMipMapOffet);
               conf.get("speedtree_enabled", mySpeedtreeForVRF);
               conf.get("enable_cache", myEnableCache);
               conf.get("enable_intersections", myEnableIntersections);
               conf.get("model_scaling", myModelScaling);
               conf.get("msfile", myMsFile);
               conf.get("mscolorfile", myMsColorFile);
               conf.get("name", myName);
            }

            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;
            optional<bool>          myEnableCache;
            optional<bool>          myEnableIntersections;
            optional<float>         myModelScaling;
            optional<std::string>   myMsFile;
            optional<std::string>   myMsColorFile;
            optional<std::string>   myName;

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