DtImGuiLoaderStatsData.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vlutil/vlPerformanceStats.h>

#include <vrvUtil/signalslib.h>
#include <map>
#include <string>
#include <deque>
#include <unordered_map>

namespace osg
{
   class RenderInfo;
   class Camera;
   class FrameStamp;
   class Object;
}

namespace osgDB
{
   class DatabasePager;
}

class DtDynamicLibrary;

namespace makVrv
{
   class DtOsgStatsHandler;
   class DtProfileNode;

   class DT_DLL_VRVOSG DtImGuiLoaderStatsData
   {
   public:

      enum ProfilerOverlayStates
      {
         ProfilerOverlayStates_OFF = 0,
         ProfilerOverlayStates_FPS = 1,
         ProfilerOverlayStates_FULL = 2
      };

      const int NUM_PAGING_ENTRIES = 4;

      struct GPUData
      {
         GPUData()
            : temp(0)
            , shutdownTemp(0)
            , slowdownTemp(0)
            , maxTemp(0)
            , clocksThrottleReasons(0)
            , dllAvailable(-1)
            , pState(0)
         {
            ;
         }
         unsigned int temp;
         unsigned int shutdownTemp;
         unsigned int slowdownTemp;
         unsigned int maxTemp;
         unsigned long long clocksThrottleReasons;
         int pState;
         int dllAvailable;
      };

      struct OsgObjectData
      {
         OsgObjectData(osg::Object* object);

         osg::Object* myObject;
         std::string myClassName;
         std::string myName;
         int myRefCount;

      };

      struct DatabasePagerData
      {
         int myPagingThreads;
         int myMaxPagedLods;
         int myActivePagedLods;
         int myToMergeCount;
         int myToCompileCount;
         int myRequestCount;

         // osgEarth job arenas
         int myOsgEarthPendingJobs;
         int myOsgEarthRunningJobs;
         int myOsgEarthICOJobs;
         int mySensorizedObjectsPending;
      };

      struct OsgSceneGraphCameraStats
      {
         int myLightCount;
         int myBinCount;
         int myDepthCount;
         int myStateGraphCount;
         int myImposterCount;
         int myDrawableCount;
         int mySortedDrawableCount;
         int myFastDrawableCount;
         int myVertexCount;
         int myPrimitiveSetCount;
         int myPointCount;
         int myLineCount;
         int myLineStripCount;
         int myLineLoopCount;
         int myTriangleCount;
         int myTriStripCount;
         int myTriFanCount;
         int myQuadCount;
         int myQuadStripCount;
         int myPolygonCount;
      };

      static const int GRAPH_ENTRIES = 180;

   public:
      DtImGuiLoaderStatsData(DtDe& de);

      virtual ~DtImGuiLoaderStatsData();

      DtImGuiLoaderStatsData(const DtImGuiLoaderStatsData& rhs) = delete;

      DtImGuiLoaderStatsData& operator=(const DtImGuiLoaderStatsData& rhs) = delete;

   public:

      virtual void updateStats(DtDe& de, osg::Camera* camera, osg::FrameStamp* frameStamp, osgDB::DatabasePager* databasePager, int mipthreads);

      virtual void createUI(osg::RenderInfo& renderInfo, DtDe& de, unsigned int state);

      virtual int getNumberOf60HtzFrames();

      virtual float getGoodFrameDuration();

      virtual int getNumberOfBlownFrames();

      virtual float getBlownFrameDuration();

      virtual int getNumberOfVeryBlownFrames();

      virtual float getVeryBlownFrameDuration();

      virtual void reset();

      virtual void setStatsHandler(DtOsgStatsHandler* stats) { myStats = stats; }

      virtual void updateGpuStats(DtDe& de);

      virtual void addIntStat(const std::string& name, int value);

      virtual void addFloatStat(const std::string& name, float value);

      virtual void addIntStat(const std::string& subsystem, const std::string& name, int value);

      virtual void addFloatStat(const std::string& subsystem, const std::string& name, float value);

      float getLastCullTime();

      float getLastUpdateTime();

      float getLastDrawTime();

      float getLastGpuTime();

   protected:
      // adds child nodes to tree
      virtual int treeTraverse(DtProfileNode* node, int depth);

      virtual void printOsgTextures(void);

      void printOsgEarthGLMemory(void);

      virtual void printVrvTextures(void);

      virtual void printVrvBuffers(void);

      virtual void printTextureBreaksup(const std::unordered_map<unsigned int, int>& textures);

      virtual void updateVrvGpuArenaStats(DtDe& de);

      virtual void createVrvGpuArenaStats();

   protected:
      DtTimedSection myTimedSection;
      float myTimeSpentUnresponsive;
      struct PagingTime
      {
         PagingTime() : myPagingTime(0.0f), myPagingFrameCount(0) { ; }
         PagingTime(float pagingTime, int count) : myPagingTime(pagingTime), myPagingFrameCount(count) { ; }
         float myPagingTime;
         int myPagingFrameCount;
      };
      std::deque<PagingTime> myPagingTimeArray;

      DatabasePagerData myLastDatabasePagerData;
      OsgSceneGraphCameraStats myLastOsgCameraStats;
      bool myEnableOsgCameraStats;
      int mySamples;
      float myRefreshTime;
      float myFrameDuration;
      float myMaxYAxis;
      float myMaxFrameTime;
      float myFrameRunningAverage;
      float myFrameRunningAverageMax;
      float myHistogramData[25];
      float myBlownHistogramData[5];
      int myCurrentIndex;
      float myPhase;
      float myFrameTimeArray[GRAPH_ENTRIES];
      float myCullTimeArray[GRAPH_ENTRIES];
      float myUpdateTimeArray[GRAPH_ENTRIES];
      float myDrawTimeArray[GRAPH_ENTRIES];
      float myGpuTimeArray[GRAPH_ENTRIES];
      float my8ms[GRAPH_ENTRIES];
      float my16ms[GRAPH_ENTRIES];
      float my33ms[GRAPH_ENTRIES];
      int myDDSThreads;
      DtOsgStatsHandler* myStats;


      bool myEnableObjectProfiling;
      std::map<std::string, std::vector<OsgObjectData> > myObjectInfo;
      std::map<std::string, std::vector<OsgObjectData> > myObjectInfoPrevious;
      std::map<std::string, std::vector<OsgObjectData> > myObjectsInBoth;
      bool myOnlyShowDifferentCounts;

      bool myAutoResetEnabled;

      typedef std::map<std::string, int> intStats;
      typedef std::map<std::string, float> floatStats;
      std::map<std::string, intStats> myIntStats;
      std::map<std::string, floatStats> myFloatStats;

      GPUData myGpuState;
      std::map<std::string, std::string> myNvidiaSmiLog;
      DtDynamicLibrary* myGpuPlugin;
      typedef void(*addProc)(makVrv::DtImGuiLoaderStatsData::GPUData* gpu);
      addProc myAddGpuImguiUI;

      DtDe& myDe;
      int myIndirectGpuOneTimeOpsRemaining;
      int myIndirectGpuBufferUpdatesRemaining;
   };
}