DtStatsHandlerManager.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2021 VT MAK
** All rights reserved.
******************************************************************************/

#pragma once


#include <vrvOsg/vrvOsg.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <osgViewer/ViewerEventHandlers>
#include <osg/Matrix>

namespace osg
{
   class Switch;
   class MatrixTransform;
   class Geode;
}

namespace osgViewer
{
   class View;
}

namespace osgText
{
   class Text;
}




namespace makVrv
{
   class DtDe;
   class DtBaseConnection;
   class DtProfileNode;
   class DtOsgPerformanceStats;
   class DtOsgProfilerStats;

   class DT_DLL_VRVOSG DtStatsHandler : public osgViewer::StatsHandler
   {
   public:       // public typedefs and enumerations  
      enum ProfilerStatsType
      {
         NO_PROFILER_STATS = 0,
         PERFORMANCE_STATS = 1,
         FUNCTION_STATS = 2,
         BOTH_STATS = 3,
         LAST_PROFILER_STATS = 4
      };

   public:       // public constructors and destructors   
      DtStatsHandler(DtDe& de);

      //This is used to extend the current transform ability of osg stats
      //It will add a matrix transform to the end of the list, then use the key to toggle 
      //between the matrix lists.
      virtual void addTransform(const osg::Matrix& transform);

      //This will clear the default added transforms,
      //Then user can use addTransform to add their own matrixs
      virtual void clearTransforms();

      //set the key toggle the Profiler Stats, default is F3
      virtual void setKeyEventTogglesProfilerStats(int key);

      //get the key toggle the Profiler Stats, default is F3
      virtual int getKeyEventTogglesProfilerStats(void);

      //set the key toggle the Profiler recording, default is F9
      virtual void setKeyEventTogglesProfilerRecording(int key);

      //get the key toggle the Profiler recording, default is F9
      virtual int getKeyEventTogglesProfilerRecording(void);
      
      virtual DtOsgPerformanceStats* osgPerformanceStats();

      virtual DtOsgProfilerStats* osgProfilerStats();

   protected:
      virtual ~DtStatsHandler();

      //create a matrix that map 2DRectangle(lowerLeft1,upperRight1)-->2DRectangle(lowerLeft1,upperRight1)
      osg::Matrix make2DWindowingTransform(osg::Vec2 lowerLeft1, osg::Vec2 upperRight1,
         osg::Vec2 lowerLeft2, osg::Vec2 upperRight2);

      //update the matrix used to transform the osg stats
      virtual void updateTransformMatrix();

      //Add all the matrixs to the osg stats,so we can toggle between them.
      //It will be called when you first hit the transform osg stats key
      virtual void initializeTransforms();

      //turn off the osg stats
      virtual void turnOffOsgStats(osgViewer::View* view);

      //turn off the performance and profiler stats and stop profiling
      virtual void turnOffBothProfilerStats(bool sendSettingsToGui);

      //This will create a instance of DtOsgPerformanceStats and connect the necessary signals
      //only if the instance is 0,It will also start profiling
      virtual void createPerformanceStats();

      //This will delete the instance of DtOsgPerformanceStats and disconnect the necessary signals
      //It will also stop profilinng
      virtual void deletePerformanceStats();

      //Send the performance stats to update the GUI
      virtual void sendPerformanceStatsToGUI(unsigned int state);

      //turn off the performance stats
      virtual void turnOffPerformanceStats(bool sendSettingsToGui);

      //This will create a instance of DtOsgProfilerStats and connect the necessary signals
      //only if the instance is 0, It will also start profiling
      virtual void createProfilerStats();

      //This will create the instance of DtOsgProfilerStats and disconnect the necessary signals
      //It will also stop profiling
      virtual void deleteProfilerStats();

      //Send the profiler stats to update the GUI
      virtual void sendProfilerStatsToGUI(bool enabled);

      //turn off the profiler stats
      virtual void turnOffProfilerStats(bool sendSettingsToGui);

      //toggle between the Performance stats and Function stats
      virtual void updateProfilerStats(bool sendSettingsToGui);

      //set up the text node of the profiler stats
      virtual void setUpProfilerStatsScene();

      virtual void initialize();

      virtual void passKeyEventToStats(int key, int modifier);

      virtual void setPerformanceStatsOverlayEnabled(bool show, bool sendSettingsToGui = true);

      virtual bool performanceStatsOverlayEnabled() const;

      virtual void setProfilerOverlayEnabled(bool show,bool sendSettingsToGui = true);

      virtual bool profilerOverlayEnabled() const;

      virtual void slot_updateDtOsgPerformanceStats(const std::string& string);

      virtual void slot_updateDtOsgProfilerStats(const std::string& string, int numOfLines);

      virtual void slot_onPerformanceStatsOverlayOnChanged(bool mode);

      virtual void slot_onProfilerOverlayOnChanged(bool mode);

   private:
      DtStatsHandler(const DtStatsHandler &other) = delete;
      DtStatsHandler &operator=(const DtStatsHandler &other) = delete;

   public:

      virtual int getStatsType();

      virtual bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);

   protected:
      osg::GraphicsContext* findValidContext(osg::GraphicsContext* context, osgViewer::View* view);

   protected:
      DtDe& myDe;
      osg::ref_ptr<osg::MatrixTransform> myMatrixTransform;
      osg::observer_ptr<osgViewer::View> myOsgView;
      int  myTransformType;
      int  myMaximumTransform;
      std::vector<osg::Matrix> myMatrixs;
      bool myFixedText;
      int myKeyEventTogglesProfilerStats;
      int myKeyEventTogglesProfilerRecording;
      int myProfilerStatsType;
      float myProfilerStatsTextSize;
      osg::Vec4 myProfilerStatsTextColor;
      osg::ref_ptr<osg::Switch> myStatsSwitch;
      osg::ref_ptr<osg::Switch> myProfilerStatsSwitch;
      std::string myProfilerStatsFont;
      osg::ref_ptr<osg::Geode> myPerformanceGeode;
      osg::ref_ptr<osgText::Text> myPerformanceStatsText;
      osg::ref_ptr<osg::Geode> myProfilerGeode;
      osg::ref_ptr<osgText::Text> myProfilerStatsText;
      unsigned int myOsgStatsChildNum;
      unsigned int myPerformanceStatsChildNum;
      unsigned int myProfilerStatsChildNum;
      bool mySetUpProfilerStatsScene;
      DtOsgPerformanceStats* myDtOsgPerformanceStats;
      DtOsgProfilerStats* myDtOsgProfilerStats;
      bool myNeedEnableOsgPerformanceInStartup;
      bool myNeedEnableOsgProfilerInStartup;
      bool myStatsActive;
      DtSignalConnectionManager myConnections;
   };

   class DT_DLL_VRVOSG DtStatsHandlerManager : public DtVirtualBaseClass
   {
   public:       // public typedefs and enumerations      
   public:       // public constructors and destructors   
   protected:

      DtStatsHandlerManager(DtDe& de);

      virtual ~DtStatsHandlerManager();

   private:

      DtStatsHandlerManager(const DtStatsHandlerManager &other) = delete;
      DtStatsHandlerManager &operator=(const DtStatsHandlerManager &other) = delete;

   public:

      virtual void toggleOnScreenStats();

      virtual void toggleProfilerStats();

      virtual void printStats();

      //sends the command to the stats handler for transforming the stats
      virtual void transformStats();

      virtual void recreateStatsHandler();

   public:

      static DtStatsHandlerManager& instance(DtDe& de);

   protected:

      DtDe& myDe;

      osg::ref_ptr<DtStatsHandler> myStatsHandler;
   };
}