DtOsgTerrainPatchObject.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>
#include <vrvOsg/DtOsgTerrainOverlayManager.h>
#include <vrvOsg/DtFastGroup.h>
#include <vrvOsg/DtTextureVisitor.h>
#include <vrvOsg/DtLightPointVisitor.h>
#include <vrvOsg/DtOsgEarthFeatureDataBroker.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <vrvCore/DtMetaFileManager.h>
#include <vrvCore/DtTerrainPatchObject.h>
#include <vrvCore/DtDynamicTerrainWorld.h>

#include <vector>
#include <unordered_map>

namespace osgEarth
{
   class Map;
   class MapNode;
   class Wind;
   class BingImageLayer;

   namespace Util
   {
      class ElevationQuery;
   }
}

namespace makVrv
{
   class DtCoordinateSystem;
   class DtDe;
   class DtTerrainPatchGroup;
   class DtOsgNodesExtractor;
   class DtOsgLightPointManager;
   class DtPagedTilesIndirectManager;

   class DT_DLL_VRVOSG DtOsgTerrainPatchObject : public DtTerrainPatchObject
   {
   public:
      enum AlphaToCoverageState
      {
         USE_GLOBAL, // use the global setting
         FORCE_OFF, // force alpha to coverage off
         FORCE_ON //force alpha to coverage on for this model
      };

   public:
      DtOsgTerrainPatchObject(DtDe& de, DtUniqueID elementId);

      virtual ~DtOsgTerrainPatchObject();

      //

      virtual void setTerrainDefinition(const std::string& modelDefinitionName);

      virtual void slot_atcGlobalTerrainEnableChanged();

      virtual void slot_terrainInstancesReadyToRender(const DtPagedTilesIndirectManager& pagedTilesIndirectManager);

      virtual void enableOverlay(int type, const std::string& definition);

      virtual void disableOverlay(int type);

      virtual void disableAllOverlays();

      virtual void setOverlayScale(int type, double x, double y);

      virtual void setWrapMode(int type, int);

      virtual void setBlendMode(int type, int);

      virtual void setOverlayOffset(int type, double x, double y);

      virtual void setLayerEnabled(const std::string& rule, bool status);

      virtual void setRasterLayerPosition(int type, int pos);

      virtual void setIsMinimapOnly(bool isForMinimap);
      virtual bool isMinimapOnly() const;
      
      virtual void setIsPageable(bool isPageable);
      virtual bool isPageable() const;

      virtual void setPageableCenterPosition(const DtVector& pageableCenter);
      virtual DtVector pageableCenterPosition() const;

      virtual void setPageableRadius(double radius);
      virtual double pageableRadius() const;
      
      virtual void setPageOutDistance(double pageOutDistance);
      virtual double pageOutDistance() const;
      

      virtual std::string overlayDefinition(int type);

      virtual std::vector<double> overlayScale(int type);
      virtual std::vector<double> overlayOffset(int type);
      virtual DtTerrainOverlayOperation defaultOverlay(int type);
      virtual DtTerrainOverlayOperation currentOverlay(int type);

      virtual void getBoundingBoxMinMax(DtVector& min, DtVector& max) const;

      virtual void getTerrainExtents(DtVector& nw, DtVector& ne, DtVector& sw, DtVector& se) const;

      virtual DtVector getDatabaseOrigin() const;

      virtual void getBoundingBoxCenter(float& x, float& y, float& z) const;

      //Get the terrain group node.
      osg::Group* terrainGroupNode();

      virtual void extractNodes(const std::string& ruleset, bool isRegEx) override;

      virtual void extractOceanNodes(const std::string& ruleset, bool isRegEx) override;

      virtual void extractSpeedTreeNodes(const std::string& rule, bool isRegEx, const std::string& modelDefinition) override;

      virtual void realizeExtractedSpeedTrees(const DtVectorTreeRecords& trees);

      virtual bool haveExtractedOcean() const;

      virtual bool canExtractOceanInIndirect(void) const;

      virtual int countNodes(const std::string& rule) const;

      virtual bool getExtractedNodePosition(const std::string& rule,
         unsigned int index, double& x, double& y, double& z) const;

      virtual bool getExtractedNodeOrientation(const std::string& rule,
         unsigned int index, double& x, double& y, double& z, double& w) const;

