DtOsgChannel.h

Go to the documentation of this file.

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

 
#pragma once
 
#include <vrvCore/DtChannel.h>
#include <vrvOsg/DtOsgRenderer.h>
#include <vrvOsg/DtCameraNode.h>

#include <osgViewer/View>

namespace osg
{
   class Matrixd;
}

namespace makVrv 
{ 
   class DtLight;
   class DtChannelSpecificGroup;
   class DtOsgWindow;
   class DtOsgChannelCreator;
   class DtChannelManager;
   class DtWindowConfiguration;
   class DtSensorModule;
   class DtSensor;
   class DtOsgObserverObject;
   class DtOsgCullVisitorParameters;

   class DtDatabasePagerCallback : public osg::DatabaseRequestHandlerCallback
   {

   public:
      DtDatabasePagerCallback(DtDe& de);

      /* child under parent was loaded and added to the scenegraph */
      virtual void childPagedIn(const osg::NodeVisitor::DatabaseRequestHandler*, osg::PagedLOD* page, osg::Node* child) const;

      /* child under parent was un-loaded and removed from the scenegraph */
      virtual void childAboutToPageOut(const osg::NodeVisitor::DatabaseRequestHandler*, osg::PagedLOD* page, osg::Node* child) const;

      virtual osg::DatabaseRequestHandlerCallback* clone() const;

      virtual ~DtDatabasePagerCallback(){}

   private:

      DtDe& myDe;
   };

   class DT_DLL_VRVOSG DtOsgChannel : public DtChannel
   {
   protected:
      friend class DtOsgChannelCreator;

      DtOsgChannel(DtDe& de, DtOsgWindow* window, DtChannelConfiguration& config);



      virtual bool initialize();


      virtual void initializeNormalized2DCamera();
      virtual void initialize2DCamera( int w, int h );
      virtual void initializeSceneCamera( );
      virtual void initializeRenderTexture( );
      virtual void initializeRTTCamera( );

      void clearRttCamera();

      virtual void recreateRTTCamera( );

     
      void setShadowState(bool enable);

      virtual void addOverlayDrawablesToCameras();

      virtual void initializeSignalConnections();


   public:
      virtual ~DtOsgChannel();

      void setSensorName( const std::string& sensorName );

      virtual void setClearColor(float r,float g,float b, float a);

      virtual void setWindow(DtWindow* view);

      virtual const DtWindow* window() const;

      virtual void setViewport(int x,int y,int width, int height);

      virtual void clearFrameBufferIfChanged();

      virtual void getViewport(int& x,int& y, int& width,int& height) const;

      virtual void setCameraPosition(double x, double y, double z);
      
      virtual void setCameraOrientation( double psi, double theta, double phi );
      
      virtual void setCameraPositionAndOrientation( double x, double y, 
         double z, double psi, double theta, double phi ); 
      virtual void setCameraPositionAndOrientation( osg::Vec3d& pos, 
         osg::Quat& orient ); 

      virtual void getCameraPositionAndOrientation( osg::Vec3d& position,
         osg::Quat& rotation ) const;

      virtual void update();
      
      virtual void connectToObserver();
           
      virtual void setProjectionMatrixAsPerspective(double fovy, 
         double   aspectRatio, double zNear, double zFar);

      virtual void setProjectionMatrixAsFrustum (double left, double right, 
         double bottom, double top, double zNear, double zFar);

      virtual void setProjectionMatrix(const osg::Matrix& matrix);
      
      virtual osgViewer::View& view();

      virtual DtCameraNode* sceneCamera();
      virtual const DtCameraNode* sceneCamera() const;

      virtual DtCameraNode* rttCamera() const;

      virtual DtCameraNode* overlayCamera();


      virtual DtCameraNode* normalizedOverlayCamera();

      virtual void setRenderToTexture(bool enabled);

      virtual void setRenderToTextureFormat(int format, int sourceFormat, int sourceType);


      virtual osg::ref_ptr<osg::Texture2D> getRenderTexture();
      virtual osg::ref_ptr<osg::Texture2D> getOcculsionTexture();

      virtual osg::ref_ptr<osg::Texture2D> getDepthTexture() const;
     
      int shadowQuality() const;

      virtual std::vector<const osg::Camera*> getShadowableCameras() const; 

      virtual void setProjectionResizePolicy(
         DtChannelConfiguration::ProjectionResizePolicy policy);

      virtual void updateProjection();

      void projectionUnitsToFrustum( DtChannelConfiguration::ProjectionUnits units, 
         double &left, double zNear, double &right, double &top, double &bottom );

      virtual void connectChannelToScene();

      virtual bool processMouseEvent( const DtMouseEvent& ev);

      virtual bool processKeyboardEvent(const DtKeyEvent & ev);

      //virtual DtDynamicOverlay* overlay();

      void getWorldToWindowMatrix( osg::Matrix& worldToWindowMatrix ) const;

      virtual void moveMouseToScreenLocation(float screenX, float screenY);

      virtual void projectToScreen( double dbX, double dbY, double dbZ,
         double& screenX, double& screenY, double& screenZ );

      virtual void projectToWorld( double screenX, double screenY,
         double& dbX, double& dbY, double& dbZ );

      virtual const std::string& name();

      boost::signal<void (int, int, int, int)> signal_viewportChanged;

      typedef std::list<std::string> PostProcessorEffectList;

      virtual void addPostProcessEffect(const std::string& postProcessorEffect);

      virtual void removePostProcessEffect(const std::string& postProcessorEffect);

