DtTritonDrawable.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2023 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 <vrvMath/DtVector4.h>
#include <vrvMath/DtMatrix4.h>

#include <matrix/vlVector.h>

#include <osg/Camera>
#include <osg/Drawable>
#include <osg/TextureCubeMap>
#include <map>

namespace osg
{
   class Texture2D;
}

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

namespace makVrv
{
   class DtHeightMapManager;
   class DtObserverObject;
   class DtOsgCullVisitorParameters;
   class DtOsgSkyObject;
   class DtPlanarReflectionCamera;
   class DtTritonBreakingWavesMapManager;
   class DtTritonPlanarReflectionManager;
   class DtTritonShaderUniformManager;
   class DtWindow;
   class DtGlDebugGroup;
   class DtTritonImGuiHelper;
   class DtSkyObjectManager;
   class DtTritonGroupTcsUserData;
   class DtHeightMapSuperManager;

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

   public:
      DtTritonDrawable(makVrv::DtDe& de, DtTritonManager& tritonManager);

   protected:
      virtual ~DtTritonDrawable();

   private:

      DtTritonDrawable() = delete;

      DtTritonDrawable(const DtTritonDrawable& drawable) = delete;

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

   public:
      virtual void setUpEnvironment();

      virtual void setUpOceanMask();
      
      virtual Triton::Ocean* ocean();

      virtual Triton::Environment* environment();

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

      virtual void setUnderwaterFogColor(const Vector4_32& color);
      virtual const Vector4_32& underwaterFogColor() const;

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

      virtual bool isInitialized() const;

      virtual void setAllowUnderwaterEffects(bool allow);

      virtual bool allowUnderwaterEffects() const;

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

      virtual void planarReflectionCameras(std::vector<osg::ref_ptr<const DtPlanarReflectionCamera>>& planarReflectionCameras) const;

      virtual osg::ref_ptr<DtPlanarReflectionCamera> planarReflectionCamera(osg::Camera* osgCamera) const;

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

      virtual const DtTritonRenderingParameters& renderingParameters(void) const;

      virtual DtTritonRenderingParameters& renderingParameters(void);

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

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

   protected:

      virtual void shaderUpdateLightUniforms(osg::RenderInfo& info
      , const osg::Camera* osgCamera
      , DtTritonGroupTcsUserData* userData, double windSpeed) const;

      virtual void slot_preObserverUpdate();

      virtual bool setUpOcean();

      virtual void cleanup(void);

      virtual void slot_reloadShader();


      virtual void applyLighting(osg::RenderInfo& info, const osg::Camera* osgCamera
         , DtTritonGroupTcsUserData* userData, double windSpeed) const;

      virtual bool applyQuality() const;
      
      virtual void applySpectralModel(void) const;

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

      virtual void onPostTick(void);

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

      virtual void prepHeightMapAndBreakingWavesMaps(const DtHeightMapManager* heightMapMgr, osg::State& state, osg::RenderInfo& renderInfo
         , DtTritonGroupTcsUserData* userData, bool forceUpdate) const;

      virtual void prepReflectionMap(osg::ref_ptr<DtPlanarReflectionCamera> planarReflectionCamera, const osg::State& state
         , double windSpeed, DtTritonGroupTcsUserData* userData) const;

      virtual void setupTritonLightFogVisibility(const osg::Camera* camera, DtOsgSkyObject* skyObject, std::pair<bool, float> isAboveWater, bool skyEnabled, DtTritonGroupTcsUserData* userData) const;

      virtual Vector4_32 calculateUnderWaterFogColor( Vector4_32 ambientLight, float cameraDepth ) const;

      virtual std::pair<bool, float> isCameraAboveWater( Triton::Ocean* ocean, 
         const Triton::Environment* environment, const Triton::Camera* camera ) const;

      virtual void setUpTritonParticlesAdditiveBlend(void) const;

      virtual void setUpGodRaysFading(const DtOsgCullVisitorParameters* params, DtTritonGroupTcsUserData* userData) const;

      virtual void setUpZoomLevel(const DtOsgCullVisitorParameters* params, DtTritonGroupTcsUserData* userData) const;

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

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

      virtual void updatePlanarReflectionCamera(const Vector4_32& fogColor, bool skyEnabled, DtTritonGroupTcsUserData* userData) const;

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


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

      virtual void updateSunIntensity(const osg::Camera* osgCamera, DtTritonGroupTcsUserData* userData, double windSpeed) const;

      virtual void updateLighingBasedonSensorFX(const osg::Camera* osgCamera, DtTritonGroupTcsUserData* userData) const;

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

      virtual void logTritonInitializationInfo(void) const;

      virtual void updateBreakingWavesParametersInTriton(void);

      virtual void slot_hdrEnabledChanged( bool );
   protected:
      Triton::ResourceLoader* myResourceLoader;
      Triton::Environment* myEnvironment;
      Triton::Ocean* myOcean;

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

      
      bool myInitializationComplete;

      bool myAllowUnderwater;
      float myLightThreshold;
      float mySpecularThreshold;

      Vector4_32 myUnderwaterFogColor;
      double myUnderwaterVisibility;

      makVrv::DtDe& myDe;

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

      DtTritonManager& myTritonManager;
      DtSignalConnectionManager myConnections;

      ContextToHandleMap myOsgGcToOsGc;

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

      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.
      // holds the compiled shader ids
      mutable std::vector<unsigned int> myMutableUserShaderVector;

      DtUniqueID myHeightMapRegisteredId;

      DtTritonImGuiHelper* myImGuiHelper;

      friend class DtTritonImGuiHelper;

      DtTritonRenderingParameters myRenderingParameters;

      DtSkyObjectManager& mySkyObjectManager;

      // This is just an upper bound  > the max possible wind speed allowed by triton (30)
      // It is used to compute the reflection blend
      const float myWindSpeedUpperBound = 40.0f;
      // This is the max amount of how much reflections are blended in
      const float myMaxReflectionBlend = 0.5f;

      DtHeightMapSuperManager& myHeightMapSuperManager;

      // Turn these on/off for debugging
      const bool myHeightMapEnabled;
      const bool myBreakingWavesEnabled;
      const bool myBreakingWavesMapEnabled;
      const bool myPlanarReflectionsEnabled;

      // Was HDR on before we turned it off for below water
      // visibility?
      bool myPreSubmergedHDROn;
   };
}