DtTritonPlanarReflectionManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvTriton/vrvTriton.h>
#include <vrvTriton/DtTritonConfig.h>
#include <vrvTriton/DtPlanarReflection.h>

#include <vrvUtil/DtVirtualBaseClass.h>

#include <matrix/vlVector.h>

#include <osg/ref_ptr>
#include <osg/observer_ptr>
#include <osg/Plane>
#include <osg/Matrixd>
#include <osg/Matrixf>

namespace osg
{
   class RenderInfo;
}

namespace makVrv
{
   class DtDe;
   class DtTritonDrawable;
   class DtOsgRenderer;

   class DT_DLL_VRVTRITON DtTritonPlanarReflectionManager
   {
   protected:
      typedef osg::observer_ptr< osg::Camera > CameraObserverPtr;
      typedef osg::ref_ptr< DtPlanarReflection > PlanarReflectionRef;
      typedef std::map< CameraObserverPtr, PlanarReflectionRef > MapCameraObserverPtrsToPlanarReflection;

   public:
      // destructor
      virtual ~DtTritonPlanarReflectionManager();

   protected:
      friend class DtTritonPlanarReflectionManagerCreator;
      DtTritonPlanarReflectionManager(DtTritonDrawable* tritonDrawable, DtDe& de);

   private:
      DtTritonPlanarReflectionManager();
      DtTritonPlanarReflectionManager(const DtTritonPlanarReflectionManager &other);
      DtTritonPlanarReflectionManager &operator=(const DtTritonPlanarReflectionManager &other);

   public:
      virtual void setMaxReflectionWindSpeed(double metersPerSecond);

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

      virtual void enableReflections(bool enabled);

      virtual void removeAllPlanarReflections();

      virtual DtPlanarReflection* getOrCreatePlanarReflection(osg::RenderInfo& renderInfo);

      virtual DtPlanarReflection* getPlanarReflection(osg::Camera* camera);

      virtual void updateReflectionBlend(const osg::Vec3& currentPosition);
      
      virtual void updateReflectionMatrix(const osg::Vec3& currentPosition);

      virtual void updateReflectionBlendAndMatrix(const osg::Vec3& currentPosition);

      virtual const osg::Matrixd& reflectionMatrix(void) const;
      
      virtual const osg::Plane& reflectionPlane(void) const;

      virtual float reflectionBlend(void) const;

      virtual bool planarReflectionsFlag(void) const;

      virtual int numPlanarReflectionCameras(void) const;

      virtual osg::ref_ptr<osg::Camera> planarReflectionCamera(int index) const;
      
      virtual DtPlanarReflection* planarReflection(int index) const;

      virtual void flushInvalidCameras(void);

   protected:

      virtual DtPlanarReflection* setupPlanarReflections(osg::RenderInfo &renderInfo);

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

   protected:

      DtTritonDrawable* myTritonDrawable;
      DtDe& myDe;

      MapCameraObserverPtrsToPlanarReflection myPlanarReflectionCameraMap;

      // 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;

      bool myPlanarReflectionsFlag;

      bool myReflectionsActive;

      float myReflectionBlend;
      float myMaxReflectionBlend;

      osg::Plane myReflectionPlane;
      osg::Matrixd myReflectionMatrix;
      DtVector myLastGeocentricReference;

      float myMaxWindForReflections;
   };

   class DT_DLL_VRVTRITON DtTritonPlanarReflectionManagerCreator : public DtVirtualBaseClass
   {
   protected:
      DtTritonPlanarReflectionManagerCreator();

      virtual ~DtTritonPlanarReflectionManagerCreator();

   private:
      DtTritonPlanarReflectionManagerCreator(const DtTritonPlanarReflectionManagerCreator &other);
      DtTritonPlanarReflectionManagerCreator &operator=(const DtTritonPlanarReflectionManagerCreator &other);

   public:
      static DtTritonPlanarReflectionManagerCreator& instance(DtDe& de);

      static void registerInstance(DtDe& de,
         DtTritonPlanarReflectionManagerCreator* instance);

   public:
      virtual DtTritonPlanarReflectionManager* create(DtTritonDrawable* parentDrawable, DtDe& de);
   };
}