DtTritonDrawable.h

Go to the documentation of this file.

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


#pragma once

#include <osg/Camera>
#include <osg/Drawable>
#include <osg/TextureCubeMap>
#include <vrvOsg/DtEnvironmentInfo.h>
#include <vrvOsg/DtOsgLightManager.h>
#include <vrvOsg/DtOsgRenderer.h>
#include <vrvTriton/DtTritonHeightMapManager.h>
#include <vrvTriton/DtTritonBreakingWavesMapManager.h>
#include <matrix/vlVector.h>
#include <osg/StateSet>

#include <vrvGraphicsUtils/DtMatrix4.h>

#include <vrvTriton/vrvTriton.h>

#include <map>


//this is based on the enum Shaders in Ocean.h
#define NUM_TRITON_SHADER_TYPES 4

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

namespace makVrv
{
   class DtPlanarReflection;
   class DtObserverObject;
   class DtTritonManager;

   struct TritonUpdateCallback : public virtual osg::Drawable::UpdateCallback 
   {
      TritonUpdateCallback(Triton::Ocean *ocean, makVrv::DtDe& de) : myOcean(ocean), myDe(de) {}

      virtual void update(osg::NodeVisitor* nv, osg::Drawable*);

      Triton::Ocean *myOcean;
      makVrv::DtDe& myDe;
   };

   class DtTritonDrawable : public osg::Drawable
   {
   public:
      DtTritonDrawable( makVrv::DtDe& de, const DtTritonManager& tritonManager,
         DtEnvironmentInfo& environmentInfo, bool geocentric,
         osg::TextureCubeMap * cubeMap = NULL );

      virtual bool isSameKindAs(const Object* obj) const {
         return dynamic_cast<const DtTritonDrawable*>(obj)!=NULL;
      }
      virtual Object* cloneType() const 
      {
         return new DtTritonDrawable(myDe, myTritonManager,
            myEnvironmentInfo, myGeocentricFlag);
      }
      virtual Object* clone(const osg::CopyOp& copyop) const 
      {
         return new DtTritonDrawable(myDe, myTritonManager, 
            myEnvironmentInfo, myGeocentricFlag);
      }

      virtual Triton::Ocean* ocean() { return myOcean; }

      virtual Triton::Environment* environment() { return myEnvironment; }

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

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

      virtual void setPlanarReflections(bool enabled);
      virtual bool planarReflections() const;

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

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

      enum TritonQuality {
         TritonQuality_Good,
         TritonQuality_Better,
         TritonQuality_Best
      };

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

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

      virtual void setWaveDampingDistance(float meters);
      virtual float waveDampingDistance() const;

      virtual void setMaxReflectionWindSpeed(double metersPerSecond)
      {
         myMaxWindForReflections = metersPerSecond;
      }

      virtual void setUnderwaterFogColor(const osg::Vec4& color)
      {
         myUnderwaterFogColor = color;
      }

      virtual const osg::Vec4& getUnderwaterFogColor() const
      {
         return myUnderwaterFogColor;
      }

      virtual void setUnderwaterVisibility(double visibility)
      {
         myUnderwaterVisibility = visibility;
      }

      virtual double getUnderwaterVisibility() const
      {
         return myUnderwaterVisibility;
      }

      virtual void setWaterVisibility(double visibility)
      {
         myDefaultVisibility = visibility;
      }

      virtual double getWaterVisibility() const
      {
         return myDefaultVisibility;
      }

      virtual void setSurgeDepth(float depth)
      {
         mySurgeDepth = std::max( 0.2f, depth );
      }

      virtual float getSurgeDepth() const
      {
         return mySurgeDepth;
      }

      virtual bool getIsInitialized() const
      {
         return myInitializationComplete;
      }

      virtual void setHeightMapResolution(float metersPerTexel);

      virtual float getHeightMapResolution() const;

      virtual void setBreakingWavesMapResolution(float metersPerTexel);

      virtual float getBreakingWavesMapResolution() const;

      virtual void enableReflections(bool enabled);

      boost::signal<void ()> signal_postInitialize;

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

      void heightMapChanged();

      void breakingWavesMapChanged();

   protected:
      void shaderUpdateLightUniforms(osg::RenderInfo& info, osg::State &state, GLint shader, int shaderType) const;

      void shaderUpdateViewMatrices(osg::State &state, GLint shader, int shaderType
         , const Matrix4_32& view_matrix_32
         , const Matrix4_32& view_inverse_transpose_matrix_32) const;
     
