DtOsgChannel.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/DtChannel.h>

#include <vrvCore/DtIntersector.h>

#include <vrvOsg/DtOsgRenderer.h>
#include <vrvOsg/DtCameraNode.h>

#include <matrix/vlVector.h>

#include <osgViewer/View>

namespace osg
{
   class Matrixd;
   class DatabaseRequestHandler;
}

namespace makVrv
{
   class DtLight;
   class DtChannelSpecificGroup;
   class DtIntersectorResult;
   class DtIntersectorsContainer;
   class DtOsgWindow;
   class DtOsgChannelCreator;
   class DtOsgEmptySceneLogo;
   class DtChannelManager;
   class DtWindowConfiguration;
   class DtSensorModule;
   class DtSensor;
   class DtOsgObserverObject;
   class DtOsgCullVisitorParameters;
   class DtTerrainPageSignaler;

   class DtOsgChannelSensor;


   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();

      virtual void clearRttCamera();

      virtual void recreateRTTCamera();


      virtual void setShadowState(bool enable);

      virtual void addOverlayDrawablesToCameras();

      virtual void initializeSignalConnections();


   public:
      virtual ~DtOsgChannel();

      virtual 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 setChannelEnabled(bool enabled, bool partial) override;

      virtual bool channelEnabled() const;

      virtual void update();

      virtual void connectToObserver();

      virtual osgViewer::View& view();
      
      virtual DtCameraNode* sceneCamera();

      virtual const DtCameraNode* sceneCamera() const;

      virtual DtCameraNode* rttCamera() const;

      virtual DtCameraNode* activeMainCamera();

      virtual const DtCameraNode* activeMainCamera() 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::Texture> allocateRenderTexture(int width, int height) const;

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

      virtual osg::ref_ptr<osg::Texture> getDepthTexture() const;

      virtual void setDepthTextureUsesStencilBuffer(bool useStencil);

      virtual bool depthTextureUsesStencilBuffer() const;

      virtual int shadowQuality() const;

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

      virtual void setProjectionResizePolicy(
         DtChannelConfiguration::ProjectionResizePolicy policy);

      virtual void updateProjection();

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

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

      virtual 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) const override;

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

      virtual DtIntersectorResult findWorldIntersection(double screenX, double screenY,
         DtIntersector::IntersectProperties properties = DtIntersector::AllNodes,
         std::vector<DtElementID>* ignoreList = 0) override;

      virtual const std::string& name();

      boost::signalslib::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 bool hasPostProcessEffect(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 setHdrOutputScale(float scale);
      virtual float hdrOutputScale();

      virtual void screenCapture();

      virtual void setOcclusionTextureEnabled(bool enabled);

      virtual void initOcclusionTexture();

      virtual void updateCameraFrustumPlanes( std::vector< DtVector4<double> >& planes );

      virtual void updateAcquisitionBoxFrustumPlanes(const int& boxCenterX, const int& boxCenterY, 
         const int& boxWidth, const int& boxHeight, std::vector< DtVector4<double> >& planes );

      virtual void setChannelSensor(DtOsgChannelSensor* extension);
      virtual DtOsgChannelSensor* findChannelSensor() { return myChannelSensor; }

      virtual void releaseResources(osg::State* gcState);

      virtual void updateShowTracksUniform(bool value);

      virtual std::vector<DtElementID> entitiesInFrustum() override;

   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 double calculateNearClipMagClamp(double zNear, double zFar, float magLevel=2.);

      virtual void projectFor3D();

      virtual void projectFor2D();

      virtual void connectRttCameraToScene();

      virtual void stopUsingModelSet(DtModelSetId modelSet);

      virtual void startUsingModelSet(DtModelSetId modelSet);

      virtual void slot_visualizerRootAdded(DtModelSetId modelSet, int visualType);

      virtual void slot_shadowsRemoved();

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

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

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

      virtual void slot_observerColorControlChanged(DtObserverObject* observer);

      virtual void slot_projectionChanged(DtObserverObject* observer, bool is2D);

      virtual void slot_windowConfigurationModified(const std::string& deName,
         const std::string& oldWindowName, const DtWindowConfiguration& config);
      
      virtual void slot_channelConfigurationModified(const std::string& deName, 
         const std::string& windowName, const std::string& oldChannelName, 
         const DtChannelConfiguration& channelConfig);

      virtual void slot_onCoordinateSystemChanged();

      virtual void slot_paperMapEnabledChanged(bool setting);

      virtual void observerRemoved(const std::string& observerName);

      virtual void updateMultiSampleOverrideSetting();

   protected:

      virtual void getRenderTextureAttachmentInfo(unsigned int& level, unsigned int& face, unsigned int& sampleBuffers, unsigned int& samples);

      virtual void initializeRenderTextureColor();

      virtual void initializeRenderTextureDepth();

      virtual void initializeRttCameraDepth();

      virtual void changedRttCameraFbo();

      virtual void enableLighting(osg::ref_ptr<osg::Camera> camera, bool enable);

      virtual void calculateAndSetFocusPointDistance(double zNear, double zFar);

      osgViewer::CompositeViewer* getOrCreateViewer();

      virtual void flipHorizontal(bool flip);

      bool anyPointInFrustum(const std::vector<DtVector4<double>>& camPlanes,
        const std::vector<DtVector>& points) const;

   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;

      bool mySensorInitialized;

      bool myChannelEnabled;

      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::Texture> myRenderTexture;
      osg::ref_ptr<osg::Texture> myDepthTexture;
      osg::ref_ptr<osg::Texture> myOcclusionTexture;

      bool myDepthTextureUsesStencilBuffer;

      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;
      osg::Node::NodeMask myOldRTTCameraNodeMask;

      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;
      float myHdrOutputScale;

      bool myFrameBufferNeedsClear;

      // For mirror mode (horizontal flip), we disable the feature in 2D (plan view)
      // We have to keep track of the last value from the channel config so we 
      // can restore right the value when the user goes back to a 3D view
      bool myLastMirrorMode;

      // When NEAR_FAR_DYNAMIC_NEAR_CLIP_MAG_CLAMP policy is used, this value is cached.  If the clamp
      // intersector gets a sky shot and this value is > 0. it is used instead.  When the policy is
      // NOT NEAR_FAR_DYNAMIC_NEAR_CLIP_MAG_CLAMP it is set to 0., so old cache values don't get used.
      double myPreviousClampedNearClipDistance;

      // used for a debug ability to override the number of multisamples used by the rtt camera
      int myLastNumMultiSamplesOverride;
      
      std::vector<osg::Vec3d> myFocusPoints;
      int myLastFocusPointAttempted;

      DtOsgChannelSensor* myChannelSensor;

      bool myShowTracksEnabled;

      DtIntersectorsContainer* myIntersectors = nullptr;

      DtOsgEmptySceneLogo* myEmptySceneLogo;

      static int theRunningCameraId;
   private:

      DtOsgChannel();

      DtOsgChannel(const DtOsgChannel&);

      DtOsgChannel &operator=(const DtOsgChannel &);   
   };

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