DtTritonDrawable.h

Go to the documentation of this file.

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


#pragma once

#include <vrvTriton/vrvTriton.h>
#include <vrvTriton/DtTritonManager.h>
#include <vrvTriton/DtTritonRenderingParameters.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <vrvGraphicsUtils/DtVector4.h>
#include <vrvGraphicsUtils/DtMatrix4.h>

#include <matrix/vlVector.h>

#include <osg/Camera>
#include <osg/Drawable>
#include <osg/TextureCubeMap>
#include <tbb/task.h>
#include <map>

namespace osg
{
   class Texture2D;
}

namespace Triton
{
   class Camera;
   class Environment;
   class Ocean;
   class ResourceLoader;
}

namespace makVrv
{
   class DtEnvironmentInfo;
   class DtHeightMapManager;
   class DtHeightMapSuperManager;
   class DtObserverObject;
   class DtOsgCullVisitorParameters;
   class DtOsgSkyObject;
   class DtPlanarReflection;
   class DtTritonBreakingWavesMapManager;
   class DtTritonBreakingWavesMapSuperManager;
   class DtTritonCameraManager;
   class DtTritonPlanarReflectionManager;
   class DtTritonShaderUniformManager;
   class DtWindow;
   class DtGlDebugGroup;
   class DtTritonImGuiHelper;

   class DT_DLL_VRVTRITON DtTritonDrawable : public osg::Drawable
   {
   protected:
      typedef std::map< osg::GraphicsContext*, void* > ContextToHandleMap;

   public:
      DtTritonDrawable(makVrv::DtDe& de, const DtTritonManager& tritonManager,
         DtEnvironmentInfo& environmentInfo, bool geocentric,
         osg::TextureCubeMap* environmentMap = NULL,
         DtTritonManager::TritonQuality tritonQuality = DtTritonManager::TritonQuality_Good);

   protected:
      virtual ~DtTritonDrawable();

   private:

      DtTritonDrawable() = delete;

      DtTritonDrawable(const DtTritonDrawable& drawable) = delete;

      DtTritonDrawable& operator=(const DtTritonDrawable&) = delete;

   public:
      virtual bool isSameKindAs(const Object* obj) const;

      virtual Object* cloneType() const;

      virtual Object* clone(const osg::CopyOp& copyop) const;

      virtual Triton::Ocean* ocean();

      virtual const Triton::Camera* closestCameraTo(const DtVector& position) const;

      virtual Triton::Environment* environment();

      virtual const Triton::Camera* tritonCamera(const osg::Camera* osgCamera) const;

      virtual void setBeach(const osg::Vec3& beachOrigin, const osg::Vec3& normal);

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

      virtual void drawImplementation(osg::RenderInfo& renderInfo) const;

      virtual void setPlanarReflectionsEnabled(bool enabled);
      virtual bool planarReflectionsFlag() const;

      virtual void setBreakingWaveAmplitude(float meters);
      virtual float getBreakingWaveAmplitude() const;

      virtual void setHeightMap(bool enabled);
      virtual bool heightMap() const;

      virtual void setQuality(DtTritonManager::TritonQuality quality);
      virtual DtTritonManager::TritonQuality getQuality() const;

      virtual void setBreakingWavesMap(bool enabled);
      virtual bool breakingWavesMap() const;

      virtual void setMaxReflectionWindSpeed(double metersPerSecond);

      virtual void setUnderwaterFogColor(const osg::Vec4& color);
      virtual const osg::Vec4& underwaterFogColor() const;

      virtual void setUnderwaterVisibility(double visibility);
      virtual double underwaterVisibility() const;

      virtual void setWaterVisibility(double visibility);
      virtual double waterVisibility() const;

      virtual void setSurgeDepth(float depth);
      virtual float surgeDepth() const;

      virtual bool isInitialized() const;

      virtual void setAllowUnderwaterEffects(bool allow);

      virtual bool allowUnderwaterEffects() const;


      virtual void setHeightMapResolution(float metersPerTexel);
      virtual float heightMapResolution() const;

      virtual void setBreakingWavesMapResolution(float metersPerTexel);
      virtual float breakingWavesMapResolution() const;

      virtual void enableReflections(bool enabled);

      virtual void releaseGLObjects(osg::State* state = 0) const;

      virtual void setHeightMapChanged();

      virtual void setBreakingWavesMapChanged();

      virtual osg::ref_ptr<DtPlanarReflection> getPlanarReflection(osg::Camera* camera);

      virtual osg::Group* getTritonGeode();
      virtual const osg::Group* getTritonGeode() const;

      virtual DtHeightMapManager* getOrCreateHeightMapManager(osg::RenderInfo& renderInfo);

      virtual DtTritonBreakingWavesMapManager* getOrCreateBreakingWavesMapManager(osg::RenderInfo& renderInfo);

      virtual void setWindSpeed(double windSpeed);

      virtual bool geocentricFlag();

      virtual void setOceanMaskTextureEnabled(bool myOceanMaskTextureEnabled);
      virtual bool isOceanMaskTextureEnabled() const;

      virtual const DtTritonRenderingParameters& renderingParameters(void) const;

      virtual DtTritonRenderingParameters& renderingParameters(void);

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

   protected:

      virtual void shaderUpdateLightUniforms(osg::RenderInfo& info, void* context, Triton::Camera* camera) const;

      virtual void updateImguiAndConstantsOffOfImgui();
      virtual void updateImguiHeightMapDebugOverlay(bool needUpdate, osg::RenderInfo& renderInfo);

      virtual bool setup(osg::RenderInfo& renderInfo);

      virtual void cleanup(void);

      virtual void removePlanarReflections();

      virtual void slot_reloadShader();