     void updateCloudShadows(osg::State &state, GLint shader, int shaderType
      , GLboolean bIsCloudShadowActive
      , unsigned int cloudshadowTextureUnit
      , unsigned int cloudshadowTextureIndex
      , osg::Matrixf textureViewProjMatrix) const;

       void GetShaderUniformHandles(GLint shader, int shaderType) const;

      osg::ref_ptr<DtPlanarReflection> getOrCreatePlanarReflection(osg::RenderInfo& renderInfo);

      osg::ref_ptr<DtPlanarReflection> setupPlanarReflections( osg::RenderInfo &renderInfo );

      DtTritonHeightMapManager *getOrCreateHeightMapManager(osg::RenderInfo& renderInfo);

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

      void setup( void );
      void cleanup( void );

      osg::Node * createMirroredWorldGraph( makVrv::DtOsgRenderer& osgRenderer, 
         const osg::Matrix & localToWorld, const osg::Vec3 currentPos );

      void computeReflectionMatrix( const osg::Vec3& currentPosition );

      void GetShaderUniformHandles() const;

      void applyLighting(osg::RenderInfo& info) const;

      void applyQuality() const;

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

      void computeReflectionBlend( const osg::Vec3& currentPosition );

      void adjustDisplacementDampingDistance();

      virtual ~DtTritonDrawable();

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

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

      double myDefaultDampingDistance;
      osg::Vec3 myOceanFloorNormal;
      osg::Vec3 myOceanFloorOrigin;
      bool myGeocentricFlag;
      bool myPlanarReflectionsFlag;
      float myReflectionBlend;
      float myMaxReflectionBlend;
      float myMaxWindForReflections;
      bool myReflectionsActive;
      bool myHeightMapFlag, myHeightMapChangedFlag;
      bool myBreakingWavesMapFlag, myBreakingWavesMapChangedFlag;
      float myDefaultVisibility;
      float mySurgeDepth;
      bool myInitializationComplete;
      bool myPrecipitationOverridden, mySavedPrecipitationState;
      float myHeightMapResolution, myBreakingWavesMapResolution;

      // This boolean indicates whether or not planar reflections have been requested,
      // regardless of the internal state of the drawable.  When it finally gets around
      // to setting up planar reflections, this flag is checked
      bool myPlanarReflectionsEnabled;

      osg::Vec4 myUnderwaterFogColor;
      double myUnderwaterVisibility;

      float myBreakerAmplitude;

      makVrv::DtEnvironmentInfo& myEnvironmentInfo;

      makVrv::DtDe& myDe;
      
      std::map<osg::Camera *, osg::ref_ptr<makVrv::DtPlanarReflection> > myPlanarReflectionCameraMap;
      std::map<osg::Camera *, makVrv::DtTritonHeightMapManager *> myHeightMapManagerMap;
      std::map<osg::Camera *, makVrv::DtTritonBreakingWavesMapManager *> myBreakingWavesMapManagerMap;

      osg::ref_ptr< osg::ClipNode > myClipNode;
      osg::Plane myReflectionPlane;
      osg::Matrix myReflectionMatrix;
      DtVector myLastGeocentricReference;

      mutable int myViewPortSizeUniform[NUM_TRITON_SHADER_TYPES];

      mutable int myLightTextureUniform[NUM_TRITON_SHADER_TYPES];
      mutable int myTileLightIndexListTextureUniform[NUM_TRITON_SHADER_TYPES];
      mutable int myTileLightGridCountOffsetsTextureUniform[NUM_TRITON_SHADER_TYPES];
      mutable int myColorRampTextureUniform[NUM_TRITON_SHADER_TYPES];

      mutable int myModelViewMatrixUniform[NUM_TRITON_SHADER_TYPES];
      mutable int myModelViewInverseTransposeMatrixUniform[NUM_TRITON_SHADER_TYPES];

      mutable int myLightGridTileDimUniform[NUM_TRITON_SHADER_TYPES];
      mutable int myLightGridMaxDimUniform[NUM_TRITON_SHADER_TYPES];
     
      mutable int myCloudShadowTextureUniform[NUM_TRITON_SHADER_TYPES];
      mutable int myCloudShadowTexGenUniform[NUM_TRITON_SHADER_TYPES];
      mutable int myCloudShadowActive[NUM_TRITON_SHADER_TYPES];
      
      mutable std::vector<unsigned int> myUserShaderVector;

      GLuint myDefaultShaderId;

      TritonQuality myQuality;

      const DtTritonManager& myTritonManager;

   };
}