DtTritonHeightMapManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvTriton/vrvTriton.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 Triton
{
   class Camera;
}

namespace makVrv
{
   class DtTritonDrawable;
   class DtDe;
   class DtTritonHeightMapManager;

   struct DT_DLL_VRVTRITON DtTritonDrawableCullHeightMapCallback : public osg::Callback
   {
   public:
      DtTritonDrawableCullHeightMapCallback(osg::View* view);;
      
   protected:
      virtual ~DtTritonDrawableCullHeightMapCallback();

   private:
      DtTritonDrawableCullHeightMapCallback();
      DtTritonDrawableCullHeightMapCallback(const DtTritonDrawableCullHeightMapCallback &other);
      DtTritonDrawableCullHeightMapCallback &operator=(const DtTritonDrawableCullHeightMapCallback &other);

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

   class DT_DLL_VRVTRITON DtTritonDrawableUpdateHeightMapJob : public osg::Operation
   {
   public:
      DtTritonDrawableUpdateHeightMapJob(DtTritonHeightMapManager* heightMapManager);

   protected:
      virtual ~DtTritonDrawableUpdateHeightMapJob();

   private:
      DtTritonDrawableUpdateHeightMapJob();
      DtTritonDrawableUpdateHeightMapJob(const DtTritonDrawableUpdateHeightMapJob &other);
      DtTritonDrawableUpdateHeightMapJob &operator=(const DtTritonDrawableUpdateHeightMapJob &other);
   
   public:
      virtual void operator () (osg::Object* sv);

   protected:
      DtTritonHeightMapManager* myHeightMapManager;
   };

   struct DT_DLL_VRVTRITON DtTritonHeightMapPostDrawFBOCallback : public PostDrawFBOCallback
   {
   public:
      DtTritonHeightMapPostDrawFBOCallback(DtTritonHeightMapManager* heightMapManager, DtDe& de);

   protected:
      virtual ~DtTritonHeightMapPostDrawFBOCallback();

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

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

   class DT_DLL_VRVTRITON DtTritonHeightMapManager
   {
   public:
      virtual ~DtTritonHeightMapManager();

   protected:
      //friend so that it and only it can create the DtTritonHeightMapManagers
      friend class DtTritonHeightMapManagerCreator;
      
      DtTritonHeightMapManager(DtTritonDrawable* parentDrawable, DtDe& de, osg::View* view);

   private:
      DtTritonHeightMapManager();
      DtTritonHeightMapManager(const DtTritonHeightMapManager &other);
      DtTritonHeightMapManager &operator=(const DtTritonHeightMapManager &other);

   public:
      virtual void setTritonCamera(const Triton::Camera* tritonCamera);

      virtual const Triton::Camera* tritonCamera(void) const;

      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::Vec3& currentPosition, bool isGeocentric );

      virtual void setHeightCameraAttachment(bool enabled);

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

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

      virtual void forceUpdate();

      virtual DtTritonDrawable* tritonDrawable();

      virtual osg::Camera* heightCamera();

   protected:
      virtual void cleanup();

      virtual void updateHeightMapMatrix();

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

   protected:

      osg::Vec3 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;

      DtTritonDrawable* myDrawable;

      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;

      const Triton::Camera* myTritonCamera;
   };

   class DT_DLL_VRVTRITON DtTritonHeightMapManagerCreator : public DtVirtualBaseClass
   {
   protected:
      DtTritonHeightMapManagerCreator();

      virtual ~DtTritonHeightMapManagerCreator();

   private:
      DtTritonHeightMapManagerCreator(const DtTritonHeightMapManagerCreator &other);
      DtTritonHeightMapManagerCreator &operator=(const DtTritonHeightMapManagerCreator &other);

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

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

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

}