DtTritonManager.h

Go to the documentation of this file.

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


#pragma once
#include <vrvTriton/vrvTriton.h>

#include <vrvCore/DtEnvironment.h>

#include <vlutil/vlTime.h>

#include <vrvUtil/signalslib.h>
#include <vrvUtil/DtBeaufortWindScale.h>

#include <osg/ref_ptr>

namespace Triton
{
   class WakeGenerator;
   class WakeGeneratorParameters;
   class RotorWash;
   class Impact;
   class TidalStreamWake;
}

namespace osg
{
   class Camera;
}

namespace makVrv
{
   class DtCoordinateSystem;
   class DtDe;
   class DtDriver;
   class DtDynamicOceanObject;
   class DtPlanarReflectionCamera;
   class DtRenderer;
   class DtTritonDrawable;
   class DtTritonEventProcessor;
   class DtTritonGroup;
   class DtDynamicOceanObjectManager;

   class DT_DLL_VRVTRITON DtTritonManager : public DtVirtualBaseClass
   {
   public:
      enum TritonQuality {
         TritonQuality_Good = 0,
         TritonQuality_Better,
         TritonQuality_Best
      };

      enum TritonSpectralModel {
          TritonSpectralModel_JonSwap = 0 // (default)
          , TritonSpectralModel_Pierson_Moskowitz
          , TritonSpectralModel_Tessendorf
      };

   public:
      static DtTritonManager& instance(makVrv::DtDe& de);

      virtual ~DtTritonManager();

   protected:
      DtTritonManager(makVrv::DtDe& de);
   public:
      virtual void addToScene();

      virtual void oceanLayerAdded();
      virtual void oceanLayerToBeDeleted();

      virtual void setSeaLevel(float level);
      virtual float seaLevel() const;

      virtual void setElevationLod(double maxElevation);
      virtual double elevationLod() const;

      virtual void setWind(double speed, double direction, double fetch = 0.0);

      virtual void setDouglasSeaState(
         DtDouglasSeaState::Scale seaState, double seaStateDirection,
         DtDouglasSwellState::Scale swellState, double swellStateDirection);

      virtual void addSwell(float wavelength, float waveHeight, float radiansClockwiseFromNorth);
      virtual void clearSwells();

      virtual void setChoppiness(float chop);

      // Water visibility when below water
      virtual bool getIsUnderwater(const osg::Camera* osgCamera) const;
      virtual void setUnderwaterVisibility(double distance);
      virtual bool setUnderwaterFogColor(const DtVector& fogColor);
      virtual void setUnderwaterFogEnabled(bool enabled);

      // Water transparency when above water
      virtual double waterVisibility() const;
      virtual void setWaterVisibility(double distance);
      virtual void setSurfaceTransparency(double transparency);

      // Depth at which wave displacements start getting dampened
      virtual void setSurgeDepth(float depth);
      virtual float getSurgeDepth() const;

      virtual void setDepthOffset(float offset);

      virtual bool intersect(const DtVector& position, DtVector& positionOut,
         DtVector& normalOut, float waterlineAdjustment = 0.0);

      virtual bool intersectSeaLevel(const DtVector& position,
         const DtVector& direction, DtVector& positionOut);

      virtual bool getHeight(const DtVector& position, const DtVector& direction,
         double& height, DtVector& normalOut);

      virtual Triton::WakeGenerator* createWake(
         const Triton::WakeGeneratorParameters& parameters);

      virtual Triton::RotorWash* createRotorWash(double rotorDiameter);

      virtual Triton::Impact* createImpact(double impactorDiameter, double mass,
         double sprayScale);

      virtual Triton::TidalStreamWake* createTidalStreamWake(double size,
         double draft, double maxWaveHeight, double offset);

      virtual void setWaveSprayEffects(bool waveSprayEnabled);
      virtual bool waveSprayEffects() const;

      virtual void setDecalEffects(bool decalsEnabled);
      virtual bool decalEffects() const;

      virtual void setGodRayEffects(bool godRaysEnabled);
      virtual bool godRayEffects() const;

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

      virtual float getMaximumWaveHeight();

      virtual void setSeaState(DtBeaufortWindScale::Scale beaufortScale);
      virtual DtBeaufortWindScale::Scale seaState() const;

      virtual void setCorrelateIntersectionsToVisuals(bool visualCorrelation);
      virtual bool correlateIntersectionsToVisuals() const;

      virtual void setIncludeWakesInIntersections(bool includeWakes);
      virtual bool includeWakesInIntersections() const;

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

      virtual bool isOverWater(const DtVector& localPosition, bool isVisible = true);

      virtual bool addedToScene();

      virtual bool getIsVisible() const;

      virtual DtTime oceanTime() const;

      virtual DtTritonDrawable* tritonDrawable() const;

      virtual double getOceanZoomOverride() const;
      virtual void setOceanZoomOverride(double zoomOverride);

      virtual void setFreezeEnabled(bool enable);
      virtual bool freezeEnabled() const;
      
      virtual void setFreezeTime(DtTime freezeAtTime);
      virtual DtTime freezeTime(void) const;

      virtual bool LockHeightData();
      virtual bool UnLockHeightData();
      virtual bool IsLockedHeightData() const;

      virtual DtTritonGroup* tritonGroup();
      virtual const DtTritonGroup* tritonGroup() const;

   public:
      boost::signalslib::signal<void()> signal_oceanInitialized;
      boost::signalslib::signal<void()> signal_addedToScene;
      boost::signalslib::signal<void()> signal_removedFromScene;
      boost::signalslib::signal<void()> signal_oceanToBeDestroyed;

      boost::signalslib::signal<void (DtPlanarReflectionCamera* reflection)> signal_planarReflectionCreated;

   protected:
      void slot_coordinateSystemChanged();
      void slot_postInitialize();
      void slot_driverToBeDestroyed(DtDriver& driver);
      virtual void installEventProcessor();

       void slot_postUpdate();

      virtual DtDynamicOceanObject* dynamicOcean() const;

      virtual bool intersectMslGeocentric(const DtVector& rayOrigin,
         const DtVector& rayDirection, const double seaLevel, DtVector& positionOut);

      virtual bool intersectMslFlat(const DtVector& rayOrigin,
         const DtVector& rayDirection, const double seaLevel, DtVector& positionOut);

      virtual bool intersectRaySphere(const DtVector& rayOrigin,
         const DtVector& rayDirection, const DtVector& sphereCenter,
         const double sphereSize, DtVector& hitPoint);

   protected:
      DtDe& myDe;

      DtDynamicOceanObjectManager& myDynamicOceanObjectManager;

      DtSignalConnectionManager myConnections;
      DtTritonEventProcessor* myEventProcessor;

      osg::ref_ptr<DtTritonDrawable> myTritonDrawable;
      osg::ref_ptr<DtTritonGroup> myTritonRoot;

      float myElevationRange;
      float mySeaLevel;
      double myWaterVisibility;
      bool myVisualIntersections;
      bool myIncludeWakesInIntersections = true;
      bool myDecalEffects;
      double myOceanZoomOverride;
      bool myOceanMaskTextureEnabled;

      bool myFreezeEnabled = false;
      DtTime myFreezeAtTime = 0;

      static const float theMaxWindSpeedForWindFetch;

      DtCoordinateSystem* myCoordinateSystem = nullptr;

      boost::signalslib::connection myDriverToBeDestroyedConnection;
      boost::signalslib::connection myPostInitializeConnection;

      float myBreakerAmplitude;

      float mySurgeDepth;
   };
}