DtTritonManager.h

Go to the documentation of this file.

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

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

#include <vrvCore/DtEnvironment.h>
#include <vrvCore/DtOceanStateInterface.h>

#include <vlutil/vlTime.h>

#include <boost/signal.hpp>
#include <osg/ref_ptr>

#include <map>

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

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


   class DT_DLL_VRVTRITON DtTritonManager 
      : public DtOceanStateInterface
      , public DtVirtualBaseClass
   {
   public:
      static DtTritonManager& instance(makVrv::DtDe& de);
      virtual ~DtTritonManager();

      void addToScene();

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

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

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

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

      void setDouglasSeaState(
         int seaState, double seaStateDirection,
         int swellState, double swellStateDirection);

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

      void setChoppiness(float chop);

      // Water visibility when below water
      bool getIsUnderwater() const;
      void setUnderwaterVisibility(double distance);
      bool setUnderwaterFogColor(const DtVector& fogColor);
      void setUnderwaterFogEnabled(bool enabled);

      // Color used for refracted water, pre-lighting
      void setWaterColor(const DtVector& waterColor);
      DtVector waterColor() const;

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

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

      void setDepthOffset(float offset);

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

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

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

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

      Triton::RotorWash* createRotorWash(double rotorDiameter);
      Triton::Impact *createImpact(double impactorDiameter, double mass,
         double sprayScale);

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

      void setSplashEffects(bool screenSplashEnabled);
      bool splashEffects() const;

      void setSprayEffects(bool screenSprayEnabled);
      bool sprayEffects() const;

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

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

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

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

      float getMaximumWaveHeight();

      void setHeightMapResolution(float metersPerTexel);
      bool getHeightMapResolution(float &metersPerTexel) const;

      void setSeaState(unsigned int beaufortScale);
      unsigned int seaState() const;

      void setBeach(const DtVector& origin, const DtVector& normal);

      void setPlanarReflections(bool enable);
      bool planarReflections() const;

      void setHeightMap(bool enable);
      bool heightMap() const;

      void setWaveDampingDistance(float distance);
      float waveDampingDistance() const;

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

      enum TritonQuality {
         TritonQuality_Good,
         TritonQuality_Better,
         TritonQuality_Best
      };

      virtual void setQuality(unsigned int quality);
      virtual TritonQuality getQuality() const;

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

      bool addedToScene();

      // Called by traversal. If any call for the given frame number is true, then
      // the ocean is visible in at least one viewport.
      void setIsVisible(bool visible, unsigned int frameNum);

      // Is the ocean currently rendered in at least one viewport?
      bool getIsVisible();

      // Get the time (in seconds) that triton is using for its simulation
      // This may be simulation time or wall clock time
      DtTime oceanTime() const;

      DtTritonDrawable* tritonDrawable() const;

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

      // This is just a hack to support the demo ship
      boost::signal<void (double)> signal_shipSpeedChanged;
      
      virtual double getOceanZoomOverride() const;
      virtual void setOceanZoomOverride(double zoomOverride);

   protected:
      DtTritonManager(makVrv::DtDe& de);

      void slot_postInitialize();
      void slot_driverToBeDestroyed(DtDriver& driver);

      DtDynamicOceanObject* dynamicOcean() const;

   protected:
      DtSignalConnectionManager mySignals;
      DtTritonEventProcessor* myEventProcessor;

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

      float myElevationRange;
      float mySeaLevel;
      double myWaterVisibility;
      bool myVisualIntersections;
      float myWaveDampingDistance;
      unsigned int myLastFrameNum;
      bool myWaterVisible;
      bool myDecalEffects;
      DtVector myWaterColor;
      double myOceanZoomOverride;
      DtDynamicOceanObjectManager& myDynamicOceanObjectManager;
      DtTritonManager::TritonQuality myTritonQuality;
   };


}