DtHeightMapManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvOsg/DtDrawFBOCallback.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtVirtualBaseClass.h>

#include <osg/Camera>
#include <osg/View>
#include <osg/Drawable>
#include <osg/Texture2D>

namespace makVrv
{
   // forward declarations
   class DtDe;
   class DtHeightMapManager;
   class DtTerrainPatchObject;
   class DtCoordinateSystem;


   struct DT_DLL_VRVOSG DtDrawableCullHeightMapCallback : public osg::Callback
   {
   public:
      DtDrawableCullHeightMapCallback(osg::View* view);;
      
   protected:
      virtual ~DtDrawableCullHeightMapCallback();

   private:
      DtDrawableCullHeightMapCallback() = delete;
      DtDrawableCullHeightMapCallback(const DtDrawableCullHeightMapCallback &other) = delete;
      DtDrawableCullHeightMapCallback &operator=(const DtDrawableCullHeightMapCallback &other) = delete;

   public:
      virtual bool run(osg::Object* object, osg::Object* data);

   protected:
      //Doesn't need to be a ref pointer since it is never accessed. Only used to compare to another pointer.
      osg::View* myView;
   };

   struct DT_DLL_VRVOSG DtHeightMapPostDrawFBOCallback : public PostDrawFBOCallback
   {
   public:
      DtHeightMapPostDrawFBOCallback(DtHeightMapManager* heightMapManager, DtDe& de);

   protected:
      virtual ~DtHeightMapPostDrawFBOCallback();

   private:
      DtHeightMapPostDrawFBOCallback() = delete;
      DtHeightMapPostDrawFBOCallback(const DtHeightMapPostDrawFBOCallback &other) = delete;
      DtHeightMapPostDrawFBOCallback &operator=(const DtHeightMapPostDrawFBOCallback &other) = delete;
   
   public:
      virtual void operator () (osg::RenderInfo& renderInfo) const;

   protected:
      DtHeightMapManager* myHeightMapManager;
      DtDe& myDe;
   };



   class DT_DLL_VRVOSG DtHeightMapManager
   {
   public:
      virtual ~DtHeightMapManager();

   protected:
      //friend so that it and only it can create the DtHeightMapManagers
      friend class DtHeightMapManagerCreator;
      
      DtHeightMapManager(DtDe& de, osg::View* view);

   private:
      DtHeightMapManager() = delete;
      DtHeightMapManager(const DtHeightMapManager &other) = delete;
      DtHeightMapManager &operator=(const DtHeightMapManager &other) = delete;

   public:

      virtual void setupHeightMap( void );

      virtual void setHeightMapResolution(float resolution);

      virtual float heightMapResolution() const;

      virtual void setHeightMapTextureSize(int pixels);

      virtual int heightMapTextureSize() const;

      virtual bool updateHeightCamera(unsigned int frameNum,
         const osg::Vec3d& currentPosition, bool isGeocentric );

      virtual void setHeightCameraAttachment(bool enabled);

      virtual bool heightCameraAttached() const;

      virtual const osg::Matrix& heightMapMatrix() const;

      virtual const osg::ref_ptr<osg::Texture2D> heightMapTexture() const;

      virtual void slot_terrainDataChanged(DtTerrainPatchObject& tpo);

      virtual void slot_wireframeModeChanged();

      virtual void slot_coordinateSystemChanged();

      virtual osg::Camera* heightCamera();

      virtual void syncHeightMapToGpu(const osg::State* state, const osg::Camera* camera);

      virtual void postDrawFBOCallback(osg::RenderInfo& renderInfo);

   protected:
      virtual void cleanup();

      virtual void updateHeightMapMatrix();

      virtual osg::Matrixd oglRevDepthOrtho(double left, double right,
         double bottom, double top,
         double zNear, double zFar);

      virtual void computeBasis(const osg::Vec3d& inGeocentricPos, osg::Matrixd& rotOut);

   protected:

      osg::Vec3d myLastHeightReferencePos;
      osg::Matrixd myHeightReferenceBasis;
      osg::Vec3d myLastHeightUpdatePos;
      unsigned int myHeightUpdateFrame;
      bool myHeightCameraAttached;
      bool myHeightMapCameraUpdateReady;
      bool myForceUpdate;
      float myResolution;
      bool mySavedPerfOverlayOn;
      double myLastUpdateTime;

      bool myShadingRateIsSupported; // true if shading rate extension is supported

      osg::ref_ptr<osg::Texture2D> myHeightMap;
      osg::ref_ptr<osg::Texture2D> myDepthTexture;
      osg::Matrix myHeightMapMatrix;
      int myHeightMapDimension;
      osg::ref_ptr<osg::Camera> myHeightCamera;

      DtDe& myDe;

      DtSignalConnectionManager myConnections;

      //Doesn't need to be a ref pointer since it is never accessed. Only used to compare to another pointer.
      osg::View* myOsgView;

      DtCoordinateSystem* myCoordinateSystem = nullptr;

   };



   class DT_DLL_VRVOSG DtHeightMapManagerCreator : public DtVirtualBaseClass
   {
   protected:
      DtHeightMapManagerCreator();

      virtual ~DtHeightMapManagerCreator();

   private:
      DtHeightMapManagerCreator(const DtHeightMapManagerCreator &other) = delete;
      DtHeightMapManagerCreator &operator=(const DtHeightMapManagerCreator &other) = delete;

   public:
      static DtHeightMapManagerCreator& instance(DtDe& de);

      static void registerInstance(DtDe& de,
         DtHeightMapManagerCreator* instance);

   public:
      virtual DtHeightMapManager* create(DtDe& de, osg::View* view);
   };



   class DT_DLL_VRVOSG DtHeightMapManagerSignaler : public DtVirtualBaseClass
   {
   public:

      static DtHeightMapManagerSignaler& instance(DtDe&);

      virtual ~DtHeightMapManagerSignaler();

   private:
      DtHeightMapManagerSignaler(const DtHeightMapManagerSignaler &other) = delete;

      DtHeightMapManagerSignaler &operator=(const DtHeightMapManagerSignaler &other) = delete;

   public:
      boost::signalslib::signal<void(DtHeightMapManager& manager)> signal_heightMapChanged;

      boost::signalslib::signal<void()> signal_cameraChanged;

      boost::signalslib::signal<void(DtHeightMapManager& manager, const osg::State* state, const osg::Camera* camera)> signal_syncHeightMapToGpu;
 
   protected:

      DtHeightMapManagerSignaler();
   };
}