0029365: Visualization, TKOpenGl - do not include hidden structures to Rendered withi...
[occt.git] / src / OpenGl / OpenGl_FrameStats.hxx
1 // Copyright (c) 2017 OPEN CASCADE SAS
2 //
3 // This file is part of Open CASCADE Technology software library.
4 //
5 // This library is free software; you can redistribute it and/or modify it under
6 // the terms of the GNU Lesser General Public License version 2.1 as published
7 // by the Free Software Foundation, with special exception defined in the file
8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
9 // distribution for complete text of the license and disclaimer of any warranty.
10 //
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
13
14 #ifndef _OpenGl_FrameStats_HeaderFile
15 #define _OpenGl_FrameStats_HeaderFile
16
17 #include <Graphic3d_RenderingParams.hxx>
18 #include <NCollection_IndexedMap.hxx>
19 #include <OSD_Timer.hxx>
20 #include <Standard_Type.hxx>
21 #include <Standard_Transient.hxx>
22
23 class OpenGl_Workspace;
24 class OpenGl_Structure;
25 typedef NCollection_IndexedMap<const OpenGl_Structure*> OpenGl_IndexedMapOfStructure;
26
27 //! Class storing the frame statistics.
28 class OpenGl_FrameStats : public Standard_Transient
29 {
30   DEFINE_STANDARD_RTTIEXT(OpenGl_FrameStats, Standard_Transient)
31 public:
32
33   //! Stats counter.
34   enum Counter
35   {
36     Counter_NbLayers = 0,           //!< number of ZLayers
37     Counter_NbLayersNotCulled,      //!< number of not culled ZLayers
38     Counter_NbStructs,              //!< number of defined OpenGl_Structure
39     Counter_NbStructsNotCulled,     //!< number of not culled OpenGl_Structure
40     Counter_NbGroupsNotCulled,      //!< number of not culled OpenGl_Group
41     Counter_NbElemsNotCulled,       //!< number of not culled OpenGl_Element
42     Counter_NbElemsFillNotCulled,   //!< number of not culled OpenGl_PrimitiveArray drawing triangles
43     Counter_NbElemsLineNotCulled,   //!< number of not culled OpenGl_PrimitiveArray drawing lines
44     Counter_NbElemsPointNotCulled,  //!< number of not culled OpenGl_PrimitiveArray drawing points
45     Counter_NbElemsTextNotCulled,   //!< number of not culled OpenGl_Text
46     Counter_NbTrianglesNotCulled,   //!< number of not culled (as structure) triangles
47     Counter_NbPointsNotCulled,      //!< number of not culled (as structure) points
48     Counter_EstimatedBytesGeom,     //!< estimated GPU memory used for geometry
49     Counter_EstimatedBytesFbos,     //!< estimated GPU memory used for FBOs
50     Counter_EstimatedBytesTextures, //!< estimated GPU memory used for textures
51   };
52   enum { Counter_NB = Counter_EstimatedBytesTextures + 1 };
53
54 public:
55
56   //! Default constructor.
57   Standard_EXPORT OpenGl_FrameStats();
58
59   //! Destructor.
60   Standard_EXPORT virtual ~OpenGl_FrameStats();
61
62   //! Returns interval in seconds for updating meters across several frames; 1 second by default.
63   Standard_Real UpdateInterval() const { return myUpdateInterval; }
64
65   //! Sets interval in seconds for updating values.
66   void SetUpdateInterval (Standard_Real theInterval) { myUpdateInterval = theInterval; }
67
68   //! Prefer longer lines over more greater of lines.
69   Standard_Boolean IsLongLineFormat() const { return myIsLongLineFormat; }
70
71   //! Set if format should prefer longer lines over greater number of lines.
72   void SetLongLineFormat (Standard_Boolean theValue) { myIsLongLineFormat = theValue; }
73
74   //! Frame redraw started.
75   Standard_EXPORT virtual void FrameStart (const Handle(OpenGl_Workspace)& theWorkspace = Handle(OpenGl_Workspace)());
76
77   //! Frame redraw finished.
78   Standard_EXPORT virtual void FrameEnd (const Handle(OpenGl_Workspace)& theWorkspace = Handle(OpenGl_Workspace)());
79
80 public:
81
82   //! Returns formatted string.
83   Standard_EXPORT virtual TCollection_AsciiString FormatStats (Graphic3d_RenderingParams::PerfCounters theFlags) const;
84
85   //! Returns duration of the last frame in seconds.
86   Standard_Real FrameDuration() const { return myFrameDuration; }
87
88   //! Returns FPS (frames per seconds, elapsed time).
89   //! This number indicates an actual frame rate averaged for several frames within UpdateInterval() duration,
90   //! basing on a real elapsed time between updates.
91   Standard_Real FrameRate() const { return myFps; }
92
93   //! Returns CPU FPS (frames per seconds, CPU time).
94   //! This number indicates a PREDICTED frame rate,
95   //! basing on CPU elapsed time between updates and NOT real elapsed time (which might include periods of CPU inactivity).
96   //! Number is expected to be greater then actual frame rate returned by FrameRate().
97   //! Values significantly greater actual frame rate indicate that rendering is limited by GPU performance (CPU is stalled in-between),
98   //! while values around actual frame rate indicate rendering being limited by CPU performance (GPU is stalled in-between).
99   Standard_Real FrameRateCpu() const { return myFpsCpu; }
100
101   //! Returns value of specified counter, cached between stats updates.
102   //! Should NOT be called between ::FrameStart() and ::FrameEnd() calls.
103   Standard_Size CounterValue (OpenGl_FrameStats::Counter theCounter) const { return myCounters[theCounter]; }
104
105   //! Returns TRUE if some Layers have been culled.
106   Standard_Boolean HasCulledLayers() const { return myCounters[Counter_NbLayersNotCulled] != myCounters[Counter_NbLayers]; }
107
108   //! Returns TRUE if some structures have been culled.
109   Standard_Boolean HasCulledStructs() const { return myCounters[Counter_NbStructsNotCulled] != myCounters[Counter_NbStructs]; }
110
111 public:
112
113   //! Returns TRUE if this stats are equal to another.
114   virtual Standard_Boolean IsEqual (const Handle(OpenGl_FrameStats)& theOther) const
115   {
116     // check just a couple of major counters
117     return Abs (myFps    - theOther->myFps)    <= 0.001
118         && Abs (myFpsCpu - theOther->myFpsCpu) <= 0.001
119         && myCounters[Counter_NbLayers] == theOther->myCounters[Counter_NbLayers]
120         && myCounters[Counter_NbLayersNotCulled] == theOther->myCounters[Counter_NbLayersNotCulled]
121         && myCounters[Counter_NbStructs] == theOther->myCounters[Counter_NbStructs]
122         && myCounters[Counter_NbStructsNotCulled] == theOther->myCounters[Counter_NbStructsNotCulled];
123   }
124
125   //! Copy stats values from another instance
126   virtual void CopyFrom (const Handle(OpenGl_FrameStats)& theOther)
127   {
128     myFps    = theOther->myFps;
129     myFpsCpu = theOther->myFpsCpu;
130     memcpy (myCounters, theOther->myCounters, sizeof(myCounters));
131   }
132
133   //! Returns value of specified counter for modification, should be called between ::FrameStart() and ::FrameEnd() calls.
134   Standard_Size& ChangeCounter (OpenGl_FrameStats::Counter theCounter) { return myCountersTmp[theCounter]; }
135
136 protected:
137
138   //! Updates counters for structures.
139   Standard_EXPORT virtual void updateStructures (Standard_Integer theViewId,
140                                                  const OpenGl_IndexedMapOfStructure& theStructures,
141                                                  Standard_Boolean theToCountElems,
142                                                  Standard_Boolean theToCountTris,
143                                                  Standard_Boolean theToCountMem);
144
145 protected:
146
147   OSD_Timer        myFpsTimer;                //!< timer for FPS measurements
148   Standard_Real    myFrameStartTime;          //!< time at the beginning of frame redraw
149   Standard_Real    myFrameDuration;           //!< frame duration
150   Standard_Real    myFps;                     //!< FPS     meter (frames per seconds, elapsed time)
151   Standard_Real    myFpsCpu;                  //!< CPU FPS meter (frames per seconds, CPU time)
152   Standard_Real    myUpdateInterval;          //!< interval to update meters
153   Standard_Size    myFpsFrameCount;           //!< FPS counter (within short measurement time slice)
154   Standard_Size    myCounters   [Counter_NB]; //!< counter values cached between updates
155   Standard_Size    myCountersTmp[Counter_NB]; //!< counter values filled during
156   Standard_Boolean myIsLongLineFormat;        //!< prefer longer lines over greater number of lines
157
158 };
159
160 DEFINE_STANDARD_HANDLE(OpenGl_FrameStats, Standard_Transient)
161
162 #endif // _OpenGl_FrameStats_HeaderFile