renderer: move m_renderData to renderer (#13474)

1 files changed, 28 insertions, 27 deletions

diff --git a/src/render/pass/Pass.cpp b/src/render/pass/Pass.cpp
index 357c02cd..901b4770 100644
--- a/src/render/pass/Pass.cpp
+++ b/src/render/pass/Pass.cpp
@@ -24,6 +24,7 @@ void CRenderPass::add(UP<IPassElement>&& el) {
 }
 
 void CRenderPass::simplify() {
+    const auto  pMonitor   = g_pHyprRenderer->m_renderData.pMonitor;
     static auto PDEBUGPASS = CConfigValue<Hyprlang::INT>("debug:pass");
 
     // TODO: use precompute blur for instances where there is nothing in between
@@ -31,7 +32,7 @@ void CRenderPass::simplify() {
     // if there is live blur, we need to NOT occlude any area where it will be influenced
     const auto WILLBLUR = std::ranges::any_of(m_passElements, [](const auto& el) { return el->element->needsLiveBlur(); });
 
-    CRegion    newDamage = m_damage.copy().intersect(CBox{{}, g_pHyprOpenGL->m_renderData.pMonitor->m_transformedSize});
+    CRegion    newDamage = m_damage.copy().intersect(CBox{{}, pMonitor->m_transformedSize});
     for (auto& el : m_passElements | std::views::reverse) {
 
         if (newDamage.empty() && !el->element->undiscardable()) {
@@ -44,7 +45,7 @@ void CRenderPass::simplify() {
         if (!bb1 || newDamage.empty())
             continue;
 
-        auto bb = bb1->scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale);
+        auto bb = bb1->scale(pMonitor->m_scale);
 
         // drop if empty
         if (CRegion copy = newDamage.copy(); copy.intersect(bb).empty()) {
@@ -57,11 +58,11 @@ void CRenderPass::simplify() {
         if (!opaque.empty()) {
             // scale and rounding is very particular so we have to use CBoxes scale and round functions
             if (opaque.getRects().size() == 1)
-                opaque = opaque.getExtents().scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale).round();
+                opaque = opaque.getExtents().scale(pMonitor->m_scale).round();
             else {
                 CRegion scaledRegion;
-                opaque.forEachRect([&scaledRegion](const auto& RECT) {
-                    scaledRegion.add(CBox(RECT.x1, RECT.y1, RECT.x2 - RECT.x1, RECT.y2 - RECT.y1).scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale).round());
+                opaque.forEachRect([&scaledRegion, pMonitor](const auto& RECT) {
+                    scaledRegion.add(CBox(RECT.x1, RECT.y1, RECT.x2 - RECT.x1, RECT.y2 - RECT.y1).scale(pMonitor->m_scale).round());
                 });
                 opaque = scaledRegion;
             }
@@ -86,7 +87,7 @@ void CRenderPass::simplify() {
                 }
 
                 // expand the region: this area needs to be proper to blur it right.
-                liveBlurRegion.scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale).expand(oneBlurRadius() * 2.F);
+                liveBlurRegion.scale(pMonitor->m_scale).expand(oneBlurRadius() * 2.F);
 
                 if (auto infringement = opaque.copy().intersect(liveBlurRegion); !infringement.empty()) {
                     // eh, this is not the correct solution, but it will do...
@@ -108,7 +109,7 @@ void CRenderPass::simplify() {
             const auto BB = el2->element->boundingBox();
             RASSERT(BB, "No bounding box for an element with live blur is illegal");
 
-            m_totalLiveBlurRegion.add(BB->copy().scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale));
+            m_totalLiveBlurRegion.add(BB->copy().scale(pMonitor->m_scale));
         }
     }
 }
@@ -118,6 +119,7 @@ void CRenderPass::clear() {
 }
 
 CRegion CRenderPass::render(const CRegion& damage_) {
+    const auto  pMonitor   = g_pHyprRenderer->m_renderData.pMonitor;
     static auto PDEBUGPASS = CConfigValue<Hyprlang::INT>("debug:pass");
 
     const auto  WILLBLUR = std::ranges::any_of(m_passElements, [](const auto& el) { return el->element->needsLiveBlur(); });
@@ -129,8 +131,8 @@ CRegion CRenderPass::render(const CRegion& damage_) {
     }
 
     if (m_damage.empty()) {
-        g_pHyprOpenGL->m_renderData.damage      = m_damage;
-        g_pHyprOpenGL->m_renderData.finalDamage = m_damage;
+        g_pHyprRenderer->m_renderData.damage      = m_damage;
+        g_pHyprRenderer->m_renderData.finalDamage = m_damage;
         return m_damage;
     }
 
@@ -156,11 +158,11 @@ CRegion CRenderPass::render(const CRegion& damage_) {
             blurRegion.add(*BB);
         }
 
-        blurRegion.scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale);
+        blurRegion.scale(pMonitor->m_scale);
 
         blurRegion.intersect(m_damage).expand(oneBlurRadius());
 
-        g_pHyprOpenGL->m_renderData.finalDamage = blurRegion.copy().add(m_damage);
+        g_pHyprRenderer->m_renderData.finalDamage = blurRegion.copy().add(m_damage);
 
         // FIXME: why does this break on * 1.F ?
         // used to work when we expand all the damage... I think? Well, before pass.
@@ -169,16 +171,17 @@ CRegion CRenderPass::render(const CRegion& damage_) {
 
         m_damage = blurRegion.copy().add(m_damage);
     } else
-        g_pHyprOpenGL->m_renderData.finalDamage = m_damage;
+        g_pHyprRenderer->m_renderData.finalDamage = m_damage;
 
-    if (g_pHyprOpenGL->m_renderData.noSimplify || std::ranges::any_of(m_passElements, [](const auto& el) { return el->element->disableSimplification(); })) {
+    if (g_pHyprRenderer->m_renderData.noSimplify || std::ranges::any_of(m_passElements, [](const auto& el) { return el->element->disableSimplification(); })) {
         for (auto& el : m_passElements) {
             el->elementDamage = m_damage;
         }
     } else
         simplify();
 
-    g_pHyprOpenGL->m_renderData.pMonitor->m_blurFBShouldRender = std::ranges::any_of(m_passElements, [](const auto& el) { return el->element->needsPrecomputeBlur(); });
+    if (g_pHyprRenderer->m_renderData.pMonitor)
+        g_pHyprRenderer->m_renderData.pMonitor->m_blurFBShouldRender = std::ranges::any_of(m_passElements, [](const auto& el) { return el->element->needsPrecomputeBlur(); });
 
     if (m_passElements.empty())
         return {};
@@ -189,7 +192,7 @@ CRegion CRenderPass::render(const CRegion& damage_) {
             continue;
         }
 
-        g_pHyprOpenGL->m_renderData.damage = el->elementDamage;
+        g_pHyprRenderer->m_renderData.damage = el->elementDamage;
         g_pHyprRenderer->draw(el->element, el->elementDamage);
     }
 
@@ -202,12 +205,13 @@ CRegion CRenderPass::render(const CRegion& damage_) {
         });
     }
 
-    g_pHyprOpenGL->m_renderData.damage = m_damage;
+    g_pHyprRenderer->m_renderData.damage = m_damage;
     return m_damage;
 }
 
 void CRenderPass::renderDebugData() {
-    CBox box = {{}, g_pHyprOpenGL->m_renderData.pMonitor->m_transformedSize};
+    const auto pMonitor = g_pHyprRenderer->m_renderData.pMonitor;
+    CBox       box      = {{}, pMonitor->m_transformedSize};
     for (const auto& rg : m_occludedRegions) {
         g_pHyprOpenGL->renderRect(box, Colors::RED.modifyA(0.1F), {.damage = &rg});
     }
@@ -216,7 +220,7 @@ void CRenderPass::renderDebugData() {
     std::unordered_map<CWLSurfaceResource*, float> offsets;
 
     // render focus stuff
-    auto renderHLSurface = [&offsets](SP<ITexture> texture, SP<CWLSurfaceResource> surface, const CHyprColor& color) {
+    auto renderHLSurface = [&offsets, pMonitor](SP<ITexture> texture, SP<CWLSurfaceResource> surface, const CHyprColor& color) {
         if (!surface || !texture)
             return;
 
@@ -229,9 +233,9 @@ void CRenderPass::renderDebugData() {
         if (!bb.has_value())
             return;
 
-        CBox box = bb->copy().translate(-g_pHyprOpenGL->m_renderData.pMonitor->m_position).scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale);
+        CBox box = bb->copy().translate(-pMonitor->m_position).scale(pMonitor->m_scale);
 
-        if (box.intersection(CBox{{}, g_pHyprOpenGL->m_renderData.pMonitor->m_size}).empty())
+        if (box.intersection(CBox{{}, pMonitor->m_size}).empty())
             return;
 
         static const auto FULL_REGION = CRegion{0, 0, INT32_MAX, INT32_MAX};
@@ -262,9 +266,7 @@ void CRenderPass::renderDebugData() {
             if (hlSurface) {
                 auto BOX = hlSurface->getSurfaceBoxGlobal();
                 if (BOX) {
-                    auto region = g_pSeatManager->m_state.pointerFocus->m_current.input.copy()
-                                      .scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale)
-                                      .translate(BOX->pos() - g_pHyprOpenGL->m_renderData.pMonitor->m_position);
+                    auto region = g_pSeatManager->m_state.pointerFocus->m_current.input.copy().scale(pMonitor->m_scale).translate(BOX->pos() - pMonitor->m_position);
                     g_pHyprOpenGL->renderRect(box, CHyprColor{0.8F, 0.8F, 0.2F, 0.4F}, {.damage = &region});
                 }
             }
@@ -273,11 +275,11 @@ void CRenderPass::renderDebugData() {
 
     const auto DISCARDED_ELEMENTS = std::ranges::count_if(m_passElements, [](const auto& e) { return e->discard; });
     auto tex = g_pHyprRenderer->renderText(std::format("occlusion layers: {}\npass elements: {} ({} discarded)\nviewport: {:X0}", m_occludedRegions.size(), m_passElements.size(),
-                                                       DISCARDED_ELEMENTS, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize),
+                                                       DISCARDED_ELEMENTS, pMonitor->m_pixelSize),
                                            Colors::WHITE, 12);
 
     if (tex) {
-        box = CBox{{0.F, g_pHyprOpenGL->m_renderData.pMonitor->m_size.y - tex->m_size.y}, tex->m_size}.scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale);
+        box = CBox{{0.F, pMonitor->m_size.y - tex->m_size.y}, tex->m_size}.scale(pMonitor->m_scale);
         g_pHyprOpenGL->renderTexture(tex, box, {});
     }
 
@@ -294,8 +296,7 @@ void CRenderPass::renderDebugData() {
 
     tex = g_pHyprRenderer->renderText(passStructure, Colors::WHITE, 12);
     if (tex) {
-        box = CBox{{g_pHyprOpenGL->m_renderData.pMonitor->m_size.x - tex->m_size.x, g_pHyprOpenGL->m_renderData.pMonitor->m_size.y - tex->m_size.y}, tex->m_size}.scale(
-            g_pHyprOpenGL->m_renderData.pMonitor->m_scale);
+        box = CBox{{pMonitor->m_size.x - tex->m_size.x, pMonitor->m_size.y - tex->m_size.y}, tex->m_size}.scale(pMonitor->m_scale);
         g_pHyprOpenGL->renderTexture(tex, box, {});
     }
 }