      virtual void initShaderUniformHandles(void* context, Triton::Camera* camera) const;

      virtual void applyLighting(osg::RenderInfo& info, void* context, Triton::Camera* camera) const;

      virtual void applyQuality() const;

      virtual void setUpNearFarIfNecessary(void) const;

      virtual void updateShader(osg::Node* node, osg::State& state, void* context, Triton::Camera* camera) const;

      virtual void setSpecularThreshold(float threshold);
      virtual float specularThreshold() const;

      virtual void slot_heightMapChanged(DtHeightMapManager& manager);

      virtual void slot_heightMapCameraChanged();

      virtual void flushInvalidCameras();


      virtual void onPostTick(void);

      virtual void prepEnvironmentMap(const DtOsgSkyObject* skyObject, const osg::Camera* camera, const osg::State& state) const;

      virtual void prepHeightMapAndBreakingWavesMaps(DtHeightMapManager* heightMapMgr, DtTritonBreakingWavesMapManager* breakingWavesMapMgr, const osg::State& state, osg::RenderInfo& renderInfo) const;

      virtual void prepReflectionMap(osg::ref_ptr<DtPlanarReflection> planarReflectionCamera, const osg::State& state) const;

      virtual void setupTritonLightFogVisibility(const osg::Camera* camera, DtOsgSkyObject* skyObject, bool isAboveWater, bool skyEnabled) const;

      virtual void setUpTritonParticlesAdditiveBlend(void) const;

      virtual void setUpGodRaysFading(const DtOsgCullVisitorParameters* params) const;

      virtual void setUpZoomLevel(const DtOsgCullVisitorParameters* params) const;

      virtual void updatePrecipitation(DtOsgSkyObject* skyObject, bool isAboveWater) const;

      virtual void setUpViewport(Triton::Camera* tritonCamera, osg::Camera* camera) const;

      virtual void checkGlErrors(void) const;

      virtual void restoreOsgState(osg::State& state) const;

      virtual void updatePlanarReflectionCamera(DtPlanarReflection* planarReflection, bool skyEnabled) const;

      virtual void slot_windowToBeDestroyed(DtWindow* window);

      virtual void addGraphicsContextIfNecessary(osg::GraphicsContext* key);

      virtual void setUpOceanMaskIfNecessary();

      virtual const osg::StateSet* shadowTechniqueStateSet(const osg::Camera* osgCamera) const;

      virtual void updateSunIntensity(void) const;

      virtual void updateLighingBasedonSensorFX(osg::Camera* osgCamera) const;
   protected:

      osg::ref_ptr< osg::TextureCubeMap >  myCubeMap;

      Triton::ResourceLoader* myResourceLoader;
      Triton::Environment* myEnvironment;
      Triton::Ocean* myOcean;

      double myDefaultDampingDistance;
      osg::Vec3 myOceanFloorNormal;
      osg::Vec3 myOceanFloorOrigin;
      bool myGeocentricFlag;

      bool myHeightMapFlag, myHeightMapChangedFlag;
      bool myBreakingWavesMapFlag, myBreakingWavesMapChangedFlag;
      float myDefaultVisibility;
      float mySurgeDepth;
      bool myInitializationComplete;
      bool myPrecipitationOverridden, mySavedPrecipitationState;

      bool myAllowUnderwater;
      float myLightThreshold;
      float mySpecularThreshold;

      osg::Vec4 myUnderwaterFogColor;
      double myUnderwaterVisibility;

      float myBreakerAmplitude;

      makVrv::DtEnvironmentInfo& myEnvironmentInfo;

      makVrv::DtDe& myDe;

      DtTritonBreakingWavesMapSuperManager* myBreakingWavesMapSuperManager;

      DtTritonCameraManager* myTritonCameraManager;

      osg::ref_ptr< osg::ClipNode > myClipNode;

      double myWindSpeed;

      DtTritonManager::TritonQuality myQuality;

      const DtTritonManager& myTritonManager;
      DtSignalConnectionManager myConnections;

      std::vector<osg::ref_ptr<osg::Camera> > myDebugVisualsCameras;
      std::vector<osg::ref_ptr<osg::Texture> > myDebugVisualsTextures;
      osg::ref_ptr<osg::Camera> myDebugHeightMapCamera;
      osg::ref_ptr<osg::Texture> myDebugHeightMapVisualTexture;
      bool myShowDebugHeightMapOverlay;

      DtTritonPlanarReflectionManager* myPlanarReflectionManager;

      DtTritonShaderUniformManager* myShaderUniformManger;

      ContextToHandleMap myOsgGcToOsGc;

      osg::ref_ptr<osg::Texture2D> myOceanMaskTexture;
      bool myMutableOceanMaskTextureSetup;

      DtVector4<double> myVrvLatLongMinMax;

      bool mySetupFailed;

      // when the quality changes the shaders have to be reloaded. 
      // This flag lets the updateShaders function know to force a reload.
      mutable bool myMutableShadersDirty;

      // mutable due to osg limitations of drawImplementation being const.
      // This disables the ocean if the shaders fail to compile.
      mutable bool myMutableDisableDrawing;

      // mutable due to osg limitations of drawImplementation being const.
      // IMGui controlled flag to freeze the ocean sim.
      mutable bool myMutableSimFrozen;

      // mutable due to osg limitations of drawImplementation being const.
      // holds the compiled shader ids
      mutable std::vector<unsigned int> myMutableUserShaderVector;

      mutable bool myNearFarValuesInitializedFromConfig;
      double myNearZConfig;
      double myFarZConfig;
      bool myOceanMaskTextureEnabled;


      DtTritonImGuiHelper* myImGuiHelper;

      friend class DtTritonImGuiHelper;

      DtTritonRenderingParameters myRenderingParameters;

   };
}