      virtual void moveNode(DtSceneObject* object,
         DtModel* model, const std::string& rule, unsigned int index);

      virtual osg::Node* findNode(const std::string& rule, unsigned int index);

      virtual bool isGlobalScaleTerrain() const;

      virtual bool getTerrainIntersection(double x, double y, double z,
         double vx, double vy, double vz, double& retX, double& retY, double& retZ);

      virtual void clearElevationCache();

      bool isOsgEarth() const;

      osgEarth::MapNode *mapNode();
      const osgEarth::MapNode *mapNode() const;

      void installOsgEarthFeatureDataCallback(const std::string& featureName,
         DtOsgEarthFeatureDataBroker::Callback* callback);

      virtual const DtTextureVisitor::TextureMap& foundTextures() const;

      virtual void setOsgEarthMaterialValues(float ambient, float diffuse,
         float specular, float shininess);
      virtual void getOsgEarthMaterialValues(float& ambient, float& diffuse,
         float& specular, float& shininess);

      DtMetaFileManager::LinkageValueVec& terrainPatchMetaFileFeatures();

      std::vector<DtVirtualBaseClass*>& terrainAttachments();

      virtual void setTerrainTreeScaleRandomization(bool isRandomized);

      virtual bool isTerrainTreeScaleRandomizationEnabled() const;

      virtual void setTerrainTreeMinScale(double minScale);

      virtual double terrainTreeMinScale() const;

      virtual void setTerrainTreeMaxScale(double maxScale);

      virtual double terrainTreeMaxScale() const;

      virtual void setTerrainTreeOrientationRandomization(bool isRandomized);

      virtual bool isTerrainTreeOrientationRandomizationEnabled() const;

      bool isDestructing();

      virtual void useICO(bool enable);

      virtual void setMaxPagedLODs(unsigned int maxPagedLODs);

      virtual void updateMaxPagedLODs();

      virtual void slot_channelCreated();

      virtual void slot_windowCreated();
      

      virtual void slot_channelToBeDestroyed();

      virtual bool alphaToCoverageEnabled();

      virtual void postExtractionProcessing();

      virtual bool indirectEnabled();

      virtual void toggleVisibility(bool visibility);

      static void authorizeBingImageryLayer(osgEarth::BingImageLayer* bingImageLayer, bool openLayer = true);

      virtual DtOsgEarthFeatureDataBroker* getOsgEarthFeatureDataBroker();

      virtual bool isMetaFlight(void) const;

   private:
      DtOsgTerrainPatchObject(const DtOsgTerrainPatchObject&);
      DtOsgTerrainPatchObject& operator=(const DtOsgTerrainPatchObject&);

   protected:

      void removeChildNodesAndCache();

      void clearStateGraphForAllChannels(void);

      static void graphBoundingBox(const osg::Node* node, osg::BoundingBox &bbox);

      //Remove the node from it's parent, and if the parent has no other
      //Children remove it from it's parent too recursively.
      void removeEmptyParent(osg::Node* node);
      void updateBounds();

      // Update myPageableCenterPosition + myPageableRadius + myPageOutDistance, if needed, based on the provided node.
      virtual void updatePageablePropertiesBasedOnNode(osg::Node* node);

      virtual bool getElevation(double lonRadians, double latRadians,
         double& retElevation);

      virtual void slot_perPixelLightingChanged(bool newVal);
      virtual void slot_usePixelShaderForOsgEarthModelsChanged();
      virtual void slot_postUpdate();
      virtual void setOsgEarthMaterial(float ambient, float diffuse,
         float specular, float shininess);
      virtual void setOsgEarthMaterialOnNode(osg::Node& node, float ambient, float diffuse,
         float specular, float shininess);
      virtual void setOsgEarthMaterialOnStateSet(osg::StateSet& ss, float ambient, float diffuse,
         float specular, float shininess);

      virtual void slot_terrainPaged();

      //         demand if necessary.
      osgEarth::Util::ElevationQuery* getOrCreateElevationQuery();

      // Installs a data broker and feature data processing callbacks.
      void installOsgEarthFeatureDataProcessors();

      // Sets up the osgEarth GeometryCompiler with custom defaults.
      virtual void configureOsgEarthFeatureGeometryCompiler();

      virtual void setupMapNodeIntersectFlag();

