time: move to stl's clocks and move timer

4 files changed, 49 insertions, 60 deletions

diff --git a/src/render/OpenGL.hpp b/src/render/OpenGL.hpp
index ab091f24..17ef4f5f 100644
--- a/src/render/OpenGL.hpp
+++ b/src/render/OpenGL.hpp
@@ -3,7 +3,7 @@
 #include "../defines.hpp"
 #include "../helpers/Monitor.hpp"
 #include "../helpers/Color.hpp"
-#include "../helpers/Timer.hpp"
+#include "../helpers/time/Timer.hpp"
 #include "../helpers/math/Math.hpp"
 #include "../helpers/Format.hpp"
 #include "../helpers/sync/SyncTimeline.hpp"
diff --git a/src/render/Renderer.cpp b/src/render/Renderer.cpp
index 1ce717bc..8a2d4555 100644
--- a/src/render/Renderer.cpp
+++ b/src/render/Renderer.cpp
@@ -135,9 +135,6 @@ CHyprRenderer::CHyprRenderer() {
             if (m_vRenderUnfocused.empty())
                 return;
 
-            timespec now;
-            clock_gettime(CLOCK_MONOTONIC, &now);
-
             bool dirty = false;
             for (auto& w : m_vRenderUnfocused) {
                 if (!w) {
@@ -148,7 +145,7 @@ CHyprRenderer::CHyprRenderer() {
                 if (!w->m_pWLSurface || !w->m_pWLSurface->resource() || shouldRenderWindow(w.lock()))
                     continue;
 
-                w->m_pWLSurface->resource()->frame(&now);
+                w->m_pWLSurface->resource()->frame(Time::steadyNow());
                 auto FEEDBACK = makeShared<CQueuedPresentationData>(w->m_pWLSurface->resource());
                 FEEDBACK->attachMonitor(g_pCompositor->m_pLastMonitor.lock());
                 FEEDBACK->discarded();
@@ -265,7 +262,7 @@ bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow) {
     return false;
 }
 
-void CHyprRenderer::renderWorkspaceWindowsFullscreen(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, timespec* time) {
+void CHyprRenderer::renderWorkspaceWindowsFullscreen(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, const Time::steady_tp& time) {
     PHLWINDOW pWorkspaceWindow = nullptr;
 
     EMIT_HOOK_EVENT("render", RENDER_PRE_WINDOWS);
@@ -356,7 +353,7 @@ void CHyprRenderer::renderWorkspaceWindowsFullscreen(PHLMONITOR pMonitor, PHLWOR
     }
 }
 
-void CHyprRenderer::renderWorkspaceWindows(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, timespec* time) {
+void CHyprRenderer::renderWorkspaceWindows(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, const Time::steady_tp& time) {
     PHLWINDOW lastWindow;
 
     EMIT_HOOK_EVENT("render", RENDER_PRE_WINDOWS);
@@ -454,7 +451,7 @@ void CHyprRenderer::renderWorkspaceWindows(PHLMONITOR pMonitor, PHLWORKSPACE pWo
     }
 }
 
-void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, timespec* time, bool decorate, eRenderPassMode mode, bool ignorePosition, bool standalone) {
+void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const Time::steady_tp& time, bool decorate, eRenderPassMode mode, bool ignorePosition, bool standalone) {
     if (pWindow->isHidden() && !standalone)
         return;
 
@@ -692,7 +689,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, timespe
     g_pHyprOpenGL->m_RenderData.currentWindow.reset();
 }
 
-void CHyprRenderer::renderLayer(PHLLS pLayer, PHLMONITOR pMonitor, timespec* time, bool popups) {
+void CHyprRenderer::renderLayer(PHLLS pLayer, PHLMONITOR pMonitor, const Time::steady_tp& time, bool popups) {
     if (!pLayer)
         return;
 
@@ -770,7 +767,7 @@ void CHyprRenderer::renderLayer(PHLLS pLayer, PHLMONITOR pMonitor, timespec* tim
     }
 }
 
-void CHyprRenderer::renderIMEPopup(CInputPopup* pPopup, PHLMONITOR pMonitor, timespec* time) {
+void CHyprRenderer::renderIMEPopup(CInputPopup* pPopup, PHLMONITOR pMonitor, const Time::steady_tp& time) {
     const auto                       POS = pPopup->globalBox().pos();
 
     CSurfacePassElement::SRenderData renderdata = {pMonitor, time, POS};
@@ -804,7 +801,7 @@ void CHyprRenderer::renderIMEPopup(CInputPopup* pPopup, PHLMONITOR pMonitor, tim
         &renderdata);
 }
 
-void CHyprRenderer::renderSessionLockSurface(WP<SSessionLockSurface> pSurface, PHLMONITOR pMonitor, timespec* time) {
+void CHyprRenderer::renderSessionLockSurface(WP<SSessionLockSurface> pSurface, PHLMONITOR pMonitor, const Time::steady_tp& time) {
     CSurfacePassElement::SRenderData renderdata = {pMonitor, time, pMonitor->vecPosition, pMonitor->vecPosition};
 
     renderdata.blur     = false;
@@ -825,7 +822,7 @@ void CHyprRenderer::renderSessionLockSurface(WP<SSessionLockSurface> pSurface, P
         &renderdata);
 }
 
-void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, timespec* time, const Vector2D& translate, const float& scale) {
+void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, const Time::steady_tp& time, const Vector2D& translate, const float& scale) {
     static auto PDIMSPECIAL      = CConfigValue<Hyprlang::FLOAT>("decoration:dim_special");
     static auto PBLURSPECIAL     = CConfigValue<Hyprlang::INT>("decoration:blur:special");
     static auto PBLUR            = CConfigValue<Hyprlang::INT>("decoration:blur:enabled");
@@ -988,7 +985,7 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
     //g_pHyprOpenGL->restoreMatrix();
 }
 
-void CHyprRenderer::renderLockscreen(PHLMONITOR pMonitor, timespec* now, const CBox& geometry) {
+void CHyprRenderer::renderLockscreen(PHLMONITOR pMonitor, const Time::steady_tp& now, const CBox& geometry) {
     TRACY_GPU_ZONE("RenderLockscreen");
 
     if (g_pSessionLockManager->isSessionLocked()) {
@@ -1246,8 +1243,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
 
     EMIT_HOOK_EVENT("preRender", pMonitor);
 
-    timespec now;
-    clock_gettime(CLOCK_MONOTONIC, &now);
+    const auto NOW = Time::steadyNow();
 
     // check the damage
     bool hasChanged = pMonitor->output->needsFrame || pMonitor->damage.hasChanged();
@@ -1328,9 +1324,9 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
                 renderCursor = false;
             } else {
                 CBox renderBox = {0, 0, (int)pMonitor->vecPixelSize.x, (int)pMonitor->vecPixelSize.y};
-                renderWorkspace(pMonitor, pMonitor->activeWorkspace, &now, renderBox);
+                renderWorkspace(pMonitor, pMonitor->activeWorkspace, NOW, renderBox);
 
-                renderLockscreen(pMonitor, &now, renderBox);
+                renderLockscreen(pMonitor, NOW, renderBox);
 
                 if (pMonitor == g_pCompositor->m_pLastMonitor) {
                     g_pHyprNotificationOverlay->draw(pMonitor);
@@ -1357,18 +1353,18 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
                 }
             }
         } else
-            renderWindow(pMonitor->solitaryClient.lock(), pMonitor, &now, false, RENDER_PASS_MAIN /* solitary = no popups */);
+            renderWindow(pMonitor->solitaryClient.lock(), pMonitor, NOW, false, RENDER_PASS_MAIN /* solitary = no popups */);
     } else if (!pMonitor->isMirror()) {
-        sendFrameEventsToWorkspace(pMonitor, pMonitor->activeWorkspace, &now);
+        sendFrameEventsToWorkspace(pMonitor, pMonitor->activeWorkspace, NOW);
         if (pMonitor->activeSpecialWorkspace)
-            sendFrameEventsToWorkspace(pMonitor, pMonitor->activeSpecialWorkspace, &now);
+            sendFrameEventsToWorkspace(pMonitor, pMonitor->activeSpecialWorkspace, NOW);
     }
 
     renderCursor = renderCursor && shouldRenderCursor();
 
     if (renderCursor) {
         TRACY_GPU_ZONE("RenderCursor");
-        g_pPointerManager->renderSoftwareCursorsFor(pMonitor->self.lock(), &now, g_pHyprOpenGL->m_RenderData.damage);
+        g_pPointerManager->renderSoftwareCursorsFor(pMonitor->self.lock(), NOW, g_pHyprOpenGL->m_RenderData.damage);
     }
 
     EMIT_HOOK_EVENT("render", RENDER_LAST_MOMENT);
@@ -1578,7 +1574,7 @@ bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) {
     return ok;
 }
 
-void CHyprRenderer::renderWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, timespec* now, const CBox& geometry) {
+void CHyprRenderer::renderWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, const Time::steady_tp& now, const CBox& geometry) {
     Vector2D translate = {geometry.x, geometry.y};
     float    scale     = (float)geometry.width / pMonitor->vecPixelSize.x;
 
@@ -1593,7 +1589,7 @@ void CHyprRenderer::renderWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace
     renderAllClientsForWorkspace(pMonitor, pWorkspace, now, translate, scale);
 }
 
-void CHyprRenderer::sendFrameEventsToWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, timespec* now) {
+void CHyprRenderer::sendFrameEventsToWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, const Time::steady_tp& now) {
     for (auto const& w : g_pCompositor->m_vWindows) {
         if (w->isHidden() || !w->m_bIsMapped || w->m_bFadingOut || !w->m_pWLSurface->resource())
             continue;
@@ -1962,7 +1958,7 @@ void CHyprRenderer::damageMirrorsWith(PHLMONITOR pMonitor, const CRegion& pRegio
     }
 }
 
-void CHyprRenderer::renderDragIcon(PHLMONITOR pMonitor, timespec* time) {
+void CHyprRenderer::renderDragIcon(PHLMONITOR pMonitor, const Time::steady_tp& time) {
     PROTO::data->renderDND(pMonitor, time);
 }
 
@@ -2426,9 +2422,6 @@ void CHyprRenderer::makeRawWindowSnapshot(PHLWINDOW pWindow, CFramebuffer* pFram
 
     g_pHyprOpenGL->clear(CHyprColor(0, 0, 0, 0)); // JIC
 
-    timespec now;
-    clock_gettime(CLOCK_MONOTONIC, &now);
-
     // this is a hack but it works :P
     // we need to disable blur or else we will get a black background, as the shader
     // will try to copy the bg to apply blur.
@@ -2445,7 +2438,7 @@ void CHyprRenderer::makeRawWindowSnapshot(PHLWINDOW pWindow, CFramebuffer* pFram
 
     g_pHyprOpenGL->clear(CHyprColor(0, 0, 0, 0)); // JIC
 
-    renderWindow(pWindow, PMONITOR, &now, false, RENDER_PASS_ALL, true);
+    renderWindow(pWindow, PMONITOR, Time::steadyNow(), false, RENDER_PASS_ALL, true);
 
     **PBLUR = BLURVAL;
 
@@ -2481,9 +2474,6 @@ void CHyprRenderer::makeWindowSnapshot(PHLWINDOW pWindow) {
 
     g_pHyprOpenGL->clear(CHyprColor(0, 0, 0, 0)); // JIC
 
-    timespec now;
-    clock_gettime(CLOCK_MONOTONIC, &now);
-
     // this is a hack but it works :P
     // we need to disable blur or else we will get a black background, as the shader
     // will try to copy the bg to apply blur.
@@ -2495,7 +2485,7 @@ void CHyprRenderer::makeWindowSnapshot(PHLWINDOW pWindow) {
 
     g_pHyprOpenGL->clear(CHyprColor(0, 0, 0, 0)); // JIC
 
-    renderWindow(pWindow, PMONITOR, &now, !pWindow->m_bX11DoesntWantBorders, RENDER_PASS_ALL);
+    renderWindow(pWindow, PMONITOR, Time::steadyNow(), !pWindow->m_bX11DoesntWantBorders, RENDER_PASS_ALL);
 
     **PBLUR = BLURVAL;
 
@@ -2528,14 +2518,11 @@ void CHyprRenderer::makeLayerSnapshot(PHLLS pLayer) {
 
     g_pHyprOpenGL->clear(CHyprColor(0, 0, 0, 0)); // JIC
 
-    timespec now;
-    clock_gettime(CLOCK_MONOTONIC, &now);
-
     const auto BLURLSSTATUS = pLayer->forceBlur;
     pLayer->forceBlur       = false;
 
     // draw the layer
-    renderLayer(pLayer, PMONITOR, &now);
+    renderLayer(pLayer, PMONITOR, Time::steadyNow());
 
     pLayer->forceBlur = BLURLSSTATUS;
 
diff --git a/src/render/Renderer.hpp b/src/render/Renderer.hpp
index 731ed926..1d0df2a5 100644
--- a/src/render/Renderer.hpp
+++ b/src/render/Renderer.hpp
@@ -6,8 +6,9 @@
 #include "../desktop/LayerSurface.hpp"
 #include "OpenGL.hpp"
 #include "Renderbuffer.hpp"
-#include "../helpers/Timer.hpp"
+#include "../helpers/time/Timer.hpp"
 #include "../helpers/math/Math.hpp"
+#include "../helpers/time/Time.hpp"
 
 struct SMonitorRule;
 class CWorkspace;
@@ -66,7 +67,7 @@ class CHyprRenderer {
     void calculateUVForSurface(PHLWINDOW, SP<CWLSurfaceResource>, PHLMONITOR pMonitor, bool main = false, const Vector2D& projSize = {}, const Vector2D& projSizeUnscaled = {},
                                bool fixMisalignedFSV1 = false);
     std::tuple<float, float, float> getRenderTimes(PHLMONITOR pMonitor); // avg max min
-    void                            renderLockscreen(PHLMONITOR pMonitor, timespec* now, const CBox& geometry);
+    void                            renderLockscreen(PHLMONITOR pMonitor, const Time::steady_tp& now, const CBox& geometry);
     void                            recheckSolitaryForMonitor(PHLMONITOR pMonitor);
     void                            setCursorSurface(SP<CWLSurface> surf, int hotspotX, int hotspotY, bool force = false);
     void                            setCursorFromName(const std::string& name, bool force = false);
@@ -115,27 +116,27 @@ class CHyprRenderer {
     CRenderPass m_sRenderPass = {};
 
   private:
-    void              arrangeLayerArray(PHLMONITOR, const std::vector<PHLLSREF>&, bool, CBox*);
-    void              renderWorkspaceWindowsFullscreen(PHLMONITOR, PHLWORKSPACE, timespec*); // renders workspace windows (fullscreen) (tiled, floating, pinned, but no special)
-    void              renderWorkspaceWindows(PHLMONITOR, PHLWORKSPACE, timespec*);           // renders workspace windows (no fullscreen) (tiled, floating, pinned, but no special)
-    void              renderWindow(PHLWINDOW, PHLMONITOR, timespec*, bool, eRenderPassMode, bool ignorePosition = false, bool standalone = false);
-    void              renderLayer(PHLLS, PHLMONITOR, timespec*, bool popups = false);
-    void              renderSessionLockSurface(WP<SSessionLockSurface>, PHLMONITOR, timespec*);
-    void              renderDragIcon(PHLMONITOR, timespec*);
-    void              renderIMEPopup(CInputPopup*, PHLMONITOR, timespec*);
-    void              renderWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, timespec* now, const CBox& geometry);
-    void              sendFrameEventsToWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, timespec* now); // sends frame displayed events but doesn't actually render anything
-    void              renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, timespec* now, const Vector2D& translate = {0, 0}, const float& scale = 1.f);
-    void              renderSessionLockMissing(PHLMONITOR pMonitor);
-
-    bool              commitPendingAndDoExplicitSync(PHLMONITOR pMonitor);
-
-    bool              m_bCursorHidden        = false;
-    bool              m_bCursorHasSurface    = false;
-    SP<CRenderbuffer> m_pCurrentRenderbuffer = nullptr;
-    SP<Aquamarine::IBuffer> m_pCurrentBuffer = nullptr;
-    eRenderMode             m_eRenderMode    = RENDER_MODE_NORMAL;
-    bool                    m_bNvidia        = false;
+    void arrangeLayerArray(PHLMONITOR, const std::vector<PHLLSREF>&, bool, CBox*);
+    void renderWorkspaceWindowsFullscreen(PHLMONITOR, PHLWORKSPACE, const Time::steady_tp&); // renders workspace windows (fullscreen) (tiled, floating, pinned, but no special)
+    void renderWorkspaceWindows(PHLMONITOR, PHLWORKSPACE, const Time::steady_tp&);           // renders workspace windows (no fullscreen) (tiled, floating, pinned, but no special)
+    void renderWindow(PHLWINDOW, PHLMONITOR, const Time::steady_tp&, bool, eRenderPassMode, bool ignorePosition = false, bool standalone = false);
+    void renderLayer(PHLLS, PHLMONITOR, const Time::steady_tp&, bool popups = false);
+    void renderSessionLockSurface(WP<SSessionLockSurface>, PHLMONITOR, const Time::steady_tp&);
+    void renderDragIcon(PHLMONITOR, const Time::steady_tp&);
+    void renderIMEPopup(CInputPopup*, PHLMONITOR, const Time::steady_tp&);
+    void renderWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, const Time::steady_tp& now, const CBox& geometry);
+    void sendFrameEventsToWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, const Time::steady_tp& now); // sends frame displayed events but doesn't actually render anything
+    void renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, const Time::steady_tp& now, const Vector2D& translate = {0, 0}, const float& scale = 1.f);
+    void renderSessionLockMissing(PHLMONITOR pMonitor);
+
+    bool commitPendingAndDoExplicitSync(PHLMONITOR pMonitor);
+
+    bool m_bCursorHidden                           = false;
+    bool m_bCursorHasSurface                       = false;
+    SP<CRenderbuffer>       m_pCurrentRenderbuffer = nullptr;
+    SP<Aquamarine::IBuffer> m_pCurrentBuffer       = nullptr;
+    eRenderMode             m_eRenderMode          = RENDER_MODE_NORMAL;
+    bool                    m_bNvidia              = false;
 
     struct {
         bool hiddenOnTouch    = false;
diff --git a/src/render/pass/SurfacePassElement.hpp b/src/render/pass/SurfacePassElement.hpp
index 1b6ddb0b..4d51f804 100644
--- a/src/render/pass/SurfacePassElement.hpp
+++ b/src/render/pass/SurfacePassElement.hpp
@@ -1,6 +1,7 @@
 #pragma once
 #include "PassElement.hpp"
 #include <optional>
+#include "../../helpers/time/Time.hpp"
 
 class CWLSurfaceResource;
 class CTexture;
@@ -10,7 +11,7 @@ class CSurfacePassElement : public IPassElement {
   public:
     struct SRenderData {
         PHLMONITORREF          pMonitor;
-        timespec*              when = nullptr;
+        Time::steady_tp        when = Time::steadyNow();
         Vector2D               pos, localPos;
 
         void*                  data        = nullptr;