      virtual void set3DCullVisitorParams( DtOsgCullVisitorParameters* params );      
      virtual void set2DCullVisitorParams( DtOsgCullVisitorParameters* params );

      virtual void setEnablePostProcessors(bool enable);

      virtual bool getEnablePostProcessors();
    
      //getter/setter for flag to use old (pre 2.1) channel offset calculation
      virtual bool useOldChannelOffsetCalcuation() const;
      virtual void setUseOldChannelOffsetCalcuation( bool enable );

      virtual bool forceHdrLuminanceOverride();
      virtual void setForceHdrLuminanceOverride(bool force);

      // structure to expedite culling. We need to clear any memory
      // that this structure caches to decrement reference count of 
      // StateSets (and hence drawables, textures, etc) when scene
      // changes completely (e.g. on post processor turned off/on)
      // so that memory can be reclaimed
      // This helper function accomplishes that
      virtual void clearStateGraph(void);

      // should just pass through without applying any effects
      // used by SensorFX to turn off HDR on a per channel basis.
      virtual void setEnableHdrPassthrough(bool flag);
      virtual bool enableHdrPassthrough();

      virtual void screenCapture();

      virtual void setOcclusionTextureEnabled(bool enabled);

      virtual void initOcclusionTexture();


   protected:
      //create observer to camera matricies both with and without 
      // channel offset applied. 
      // offsetObserverToCamera has channel offset applied and
      // observerToCamera does not
      virtual void makeObserverToCameraMatrix( osg::Vec3d& orient, 
         osg::Matrixd& offsetObserverToCamera, osg::Matrixd& observerToCamera ); 
      virtual void makeObserverToCameraMatrix( osg::Quat& qObserverToWorld, 
         osg::Matrixd& offsetObserverToCamera, osg::Matrixd& observerToCamera );
      

      virtual void calculateNearFar(double& zNear, double& zFar);

      virtual bool useAttachedForNearClip( double alt );

      virtual double calculateNearClip( double alt, double zFar );

      virtual double calculateFarClip( double alt );

      virtual void projectFor3D();

      virtual void projectFor2D();
      
      virtual void stopUsingModelSet( int modelSet );

      virtual void startUsingModelSet( int modelSet );

      virtual void stopUsingSensor( DtSensor* sensor );

      virtual void startUsingSensor( DtSensor* sensor );

      virtual void slot_sensorRemoved( DtSensor* sensor );
      
      virtual void slot_visualizerRootAdded( int modelSet, int visualType );

      virtual void slot_observerModelSetChanged( DtObserverObject* observer, 
         int modelSet );

      virtual void slot_observerSettingChanged( DtObserverObject* observer, 
         int setting, bool value );

      virtual void slot_observerSettingRemoved( DtObserverObject* observer, 
         int setting );

      virtual void slot_windowConfigurationModified( const std::string& deName, 
         const std::string& oldWindowName, const DtWindowConfiguration& config);
 
      virtual void slot_onCoordinateSystemChanged();

   protected:
      void stopUsingModelSetWork( int modelSet );
      
     void startUsingModelSetWork( int modelSet );
     
     void initializeRenderTextureColor();
     
     void initializeRenderTextureDepth();

     void enableLighting(osg::ref_ptr<osg::Camera> camera, bool enable);
     
     
     
   protected:
      typedef std::map< int, DtChannelSpecificGroup*> VisualTypeMap;

      osg::ref_ptr<osgViewer::View> myView;
      DtOsgWindow* myOsgWindow;
      DtOsgObserverObject* myOsgObserverObject;

      int myRenderTextureFormat;

      int myRenderTextureSourceFormat;

      int myRenderTextureSourceType;

      bool myRenderTextureFormatDirty;

      DtSensor* mySensor;

      osg::ref_ptr<osg::Group> myRoot;

      //The master 3D camera
      osg::ref_ptr<DtCameraNode> mySceneCamera;

      //The 2D camera in screen space(0,0 - w,h)
      osg::ref_ptr<DtCameraNode> my2DCamera;

      //The 2D camera in normalize screen space (0,0 - 1,1)
      osg::ref_ptr<DtCameraNode> myNormalized2DCamera;

      osg::ref_ptr<osg::Texture2D> myRenderTexture;
      osg::ref_ptr<osg::Texture2D> myDepthTexture;
      osg::ref_ptr<osg::Texture2D> myOcclusionTexture;

      osg::ref_ptr<DtCameraNode> myRTTCamera;

      bool myIsUsingTrackballManipulator;
      bool myCoordinateSystemChanged;
      bool myRenderToTextureFlag;
      bool myShadowState;

      // ex. { "dof", "rainsplash", "oceanspray" }
      // list of post processor effect names to enable on update
      PostProcessorEffectList myPostProcessorEffects;

      osg::Node::NodeMask myOldSceneCameraNodeMask;

      DtLight* myFlashlight;

      bool myEnablePostProcessors;

      //flag to use old (pre 2.1) channel offset calculation
      // set by creating a signal_channelCreated callback and 
      // setting it in there
      bool myUseOldChannelOffsetCalcuation;

      osg::ref_ptr<osg::DatabaseRequestHandlerCallback> myDatabasePagerCallback;

      bool myEnableHdrPassthrough;
      bool myForceHdrLuminanceOverride;

      bool myFrameBufferNeedsClear;
   };

   class DT_DLL_VRVOSG DtOsgChannelCreator : public DtChannelCreator
   {
   public:
      virtual DtChannel* create(DtDe& de, DtWindow* window, DtChannelConfiguration& config);
   };
}