      virtual void setGlobalWindSpeed(float metersPerSecond);

      virtual void setGlobalWindDirection(float radians);

      virtual void setupMapNode(void);

      virtual void setupOsgEarthBlendingForHbao(osgEarth::Map* map);

      virtual void setupOsgEarthLayersForHeightmapRendering(osgEarth::Map* map);

      virtual void setupNonMapNode(osg::ref_ptr<osg::Node> node);

      virtual void slot_coordinateSystemChanged();

      virtual void extractNodesExecute(osg::Node* node, const std::string& ruleset, bool isRegEx);

      virtual void extractOceanNodesExecute(osg::Node* node, const std::string& ruleset, bool isRegEx);

      virtual void extractSpeedTreeNodesExecute(osg::Node* node, const std::string& rule, bool isRegEx, const std::string& modelDefinition);

      virtual void postExtractionProcessingExecute(void);

      virtual void parseDynamicTerrain(void);

      virtual void executeExtractionOperationsDeferred(osg::Node* node);

      virtual void setupOsgEarthTextureLimits();

   protected:
      osg::ref_ptr<DtTerrainPatchGroup> myRoot;

      osg::ref_ptr<DtFastGroup> myTerrainGroup;

      osg::ref_ptr<osgEarth::MapNode> myMapNode;

      DtOsgTerrainOverlayManager myOverlayManager;
      DtTextureVisitor::TextureMap myFoundTextureMap;

      bool myGlobalFlag;
      bool myHaveExtractedOcean;
      bool myPerPixelLightingChanged;
      volatile bool myTerrainPagedThisFrame;
      bool myPendingPerPixelLightingValue;
      bool myOsgEarthMaterialChanged;
      float myPendingOsgEarthMaterialAmbient;
      float myPendingOsgEarthMaterialDiffuse;
      float myPendingOsgEarthMaterialSpecular;
      float myPendingOsgEarthMaterialShininess;
      DtSignalConnectionManager myConnections;

      // List of node pointers that have meta data associated with them
      DtMetaFileManager::LinkageValueVec myTerrainPatchMetaFileFeatures;
      // Vector of node with .meta file info associated with them 
      // on this terrain so they can be deleted on page destruction
      std::vector<DtVirtualBaseClass*> myTerrainAttachments;

      osgEarth::Util::ElevationQuery* myElevationQuery;

      osg::ref_ptr<DtOsgEarthFeatureDataBroker> myOsgEarthFeatureDataBroker;

      bool myTerrainTreeScaleRandomizationEnabled;
      float myTerrainTreeMinScale;
      float myTerrainTreeMaxScale;
      bool myTerrainTreeOrientationRandomizationEnabled;

      bool myDestructing;

      DtOsgNodesExtractor* myExtractedNodesLogic;

      friend class DtOsgNodesExtractor;

      DtDynamicTerrainWorld::FeatureHandle myDynamicTerrainHandle;

      AlphaToCoverageState myAlphaToCoverageState;

      bool myIndirectEnabled;

      unsigned int myMaxPagedLods;

      DtOsgLightPointManager& myLightPointManager;

      friend class DtPagedTilesIndirectManager;
      DtPagedTilesIndirectManager* myPagedTilesIndirectManager;

      boost::signalslib::connection myPagedTilesIndirectManagerConnection;

      typedef osg::ref_ptr<osg::Node> RefNode;
      std::vector<RefNode> myIndirectedNodes;
      std::string myActualFilename;

      // This is used to implement global wind effects on procedural terrain patches
      osg::ref_ptr<osgEarth::Wind> myGlobalWind;

      bool myIsMinimapOnly;

      bool myIsPageable;
      DtVector myPageableCenterPosition;
      double myPageableRadius;
      double myPageOutDistance;

      DtCoordinateSystem* myCoordinateSystem = nullptr;

      const osg::Node* myMetaflightGroupNode = nullptr;

      osg::Node* myPagedLod = nullptr;

      std::unordered_map<std::string, bool> myExtractNodesOps;

      struct ExtractSpeedTreeOp
      {
         const std::string myRule;
         const bool myIsRegEx;
         const std::string myModelDefinition;
      };
      std::vector<ExtractSpeedTreeOp> myExtractSpeedTreeOps;

      std::unordered_map<std::string, bool> myExtractOceanNodesOps;
   };
}