DtOsgChannel.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (c) 2016 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 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( int format, int sourceFormat = GL_RGBA, int sourceType = GL_UNSIGNED_BYTE);
      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 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 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> 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(std::string postProcessorEffect);

      virtual void removePostProcessEffect(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 );


   protected:
      //create observer to camera matricies both with and without 
      // channel offset applied. 
      // offsetObserverToCamera has channel offset applied and
      // observerToCamera does not
      void makeObserverToCameraMatrix( osg::Vec3d& orient, 
         osg::Matrixd& offsetObserverToCamera, osg::Matrixd& observerToCamera ); 
      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_channelAdded(DtChannelManager* mgr, DtChannel* channel);

      virtual void slot_channelDestroyed(DtChannelManager* mgr, DtChannel* channel);

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

      virtual void throttleDatabasePager(DtChannelManager* mgr, DtChannel* channel);

   protected:
      void stopUsingModelSetWork( int modelSet );
      
     void startUsingModelSetWork( int modelSet );
     
     void initializeRenderTextureColor(int format, int sourceFormat, int sourceType);
     
     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;
     
     int 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<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;

   };

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