DtOsgTerrainPatchObject.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2020 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>


namespace osgEarth
{
   class MapNode;
   class Wind;

   namespace Util
   {
      class ElevationQuery;
   }
}

namespace makVrv
{

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

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

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

      virtual void realizeExtractedSpeedTrees(const DtVectorTreeRecords& trees);

      virtual bool haveExtractedOcean() 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);

      virtual DtOsgEarthFeatureDataBroker* getOsgEarthFeatureDataBroker();

   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();

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

      virtual void setPerPixelLightingEnabled(bool setting);

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

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

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

      DtPagedTilesIndirectManager* myPagedTilesIndirectManager;
      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;
   
   };
}