renderer: move m_renderData to renderer (#13474)

11 files changed, 526 insertions, 447 deletions

diff --git a/src/render/OpenGL.cpp b/src/render/OpenGL.cpp
index 0a54613c..f9cb83ac 100644
--- a/src/render/OpenGL.cpp
+++ b/src/render/OpenGL.cpp
@@ -641,7 +641,7 @@ EGLImageKHR CHyprOpenGLImpl::createEGLImage(const Aquamarine::SDMABUFAttrs& attr
 }
 
 void CHyprOpenGLImpl::beginSimple(PHLMONITOR pMonitor, const CRegion& damage, SP<IRenderbuffer> rb, SP<IFramebuffer> fb) {
-    m_renderData.pMonitor = pMonitor;
+    g_pHyprRenderer->m_renderData.pMonitor = pMonitor;
 
     const GLenum RESETSTATUS = glGetGraphicsResetStatus();
     if (RESETSTATUS != GL_NO_ERROR) {
@@ -662,29 +662,29 @@ void CHyprOpenGLImpl::beginSimple(PHLMONITOR pMonitor, const CRegion& damage, SP
 
     setViewport(0, 0, pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y);
 
-    m_renderData.projection = Mat3x3::outputProjection(pMonitor->m_pixelSize, HYPRUTILS_TRANSFORM_NORMAL);
+    g_pHyprRenderer->m_renderData.projection = Mat3x3::outputProjection(pMonitor->m_pixelSize, HYPRUTILS_TRANSFORM_NORMAL);
 
-    m_renderData.monitorProjection = Mat3x3::identity();
+    g_pHyprRenderer->m_renderData.monitorProjection = Mat3x3::identity();
     if (pMonitor->m_transform != WL_OUTPUT_TRANSFORM_NORMAL) {
         const Vector2D tfmd = pMonitor->m_transform % 2 == 1 ? Vector2D{FBO->m_size.y, FBO->m_size.x} : FBO->m_size;
-        m_renderData.monitorProjection.translate(FBO->m_size / 2.0).transform(Math::wlTransformToHyprutils(pMonitor->m_transform)).translate(-tfmd / 2.0);
+        g_pHyprRenderer->m_renderData.monitorProjection.translate(FBO->m_size / 2.0).transform(Math::wlTransformToHyprutils(pMonitor->m_transform)).translate(-tfmd / 2.0);
     }
 
     if (!m_shadersInitialized)
         initShaders();
 
-    m_renderData.transformDamage = true;
-    m_renderData.damage.set(damage);
-    m_renderData.finalDamage.set(damage);
+    g_pHyprRenderer->m_renderData.transformDamage = true;
+    g_pHyprRenderer->m_renderData.damage.set(damage);
+    g_pHyprRenderer->m_renderData.finalDamage.set(damage);
 
     m_fakeFrame = true;
 
-    m_renderData.currentFB = FBO;
+    g_pHyprRenderer->m_renderData.currentFB = FBO;
     FBO->bind();
     m_offloadedFramebuffer = false;
 
-    m_renderData.mainFB = m_renderData.currentFB;
-    m_renderData.outFB  = FBO;
+    g_pHyprRenderer->m_renderData.mainFB = g_pHyprRenderer->m_renderData.currentFB;
+    g_pHyprRenderer->m_renderData.outFB  = FBO;
 
     g_pHyprRenderer->pushMonitorTransformEnabled(false);
 }
@@ -698,7 +698,7 @@ void CHyprOpenGLImpl::makeEGLCurrent() {
 }
 
 void CHyprOpenGLImpl::begin(PHLMONITOR pMonitor, const CRegion& damage_, SP<IFramebuffer> fb, std::optional<CRegion> finalDamage) {
-    m_renderData.pMonitor = pMonitor;
+    g_pHyprRenderer->m_renderData.pMonitor = pMonitor;
 
     const GLenum RESETSTATUS = glGetGraphicsResetStatus();
     if (RESETSTATUS != GL_NO_ERROR) {
@@ -717,9 +717,9 @@ void CHyprOpenGLImpl::begin(PHLMONITOR pMonitor, const CRegion& damage_, SP<IFra
 
     setViewport(0, 0, pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y);
 
-    m_renderData.projection = Mat3x3::outputProjection(pMonitor->m_pixelSize, HYPRUTILS_TRANSFORM_NORMAL);
+    g_pHyprRenderer->m_renderData.projection = Mat3x3::outputProjection(pMonitor->m_pixelSize, HYPRUTILS_TRANSFORM_NORMAL);
 
-    m_renderData.monitorProjection = pMonitor->m_projMatrix;
+    g_pHyprRenderer->m_renderData.monitorProjection = pMonitor->m_projMatrix;
 
     if (pMonitor && (!pMonitor->m_offloadFB || pMonitor->m_offloadFB->m_size != pMonitor->m_pixelSize))
         destroyMonitorResources(pMonitor);
@@ -730,39 +730,40 @@ void CHyprOpenGLImpl::begin(PHLMONITOR pMonitor, const CRegion& damage_, SP<IFra
     const auto DRM_FORMAT = fb ? fb->m_drmFormat : pMonitor->m_output->state->state().drmFormat;
 
     // ensure a framebuffer for the monitor exists
-    if (!m_renderData.pMonitor->m_offloadFB || m_renderData.pMonitor->m_offloadFB->m_size != pMonitor->m_pixelSize ||
-        DRM_FORMAT != m_renderData.pMonitor->m_offloadFB->m_drmFormat) {
-        m_renderData.pMonitor->m_stencilTex   = g_pHyprRenderer->createStencilTexture(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y);
-        m_renderData.pMonitor->m_offloadFB    = g_pHyprRenderer->createFB();
-        m_renderData.pMonitor->m_mirrorFB     = g_pHyprRenderer->createFB();
-        m_renderData.pMonitor->m_mirrorSwapFB = g_pHyprRenderer->createFB();
+    if (!g_pHyprRenderer->m_renderData.pMonitor->m_offloadFB || g_pHyprRenderer->m_renderData.pMonitor->m_offloadFB->m_size != pMonitor->m_pixelSize ||
+        DRM_FORMAT != g_pHyprRenderer->m_renderData.pMonitor->m_offloadFB->m_drmFormat) {
+        g_pHyprRenderer->m_renderData.pMonitor->m_stencilTex   = g_pHyprRenderer->createStencilTexture(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y);
+        g_pHyprRenderer->m_renderData.pMonitor->m_offloadFB    = g_pHyprRenderer->createFB();
+        g_pHyprRenderer->m_renderData.pMonitor->m_mirrorFB     = g_pHyprRenderer->createFB();
+        g_pHyprRenderer->m_renderData.pMonitor->m_mirrorSwapFB = g_pHyprRenderer->createFB();
 
-        m_renderData.pMonitor->m_offloadFB->addStencil(m_renderData.pMonitor->m_stencilTex);
-        m_renderData.pMonitor->m_mirrorFB->addStencil(m_renderData.pMonitor->m_stencilTex);
-        m_renderData.pMonitor->m_mirrorSwapFB->addStencil(m_renderData.pMonitor->m_stencilTex);
+        g_pHyprRenderer->m_renderData.pMonitor->m_offloadFB->addStencil(g_pHyprRenderer->m_renderData.pMonitor->m_stencilTex);
+        g_pHyprRenderer->m_renderData.pMonitor->m_mirrorFB->addStencil(g_pHyprRenderer->m_renderData.pMonitor->m_stencilTex);
+        g_pHyprRenderer->m_renderData.pMonitor->m_mirrorSwapFB->addStencil(g_pHyprRenderer->m_renderData.pMonitor->m_stencilTex);
 
-        m_renderData.pMonitor->m_offloadFB->alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, DRM_FORMAT);
-        m_renderData.pMonitor->m_mirrorFB->alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, DRM_FORMAT);
-        m_renderData.pMonitor->m_mirrorSwapFB->alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, DRM_FORMAT);
+        g_pHyprRenderer->m_renderData.pMonitor->m_offloadFB->alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, DRM_FORMAT);
+        g_pHyprRenderer->m_renderData.pMonitor->m_mirrorFB->alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, DRM_FORMAT);
+        g_pHyprRenderer->m_renderData.pMonitor->m_mirrorSwapFB->alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, DRM_FORMAT);
     }
 
-    const bool HAS_MIRROR_FB = m_renderData.pMonitor->m_monitorMirrorFB && m_renderData.pMonitor->m_monitorMirrorFB->isAllocated();
-    const bool NEEDS_COPY_FB = needsACopyFB(m_renderData.pMonitor.lock());
+    const bool HAS_MIRROR_FB = g_pHyprRenderer->m_renderData.pMonitor->m_monitorMirrorFB && g_pHyprRenderer->m_renderData.pMonitor->m_monitorMirrorFB->isAllocated();
+    const bool NEEDS_COPY_FB = needsACopyFB(g_pHyprRenderer->m_renderData.pMonitor.lock());
 
     if (HAS_MIRROR_FB && !NEEDS_COPY_FB)
-        m_renderData.pMonitor->m_monitorMirrorFB->release();
-    else if (!HAS_MIRROR_FB && NEEDS_COPY_FB && m_renderData.pMonitor->m_monitorMirrorFB)
-        m_renderData.pMonitor->m_monitorMirrorFB->alloc(m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y,
-                                                        m_renderData.pMonitor->m_output->state->state().drmFormat);
+        g_pHyprRenderer->m_renderData.pMonitor->m_monitorMirrorFB->release();
+    else if (!HAS_MIRROR_FB && NEEDS_COPY_FB && g_pHyprRenderer->m_renderData.pMonitor->m_monitorMirrorFB)
+        g_pHyprRenderer->m_renderData.pMonitor->m_monitorMirrorFB->alloc(g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.x,
+                                                                         g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.y,
+                                                                         g_pHyprRenderer->m_renderData.pMonitor->m_output->state->state().drmFormat);
 
-    m_renderData.transformDamage = true;
+    g_pHyprRenderer->m_renderData.transformDamage = true;
     if (HAS_MIRROR_FB != NEEDS_COPY_FB) {
         // force full damage because the mirror fb will be empty
-        m_renderData.damage.set({0, 0, INT32_MAX, INT32_MAX});
-        m_renderData.finalDamage.set(m_renderData.damage);
+        g_pHyprRenderer->m_renderData.damage.set({0, 0, INT32_MAX, INT32_MAX});
+        g_pHyprRenderer->m_renderData.finalDamage.set(g_pHyprRenderer->m_renderData.damage);
     } else {
-        m_renderData.damage.set(damage_);
-        m_renderData.finalDamage.set(finalDamage.value_or(damage_));
+        g_pHyprRenderer->m_renderData.damage.set(damage_);
+        g_pHyprRenderer->m_renderData.finalDamage.set(finalDamage.value_or(damage_));
     }
 
     m_fakeFrame = fb;
@@ -773,12 +774,12 @@ void CHyprOpenGLImpl::begin(PHLMONITOR pMonitor, const CRegion& damage_, SP<IFra
         applyScreenShader(*PSHADER);
     }
 
-    m_renderData.pMonitor->m_offloadFB->bind();
-    m_renderData.currentFB = m_renderData.pMonitor->m_offloadFB;
-    m_offloadedFramebuffer = true;
+    g_pHyprRenderer->m_renderData.pMonitor->m_offloadFB->bind();
+    g_pHyprRenderer->m_renderData.currentFB = g_pHyprRenderer->m_renderData.pMonitor->m_offloadFB;
+    m_offloadedFramebuffer                  = true;
 
-    m_renderData.mainFB = m_renderData.currentFB;
-    m_renderData.outFB  = fb ? fb : g_pHyprRenderer->getCurrentRBO()->getFB();
+    g_pHyprRenderer->m_renderData.mainFB = g_pHyprRenderer->m_renderData.currentFB;
+    g_pHyprRenderer->m_renderData.outFB  = fb ? fb : g_pHyprRenderer->getCurrentRBO()->getFB();
 
     g_pHyprRenderer->pushMonitorTransformEnabled(false);
 }
@@ -788,83 +789,84 @@ void CHyprOpenGLImpl::end() {
 
     TRACY_GPU_ZONE("RenderEnd");
 
-    m_renderData.currentWindow.reset();
-    m_renderData.surface.reset();
-    m_renderData.currentLS.reset();
-    m_renderData.clipBox = {};
-    m_renderData.clipRegion.clear();
+    g_pHyprRenderer->m_renderData.currentWindow.reset();
+    g_pHyprRenderer->m_renderData.surface.reset();
+    g_pHyprRenderer->m_renderData.currentLS.reset();
+    g_pHyprRenderer->m_renderData.clipBox = {};
+    g_pHyprRenderer->m_renderData.clipRegion.clear();
 
     // end the render, copy the data to the main framebuffer
     if LIKELY (m_offloadedFramebuffer) {
-        m_renderData.damage = m_renderData.finalDamage;
+        g_pHyprRenderer->m_renderData.damage = g_pHyprRenderer->m_renderData.finalDamage;
         g_pHyprRenderer->pushMonitorTransformEnabled(true);
 
-        CBox monbox = {0, 0, m_renderData.pMonitor->m_transformedSize.x, m_renderData.pMonitor->m_transformedSize.y};
+        CBox monbox = {0, 0, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y};
 
-        if LIKELY (g_pHyprRenderer->m_renderMode == RENDER_MODE_NORMAL && m_renderData.mouseZoomFactor == 1.0f)
-            m_renderData.pMonitor->m_zoomController.m_resetCameraState = true;
-        m_renderData.pMonitor->m_zoomController.applyZoomTransform(monbox, m_renderData);
+        if LIKELY (g_pHyprRenderer->m_renderMode == RENDER_MODE_NORMAL && g_pHyprRenderer->m_renderData.mouseZoomFactor == 1.0f)
+            g_pHyprRenderer->m_renderData.pMonitor->m_zoomController.m_resetCameraState = true;
+        g_pHyprRenderer->m_renderData.pMonitor->m_zoomController.applyZoomTransform(monbox, g_pHyprRenderer->m_renderData);
 
-        m_applyFinalShader = !m_renderData.blockScreenShader;
-        if UNLIKELY (m_renderData.mouseZoomFactor != 1.F && m_renderData.mouseZoomUseMouse && *PZOOMDISABLEAA)
-            m_renderData.useNearestNeighbor = true;
+        m_applyFinalShader = !g_pHyprRenderer->m_renderData.blockScreenShader;
+        if UNLIKELY (g_pHyprRenderer->m_renderData.mouseZoomFactor != 1.F && g_pHyprRenderer->m_renderData.mouseZoomUseMouse && *PZOOMDISABLEAA)
+            g_pHyprRenderer->m_renderData.useNearestNeighbor = true;
 
         // copy the damaged areas into the mirror buffer
         // we can't use the offloadFB for mirroring / ss, as it contains artifacts from blurring
-        if UNLIKELY (needsACopyFB(m_renderData.pMonitor.lock()) && !m_fakeFrame)
+        if UNLIKELY (needsACopyFB(g_pHyprRenderer->m_renderData.pMonitor.lock()) && !m_fakeFrame)
             saveBufferForMirror(monbox);
 
-        m_renderData.outFB->bind();
+        g_pHyprRenderer->m_renderData.outFB->bind();
         blend(false);
 
-        const auto PRIMITIVE_BLOCKED =
-            m_finalScreenShader->program() >= 1 || g_pHyprRenderer->m_crashingInProgress || m_renderData.pMonitor->m_imageDescription->value() != SImageDescription{};
+        const auto PRIMITIVE_BLOCKED = m_finalScreenShader->program() >= 1 || g_pHyprRenderer->m_crashingInProgress ||
+            g_pHyprRenderer->m_renderData.pMonitor->m_imageDescription->value() != SImageDescription{};
 
         if LIKELY (!PRIMITIVE_BLOCKED || g_pHyprRenderer->m_renderMode != RENDER_MODE_NORMAL)
-            renderTexturePrimitive(m_renderData.pMonitor->m_offloadFB->getTexture(), monbox);
+            renderTexturePrimitive(g_pHyprRenderer->m_renderData.pMonitor->m_offloadFB->getTexture(), monbox);
         else // we need to use renderTexture if we do any CM whatsoever.
-            renderTexture(m_renderData.pMonitor->m_offloadFB->getTexture(), monbox, {.finalMonitorCM = true});
+            renderTexture(g_pHyprRenderer->m_renderData.pMonitor->m_offloadFB->getTexture(), monbox, {.finalMonitorCM = true});
 
         blend(true);
 
-        m_renderData.useNearestNeighbor = false;
-        m_applyFinalShader              = false;
+        g_pHyprRenderer->m_renderData.useNearestNeighbor = false;
+        m_applyFinalShader                               = false;
         g_pHyprRenderer->popMonitorTransformEnabled();
     }
 
     // invalidate our render FBs to signal to the driver we don't need them anymore
-    if (m_renderData.pMonitor->m_mirrorFB) {
-        m_renderData.pMonitor->m_mirrorFB->bind();
-        GLFB(m_renderData.pMonitor->m_mirrorFB)->invalidate({GL_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0});
+    if (g_pHyprRenderer->m_renderData.pMonitor->m_mirrorFB) {
+        g_pHyprRenderer->m_renderData.pMonitor->m_mirrorFB->bind();
+        GLFB(g_pHyprRenderer->m_renderData.pMonitor->m_mirrorFB)->invalidate({GL_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0});
     }
-    if (m_renderData.pMonitor->m_mirrorSwapFB) {
-        m_renderData.pMonitor->m_mirrorSwapFB->bind();
-        GLFB(m_renderData.pMonitor->m_mirrorSwapFB)->invalidate({GL_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0});
+    if (g_pHyprRenderer->m_renderData.pMonitor->m_mirrorSwapFB) {
+        g_pHyprRenderer->m_renderData.pMonitor->m_mirrorSwapFB->bind();
+        GLFB(g_pHyprRenderer->m_renderData.pMonitor->m_mirrorSwapFB)->invalidate({GL_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0});
     }
-    if (m_renderData.pMonitor->m_offloadFB) {
-        m_renderData.pMonitor->m_offloadFB->bind();
-        GLFB(m_renderData.pMonitor->m_offloadFB)->invalidate({GL_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0});
+    if (g_pHyprRenderer->m_renderData.pMonitor->m_offloadFB) {
+        g_pHyprRenderer->m_renderData.pMonitor->m_offloadFB->bind();
+        GLFB(g_pHyprRenderer->m_renderData.pMonitor->m_offloadFB)->invalidate({GL_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0});
     }
-    if (m_renderData.pMonitor->m_offMainFB) {
-        m_renderData.pMonitor->m_offMainFB->bind();
-        GLFB(m_renderData.pMonitor->m_offMainFB)->invalidate({GL_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0});
+    if (g_pHyprRenderer->m_renderData.pMonitor->m_offMainFB) {
+        g_pHyprRenderer->m_renderData.pMonitor->m_offMainFB->bind();
+        GLFB(g_pHyprRenderer->m_renderData.pMonitor->m_offMainFB)->invalidate({GL_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0});
     }
 
     // reset our data
-    m_renderData.pMonitor.reset();
-    m_renderData.mouseZoomFactor   = 1.f;
-    m_renderData.mouseZoomUseMouse = true;
-    m_renderData.blockScreenShader = false;
-    m_renderData.currentFB         = nullptr;
-    m_renderData.mainFB            = nullptr;
-    m_renderData.outFB             = nullptr;
+    g_pHyprRenderer->m_renderData.pMonitor.reset();
+    g_pHyprRenderer->m_renderData.mouseZoomFactor   = 1.f;
+    g_pHyprRenderer->m_renderData.mouseZoomUseMouse = true;
+    g_pHyprRenderer->m_renderData.blockScreenShader = false;
+    g_pHyprRenderer->m_renderData.currentFB         = nullptr;
+    g_pHyprRenderer->m_renderData.mainFB            = nullptr;
+    g_pHyprRenderer->m_renderData.outFB             = nullptr;
     g_pHyprRenderer->popMonitorTransformEnabled();
 
     // if we dropped to offMain, release it now.
     // if there is a plugin constantly using it, this might be a bit slow,
     // but I haven't seen a single plugin yet use these, so it's better to drop a bit of vram.
-    if UNLIKELY (m_renderData.pMonitor && m_renderData.pMonitor->m_offMainFB && m_renderData.pMonitor->m_offMainFB->isAllocated())
-        m_renderData.pMonitor->m_offMainFB->release();
+    if UNLIKELY (g_pHyprRenderer->m_renderData.pMonitor && g_pHyprRenderer->m_renderData.pMonitor->m_offMainFB &&
+                 g_pHyprRenderer->m_renderData.pMonitor->m_offMainFB->isAllocated())
+        g_pHyprRenderer->m_renderData.pMonitor->m_offMainFB->release();
 
     static const auto GLDEBUG = CConfigValue<Hyprlang::INT>("debug:gl_debugging");
 
@@ -882,8 +884,8 @@ bool CHyprOpenGLImpl::needsACopyFB(PHLMONITOR mon) {
 }
 
 void CHyprOpenGLImpl::setDamage(const CRegion& damage_, std::optional<CRegion> finalDamage) {
-    m_renderData.damage.set(damage_);
-    m_renderData.finalDamage.set(finalDamage.value_or(damage_));
+    g_pHyprRenderer->m_renderData.damage.set(damage_);
+    g_pHyprRenderer->m_renderData.finalDamage.set(finalDamage.value_or(damage_));
 }
 
 static const std::vector<std::string> SHADER_INCLUDES = {
@@ -987,15 +989,15 @@ void CHyprOpenGLImpl::applyScreenShader(const std::string& path) {
 }
 
 void CHyprOpenGLImpl::clear(const CHyprColor& color) {
-    RASSERT(m_renderData.pMonitor, "Tried to render without begin()!");
+    RASSERT(g_pHyprRenderer->m_renderData.pMonitor, "Tried to render without begin()!");
 
     TRACY_GPU_ZONE("RenderClear");
 
     GLCALL(glClearColor(color.r, color.g, color.b, color.a));
 
-    if (!m_renderData.damage.empty()) {
-        m_renderData.damage.forEachRect([this](const auto& RECT) {
-            scissor(&RECT, m_renderData.transformDamage);
+    if (!g_pHyprRenderer->m_renderData.damage.empty()) {
+        g_pHyprRenderer->m_renderData.damage.forEachRect([this](const auto& RECT) {
+            scissor(&RECT, g_pHyprRenderer->m_renderData.transformDamage);
             glClear(GL_COLOR_BUFFER_BIT);
         });
     }
@@ -1012,15 +1014,15 @@ void CHyprOpenGLImpl::blend(bool enabled) {
 }
 
 void CHyprOpenGLImpl::scissor(const CBox& originalBox, bool transform) {
-    RASSERT(m_renderData.pMonitor, "Tried to scissor without begin()!");
+    RASSERT(g_pHyprRenderer->m_renderData.pMonitor, "Tried to scissor without begin()!");
 
     // only call glScissor if the box has changed
     static CBox m_lastScissorBox = {};
 
     if (transform) {
         CBox       box = originalBox;
-        const auto TR  = Math::wlTransformToHyprutils(Math::invertTransform(m_renderData.pMonitor->m_transform));
-        box.transform(TR, m_renderData.pMonitor->m_transformedSize.x, m_renderData.pMonitor->m_transformedSize.y);
+        const auto TR  = Math::wlTransformToHyprutils(Math::invertTransform(g_pHyprRenderer->m_renderData.pMonitor->m_transform));
+        box.transform(TR, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y);
 
         if (box != m_lastScissorBox) {
             GLCALL(glScissor(box.x, box.y, box.width, box.height));
@@ -1040,7 +1042,7 @@ void CHyprOpenGLImpl::scissor(const CBox& originalBox, bool transform) {
 }
 
 void CHyprOpenGLImpl::scissor(const pixman_box32* pBox, bool transform) {
-    RASSERT(m_renderData.pMonitor, "Tried to scissor without begin()!");
+    RASSERT(g_pHyprRenderer->m_renderData.pMonitor, "Tried to scissor without begin()!");
 
     if (!pBox) {
         setCapStatus(GL_SCISSOR_TEST, false);
@@ -1059,7 +1061,7 @@ void CHyprOpenGLImpl::scissor(const int x, const int y, const int w, const int h
 
 void CHyprOpenGLImpl::renderRect(const CBox& box, const CHyprColor& col, SRectRenderData data) {
     if (!data.damage)
-        data.damage = &m_renderData.damage;
+        data.damage = &g_pHyprRenderer->m_renderData.damage;
 
     if (data.blur)
         renderRectWithBlurInternal(box, col, data);
@@ -1071,38 +1073,40 @@ void CHyprOpenGLImpl::renderRectWithBlurInternal(const CBox& box, const CHyprCol
     if (data.damage->empty())
         return;
 
-    CRegion damage{m_renderData.damage};
+    CRegion damage{g_pHyprRenderer->m_renderData.damage};
     damage.intersect(box);
 
-    auto POUTFB = data.xray ? m_renderData.pMonitor->m_blurFB : blurMainFramebufferWithDamage(data.blurA, &damage);
+    auto POUTFB = data.xray ? g_pHyprRenderer->m_renderData.pMonitor->m_blurFB : blurMainFramebufferWithDamage(data.blurA, &damage);
 
-    m_renderData.currentFB->bind();
+    g_pHyprRenderer->m_renderData.currentFB->bind();
 
-    CBox MONITORBOX = {0, 0, m_renderData.pMonitor->m_transformedSize.x, m_renderData.pMonitor->m_transformedSize.y};
+    CBox MONITORBOX = {0, 0, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y};
     g_pHyprRenderer->pushMonitorTransformEnabled(true);
-    const auto SAVEDRENDERMODIF = m_renderData.renderModif;
-    m_renderData.renderModif    = {}; // fix shit
+    const auto SAVEDRENDERMODIF               = g_pHyprRenderer->m_renderData.renderModif;
+    g_pHyprRenderer->m_renderData.renderModif = {}; // fix shit
     renderTexture(POUTFB->getTexture(), MONITORBOX,
                   STextureRenderData{.damage = &damage, .a = data.blurA, .round = data.round, .roundingPower = 2.F, .allowCustomUV = false, .allowDim = false, .noAA = false});
     g_pHyprRenderer->popMonitorTransformEnabled();
-    m_renderData.renderModif = SAVEDRENDERMODIF;
+    g_pHyprRenderer->m_renderData.renderModif = SAVEDRENDERMODIF;
 
     renderRectWithDamageInternal(box, col, data);
 }
 
 void CHyprOpenGLImpl::renderRectWithDamageInternal(const CBox& box, const CHyprColor& col, const SRectRenderData& data) {
     RASSERT((box.width > 0 && box.height > 0), "Tried to render rect with width/height < 0!");
-    RASSERT(m_renderData.pMonitor, "Tried to render rect without begin()!");
+    RASSERT(g_pHyprRenderer->m_renderData.pMonitor, "Tried to render rect without begin()!");
 
     TRACY_GPU_ZONE("RenderRectWithDamage");
 
     CBox newBox = box;
-    m_renderData.renderModif.applyToBox(newBox);
+    g_pHyprRenderer->m_renderData.renderModif.applyToBox(newBox);
 
-    Mat3x3 matrix = m_renderData.monitorProjection.projectBox(
-        newBox, Math::wlTransformToHyprutils(Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform)),
+    Mat3x3 matrix = g_pHyprRenderer->m_renderData.monitorProjection.projectBox(
+        newBox,
+        Math::wlTransformToHyprutils(
+            Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : g_pHyprRenderer->m_renderData.pMonitor->m_transform)),
         newBox.rot);
-    Mat3x3 glMatrix = m_renderData.projection.copy().multiply(matrix);
+    Mat3x3 glMatrix = g_pHyprRenderer->m_renderData.projection.copy().multiply(matrix);
 
     auto   shader = useShader(getShaderVariant(SH_FRAG_QUAD, data.round > 0 ? SH_FEAT_ROUNDING : 0));
     shader->setUniformMatrix3fv(SHADER_PROJ, 1, GL_TRUE, glMatrix.getMatrix());
@@ -1111,8 +1115,8 @@ void CHyprOpenGLImpl::renderRectWithDamageInternal(const CBox& box, const CHyprC
     shader->setUniformFloat4(SHADER_COLOR, col.r * col.a, col.g * col.a, col.b * col.a, col.a);
 
     CBox transformedBox = box;
-    transformedBox.transform(Math::wlTransformToHyprutils(Math::invertTransform(m_renderData.pMonitor->m_transform)), m_renderData.pMonitor->m_transformedSize.x,
-                             m_renderData.pMonitor->m_transformedSize.y);
+    transformedBox.transform(Math::wlTransformToHyprutils(Math::invertTransform(g_pHyprRenderer->m_renderData.pMonitor->m_transform)),
+                             g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y);
 
     const auto TOPLEFT  = Vector2D(transformedBox.x, transformedBox.y);
     const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height);
@@ -1125,19 +1129,20 @@ void CHyprOpenGLImpl::renderRectWithDamageInternal(const CBox& box, const CHyprC
 
     glBindVertexArray(shader->getUniformLocation(SHADER_SHADER_VAO));
 
-    if (m_renderData.clipBox.width != 0 && m_renderData.clipBox.height != 0) {
-        CRegion damageClip{m_renderData.clipBox.x, m_renderData.clipBox.y, m_renderData.clipBox.width, m_renderData.clipBox.height};
+    if (g_pHyprRenderer->m_renderData.clipBox.width != 0 && g_pHyprRenderer->m_renderData.clipBox.height != 0) {
+        CRegion damageClip{g_pHyprRenderer->m_renderData.clipBox.x, g_pHyprRenderer->m_renderData.clipBox.y, g_pHyprRenderer->m_renderData.clipBox.width,
+                           g_pHyprRenderer->m_renderData.clipBox.height};
         damageClip.intersect(*data.damage);
 
         if (!damageClip.empty()) {
             damageClip.forEachRect([this](const auto& RECT) {
-                scissor(&RECT, m_renderData.transformDamage);
+                scissor(&RECT, g_pHyprRenderer->m_renderData.transformDamage);
                 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
             });
         }
     } else {
         data.damage->forEachRect([this](const auto& RECT) {
-            scissor(&RECT, m_renderData.transformDamage);
+            scissor(&RECT, g_pHyprRenderer->m_renderData.transformDamage);
             glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
         });
     }
@@ -1147,13 +1152,13 @@ void CHyprOpenGLImpl::renderRectWithDamageInternal(const CBox& box, const CHyprC
 }
 
 void CHyprOpenGLImpl::renderTexture(SP<ITexture> tex, const CBox& box, STextureRenderData data) {
-    RASSERT(m_renderData.pMonitor, "Tried to render texture without begin()!");
+    RASSERT(g_pHyprRenderer->m_renderData.pMonitor, "Tried to render texture without begin()!");
 
     if (!data.damage) {
-        if (m_renderData.damage.empty())
+        if (g_pHyprRenderer->m_renderData.damage.empty())
             return;
 
-        data.damage = &m_renderData.damage;
+        data.damage = &g_pHyprRenderer->m_renderData.damage;
     }
 
     if (data.blur)
@@ -1184,7 +1189,8 @@ static bool isHDR2SDR(const NColorManagement::SImageDescription& imageDescriptio
 
 void CHyprOpenGLImpl::passCMUniforms(WP<CShader> shader, const NColorManagement::PImageDescription imageDescription,
                                      const NColorManagement::PImageDescription targetImageDescription, bool modifySDR, float sdrMinLuminance, int sdrMaxLuminance) {
-    const auto settings = g_pHyprRenderer->getCMSettings(imageDescription, targetImageDescription, m_renderData.surface.valid() ? m_renderData.surface.lock() : nullptr, modifySDR,
+    const auto settings = g_pHyprRenderer->getCMSettings(imageDescription, targetImageDescription,
+                                                         g_pHyprRenderer->m_renderData.surface.valid() ? g_pHyprRenderer->m_renderData.surface.lock() : nullptr, modifySDR,
                                                          sdrMinLuminance, sdrMaxLuminance);
 
     shader->setUniformInt(SHADER_SOURCE_TF, settings.sourceTF);
@@ -1231,8 +1237,8 @@ void CHyprOpenGLImpl::passCMUniforms(WP<CShader> shader, const NColorManagement:
 }
 
 void CHyprOpenGLImpl::passCMUniforms(WP<CShader> shader, const PImageDescription imageDescription) {
-    passCMUniforms(shader, imageDescription, g_pHyprRenderer->workBufferImageDescription(), true, m_renderData.pMonitor->m_sdrMinLuminance,
-                   m_renderData.pMonitor->m_sdrMaxLuminance);
+    passCMUniforms(shader, imageDescription, g_pHyprRenderer->workBufferImageDescription(), true, g_pHyprRenderer->m_renderData.pMonitor->m_sdrMinLuminance,
+                   g_pHyprRenderer->m_renderData.pMonitor->m_sdrMaxLuminance);
 }
 
 WP<CShader> CHyprOpenGLImpl::renderToOutputInternal() {
@@ -1249,8 +1255,8 @@ WP<CShader> CHyprOpenGLImpl::renderToOutputInternal() {
     else
         shader->setUniformFloat(SHADER_TIME, 0.f);
 
-    shader->setUniformInt(SHADER_WL_OUTPUT, m_renderData.pMonitor->m_id);
-    shader->setUniformFloat2(SHADER_FULL_SIZE, m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y);
+    shader->setUniformInt(SHADER_WL_OUTPUT, g_pHyprRenderer->m_renderData.pMonitor->m_id);
+    shader->setUniformFloat2(SHADER_FULL_SIZE, g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.y);
     shader->setUniformFloat(SHADER_POINTER_INACTIVE_TIMEOUT, *PCURSORTIMEOUT);
     shader->setUniformInt(SHADER_POINTER_HIDDEN, g_pHyprRenderer->m_cursorHiddenByCondition);
     shader->setUniformInt(SHADER_POINTER_KILLING, g_pInputManager->getClickMode() == CLICKMODE_KILL);
@@ -1259,7 +1265,7 @@ WP<CShader> CHyprOpenGLImpl::renderToOutputInternal() {
     shader->setUniformFloat(SHADER_POINTER_SIZE, g_pCursorManager->getScaledSize());
 
     if (*PDT == 0) {
-        PHLMONITORREF pMonitor = m_renderData.pMonitor;
+        PHLMONITORREF pMonitor = g_pHyprRenderer->m_renderData.pMonitor;
         Vector2D      p        = ((g_pInputManager->getMouseCoordsInternal() - pMonitor->m_position) * pMonitor->m_scale);
         p                      = p.transform(Math::wlTransformToHyprutils(pMonitor->m_transform), pMonitor->m_pixelSize);
         shader->setUniformFloat2(SHADER_POINTER, p.x / pMonitor->m_pixelSize.x, p.y / pMonitor->m_pixelSize.y);
@@ -1300,7 +1306,7 @@ WP<CShader> CHyprOpenGLImpl::renderToOutputInternal() {
 
     if (g_pHyprRenderer->m_crashingInProgress) {
         shader->setUniformFloat(SHADER_DISTORT, g_pHyprRenderer->m_crashingDistort);
-        shader->setUniformFloat2(SHADER_FULL_SIZE, m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y);
+        shader->setUniformFloat2(SHADER_FULL_SIZE, g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.y);
     }
 
     return shader;
@@ -1325,10 +1331,10 @@ WP<CShader> CHyprOpenGLImpl::renderToFBInternal(const STextureRenderData& data,
         default: RASSERT(false, "tex->m_iTarget unsupported!");
     }
 
-    if (data.finalMonitorCM || (m_renderData.currentWindow && m_renderData.currentWindow->m_ruleApplicator->RGBX().valueOrDefault()))
+    if (data.finalMonitorCM || (g_pHyprRenderer->m_renderData.currentWindow && g_pHyprRenderer->m_renderData.currentWindow->m_ruleApplicator->RGBX().valueOrDefault()))
         shaderFeatures &= ~SH_FEAT_RGBA;
 
-    const auto surface           = m_renderData.surface;
+    const auto surface           = g_pHyprRenderer->m_renderData.surface;
     const bool isHDRSurface      = surface.valid() && surface->m_colorManagement.valid() ? surface->m_colorManagement->isHDR() : false;
     const bool canPassHDRSurface = isHDRSurface && !surface->m_colorManagement->isWindowsScRGB(); // windows scRGB requires CM shader
 
@@ -1338,8 +1344,8 @@ WP<CShader> CHyprOpenGLImpl::renderToFBInternal(const STextureRenderData& data,
 
     const auto SOURCE_IMAGE_DESCRIPTION = [&] {
         // if valid CM surface, use that as a source
-        if (m_renderData.surface.valid() && m_renderData.surface->m_colorManagement.valid())
-            return CImageDescription::from(m_renderData.surface->m_colorManagement->imageDescription());
+        if (g_pHyprRenderer->m_renderData.surface.valid() && g_pHyprRenderer->m_renderData.surface->m_colorManagement.valid())
+            return CImageDescription::from(g_pHyprRenderer->m_renderData.surface->m_colorManagement->imageDescription());
 
         // otherwise, if we are CM'ing back into source, use chosen, because that's what our work buffer is in
         // the same applies to the final monitor CM
@@ -1357,7 +1363,7 @@ WP<CShader> CHyprOpenGLImpl::renderToFBInternal(const STextureRenderData& data,
 
         // for final CM, use the target description
         if (data.finalMonitorCM)
-            return m_renderData.pMonitor->m_imageDescription;
+            return g_pHyprRenderer->m_renderData.pMonitor->m_imageDescription;
         // otherwise, use chosen, we're drawing into the work buffer
         // NOLINTNEXTLINE
         return WORK_BUFFER_IMAGE_DESCRIPTION;
@@ -1369,16 +1375,19 @@ WP<CShader> CHyprOpenGLImpl::renderToFBInternal(const STextureRenderData& data,
     if (data.discardActive)
         shaderFeatures |= SH_FEAT_DISCARD;
 
-    const bool CANT_CHECK_CM_EQUALITY = data.cmBackToSRGB || data.finalMonitorCM || (!m_renderData.surface || !m_renderData.surface->m_colorManagement);
+    const bool CANT_CHECK_CM_EQUALITY =
+        data.cmBackToSRGB || data.finalMonitorCM || (!g_pHyprRenderer->m_renderData.surface || !g_pHyprRenderer->m_renderData.surface->m_colorManagement);
 
     const bool skipCM = !*PENABLECM || !m_cmSupported                                                    /* CM unsupported or disabled */
-        || m_renderData.pMonitor->doesNoShaderCM()                                                       /* no shader needed */
+        || g_pHyprRenderer->m_renderData.pMonitor->doesNoShaderCM()                                      /* no shader needed */
         || (SOURCE_IMAGE_DESCRIPTION->id() == TARGET_IMAGE_DESCRIPTION->id() && !CANT_CHECK_CM_EQUALITY) /* Source and target have the same image description */
         || (((*PPASS && canPassHDRSurface) ||
-             (*PPASS == 1 && !isHDRSurface && m_renderData.pMonitor->m_cmType != NCMType::CM_HDR && m_renderData.pMonitor->m_cmType != NCMType::CM_HDR_EDID)) &&
-            m_renderData.pMonitor->inFullscreenMode()) /* Fullscreen window with pass cm enabled */;
+             (*PPASS == 1 && !isHDRSurface && g_pHyprRenderer->m_renderData.pMonitor->m_cmType != NCMType::CM_HDR &&
+              g_pHyprRenderer->m_renderData.pMonitor->m_cmType != NCMType::CM_HDR_EDID)) &&
+            g_pHyprRenderer->m_renderData.pMonitor->inFullscreenMode()) /* Fullscreen window with pass cm enabled */;
 
-    if (data.allowDim && m_renderData.currentWindow && (m_renderData.currentWindow->m_notRespondingTint->value() > 0 || m_renderData.currentWindow->m_dimPercent->value() > 0))
+    if (data.allowDim && g_pHyprRenderer->m_renderData.currentWindow &&
+        (g_pHyprRenderer->m_renderData.currentWindow->m_notRespondingTint->value() > 0 || g_pHyprRenderer->m_renderData.currentWindow->m_dimPercent->value() > 0))
         shaderFeatures |= SH_FEAT_TINT;
 
     if (data.round > 0)
@@ -1404,8 +1413,8 @@ WP<CShader> CHyprOpenGLImpl::renderToFBInternal(const STextureRenderData& data,
                 (SOURCE_IMAGE_DESCRIPTION->value().transferFunction == CM_TRANSFER_FUNCTION_SRGB ||
                  SOURCE_IMAGE_DESCRIPTION->value().transferFunction == CM_TRANSFER_FUNCTION_GAMMA22) &&
                 TARGET_IMAGE_DESCRIPTION->value().transferFunction == CM_TRANSFER_FUNCTION_ST2084_PQ &&
-                ((m_renderData.pMonitor->m_sdrSaturation > 0 && m_renderData.pMonitor->m_sdrSaturation != 1.0f) ||
-                 (m_renderData.pMonitor->m_sdrBrightness > 0 && m_renderData.pMonitor->m_sdrBrightness != 1.0f)))
+                ((g_pHyprRenderer->m_renderData.pMonitor->m_sdrSaturation > 0 && g_pHyprRenderer->m_renderData.pMonitor->m_sdrSaturation != 1.0f) ||
+                 (g_pHyprRenderer->m_renderData.pMonitor->m_sdrBrightness > 0 && g_pHyprRenderer->m_renderData.pMonitor->m_sdrBrightness != 1.0f)))
                 shaderFeatures |= SH_FEAT_SDR_MOD;
         }
     }
@@ -1416,7 +1425,8 @@ WP<CShader> CHyprOpenGLImpl::renderToFBInternal(const STextureRenderData& data,
 
     if (!skipCM) {
         if (data.finalMonitorCM || data.cmBackToSRGB)
-            passCMUniforms(shader, SOURCE_IMAGE_DESCRIPTION, TARGET_IMAGE_DESCRIPTION, true, m_renderData.pMonitor->m_sdrMinLuminance, m_renderData.pMonitor->m_sdrMaxLuminance);
+            passCMUniforms(shader, SOURCE_IMAGE_DESCRIPTION, TARGET_IMAGE_DESCRIPTION, true, g_pHyprRenderer->m_renderData.pMonitor->m_sdrMinLuminance,
+                           g_pHyprRenderer->m_renderData.pMonitor->m_sdrMaxLuminance);
         else
             passCMUniforms(shader, SOURCE_IMAGE_DESCRIPTION);
     }
@@ -1426,25 +1436,27 @@ WP<CShader> CHyprOpenGLImpl::renderToFBInternal(const STextureRenderData& data,
     if (shaderFeatures & SH_FEAT_BLUR) {
         shader->setUniformInt(SHADER_BLURRED_BG, 1);
         // shader->setUniformFloat2(SHADER_UV_OFFSET, 0, 0);
-        shader->setUniformFloat2(SHADER_UV_OFFSET, newBox.x / m_renderData.pMonitor->m_transformedSize.x, newBox.y / m_renderData.pMonitor->m_transformedSize.y);
-        shader->setUniformFloat2(SHADER_UV_SIZE, newBox.width / m_renderData.pMonitor->m_transformedSize.x, newBox.height / m_renderData.pMonitor->m_transformedSize.y);
+        shader->setUniformFloat2(SHADER_UV_OFFSET, newBox.x / g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x,
+                                 newBox.y / g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y);
+        shader->setUniformFloat2(SHADER_UV_SIZE, newBox.width / g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x,
+                                 newBox.height / g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y);
 
         glActiveTexture(GL_TEXTURE0 + 1);
         data.blurredBG->bind();
     }
 
     if (data.discardActive) {
-        shader->setUniformInt(SHADER_DISCARD_OPAQUE, !!(m_renderData.discardMode & DISCARD_OPAQUE));
-        shader->setUniformInt(SHADER_DISCARD_ALPHA, !!(m_renderData.discardMode & DISCARD_ALPHA));
-        shader->setUniformFloat(SHADER_DISCARD_ALPHA_VALUE, m_renderData.discardOpacity);
+        shader->setUniformInt(SHADER_DISCARD_OPAQUE, !!(g_pHyprRenderer->m_renderData.discardMode & DISCARD_OPAQUE));
+        shader->setUniformInt(SHADER_DISCARD_ALPHA, !!(g_pHyprRenderer->m_renderData.discardMode & DISCARD_ALPHA));
+        shader->setUniformFloat(SHADER_DISCARD_ALPHA_VALUE, g_pHyprRenderer->m_renderData.discardOpacity);
     } else {
         shader->setUniformInt(SHADER_DISCARD_OPAQUE, 0);
         shader->setUniformInt(SHADER_DISCARD_ALPHA, 0);
     }
 
     CBox transformedBox = newBox;
-    transformedBox.transform(Math::wlTransformToHyprutils(Math::invertTransform(m_renderData.pMonitor->m_transform)), m_renderData.pMonitor->m_transformedSize.x,
-                             m_renderData.pMonitor->m_transformedSize.y);
+    transformedBox.transform(Math::wlTransformToHyprutils(Math::invertTransform(g_pHyprRenderer->m_renderData.pMonitor->m_transform)),
+                             g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y);
 
     const auto TOPLEFT  = Vector2D(transformedBox.x, transformedBox.y);
     const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height);
@@ -1454,14 +1466,14 @@ WP<CShader> CHyprOpenGLImpl::renderToFBInternal(const STextureRenderData& data,
     shader->setUniformFloat(SHADER_RADIUS, data.round);
     shader->setUniformFloat(SHADER_ROUNDING_POWER, data.roundingPower);
 
-    if (data.allowDim && m_renderData.currentWindow) {
-        if (m_renderData.currentWindow->m_notRespondingTint->value() > 0) {
-            const auto DIM = m_renderData.currentWindow->m_notRespondingTint->value();
+    if (data.allowDim && g_pHyprRenderer->m_renderData.currentWindow) {
+        if (g_pHyprRenderer->m_renderData.currentWindow->m_notRespondingTint->value() > 0) {
+            const auto DIM = g_pHyprRenderer->m_renderData.currentWindow->m_notRespondingTint->value();
             shader->setUniformInt(SHADER_APPLY_TINT, 1);
             shader->setUniformFloat3(SHADER_TINT, 1.f - DIM, 1.f - DIM, 1.f - DIM);
-        } else if (m_renderData.currentWindow->m_dimPercent->value() > 0) {
+        } else if (g_pHyprRenderer->m_renderData.currentWindow->m_dimPercent->value() > 0) {
             shader->setUniformInt(SHADER_APPLY_TINT, 1);
-            const auto DIM = m_renderData.currentWindow->m_dimPercent->value();
+            const auto DIM = g_pHyprRenderer->m_renderData.currentWindow->m_dimPercent->value();
             shader->setUniformFloat3(SHADER_TINT, 1.f - DIM, 1.f - DIM, 1.f - DIM);
         } else
             shader->setUniformInt(SHADER_APPLY_TINT, 0);
@@ -1472,7 +1484,7 @@ WP<CShader> CHyprOpenGLImpl::renderToFBInternal(const STextureRenderData& data,
 }
 
 void CHyprOpenGLImpl::renderTextureInternal(SP<ITexture> tex, const CBox& box, const STextureRenderData& data) {
-    RASSERT(m_renderData.pMonitor, "Tried to render texture without begin()!");
+    RASSERT(g_pHyprRenderer->m_renderData.pMonitor, "Tried to render texture without begin()!");
     RASSERT((tex->ok()), "Attempted to draw nullptr texture!");
 
     TRACY_GPU_ZONE("RenderTextureInternalWithDamage");
@@ -1481,19 +1493,19 @@ void CHyprOpenGLImpl::renderTextureInternal(SP<ITexture> tex, const CBox& box, c
         return;
 
     CBox newBox = box;
-    m_renderData.renderModif.applyToBox(newBox);
+    g_pHyprRenderer->m_renderData.renderModif.applyToBox(newBox);
 
     // get the needed transform for this texture
-    const auto                  MONITOR_INVERTED = Math::wlTransformToHyprutils(Math::invertTransform(m_renderData.pMonitor->m_transform));
+    const auto                  MONITOR_INVERTED = Math::wlTransformToHyprutils(Math::invertTransform(g_pHyprRenderer->m_renderData.pMonitor->m_transform));
     Hyprutils::Math::eTransform TRANSFORM        = tex->m_transform;
 
     if (g_pHyprRenderer->monitorTransformEnabled())
         TRANSFORM = Math::composeTransform(MONITOR_INVERTED, TRANSFORM);
 
-    Mat3x3     matrix   = m_renderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
-    Mat3x3     glMatrix = m_renderData.projection.copy().multiply(matrix);
+    Mat3x3     matrix   = g_pHyprRenderer->m_renderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
+    Mat3x3     glMatrix = g_pHyprRenderer->m_renderData.projection.copy().multiply(matrix);
 
-    const bool renderToOutput = m_applyFinalShader && g_pHyprRenderer->workBufferImageDescription()->id() == m_renderData.pMonitor->m_imageDescription->id();
+    const bool renderToOutput = m_applyFinalShader && g_pHyprRenderer->workBufferImageDescription()->id() == g_pHyprRenderer->m_renderData.pMonitor->m_imageDescription->id();
 
     glActiveTexture(GL_TEXTURE0);
     tex->bind();
@@ -1501,7 +1513,7 @@ void CHyprOpenGLImpl::renderTextureInternal(SP<ITexture> tex, const CBox& box, c
     tex->setTexParameter(GL_TEXTURE_WRAP_S, data.wrapX);
     tex->setTexParameter(GL_TEXTURE_WRAP_T, data.wrapY);
 
-    if (m_renderData.useNearestNeighbor) {
+    if (g_pHyprRenderer->m_renderData.useNearestNeighbor) {
         tex->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_NEAREST);
         tex->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     } else {
@@ -1523,11 +1535,11 @@ void CHyprOpenGLImpl::renderTextureInternal(SP<ITexture> tex, const CBox& box, c
 
     auto verts = fullVerts;
 
-    if (data.allowCustomUV && m_renderData.primarySurfaceUVTopLeft != Vector2D(-1, -1)) {
-        const float u0 = m_renderData.primarySurfaceUVTopLeft.x;
-        const float v0 = m_renderData.primarySurfaceUVTopLeft.y;
-        const float u1 = m_renderData.primarySurfaceUVBottomRight.x;
-        const float v1 = m_renderData.primarySurfaceUVBottomRight.y;
+    if (data.allowCustomUV && g_pHyprRenderer->m_renderData.primarySurfaceUVTopLeft != Vector2D(-1, -1)) {
+        const float u0 = g_pHyprRenderer->m_renderData.primarySurfaceUVTopLeft.x;
+        const float v0 = g_pHyprRenderer->m_renderData.primarySurfaceUVTopLeft.y;
+        const float u1 = g_pHyprRenderer->m_renderData.primarySurfaceUVBottomRight.x;
+        const float v1 = g_pHyprRenderer->m_renderData.primarySurfaceUVBottomRight.y;
 
         verts[0].u = u0;
         verts[0].v = v0;
@@ -1541,25 +1553,25 @@ void CHyprOpenGLImpl::renderTextureInternal(SP<ITexture> tex, const CBox& box, c
 
     glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(verts), verts.data());
 
-    if (!m_renderData.clipBox.empty() || !m_renderData.clipRegion.empty()) {
-        CRegion damageClip = m_renderData.clipBox;
+    if (!g_pHyprRenderer->m_renderData.clipBox.empty() || !g_pHyprRenderer->m_renderData.clipRegion.empty()) {
+        CRegion damageClip = g_pHyprRenderer->m_renderData.clipBox;
 
-        if (!m_renderData.clipRegion.empty()) {
-            if (m_renderData.clipBox.empty())
-                damageClip = m_renderData.clipRegion;
+        if (!g_pHyprRenderer->m_renderData.clipRegion.empty()) {
+            if (g_pHyprRenderer->m_renderData.clipBox.empty())
+                damageClip = g_pHyprRenderer->m_renderData.clipRegion;
             else
-                damageClip.intersect(m_renderData.clipRegion);
+                damageClip.intersect(g_pHyprRenderer->m_renderData.clipRegion);
         }
 
         if (!damageClip.empty()) {
             damageClip.forEachRect([this](const auto& RECT) {
-                scissor(&RECT, m_renderData.transformDamage);
+                scissor(&RECT, g_pHyprRenderer->m_renderData.transformDamage);
                 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
             });
         }
     } else {
         data.damage->forEachRect([this](const auto& RECT) {
-            scissor(&RECT, m_renderData.transformDamage);
+            scissor(&RECT, g_pHyprRenderer->m_renderData.transformDamage);
             glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
         });
     }
@@ -1570,29 +1582,29 @@ void CHyprOpenGLImpl::renderTextureInternal(SP<ITexture> tex, const CBox& box, c
 }
 
 void CHyprOpenGLImpl::renderTexturePrimitive(SP<ITexture> tex, const CBox& box) {
-    RASSERT(m_renderData.pMonitor, "Tried to render texture without begin()!");
+    RASSERT(g_pHyprRenderer->m_renderData.pMonitor, "Tried to render texture without begin()!");
     RASSERT((tex->ok()), "Attempted to draw nullptr texture!");
 
     TRACY_GPU_ZONE("RenderTexturePrimitive");
 
-    if (m_renderData.damage.empty())
+    if (g_pHyprRenderer->m_renderData.damage.empty())
         return;
 
     CBox newBox = box;
-    m_renderData.renderModif.applyToBox(newBox);
+    g_pHyprRenderer->m_renderData.renderModif.applyToBox(newBox);
 
     // get transform
-    const auto TRANSFORM =
-        Math::wlTransformToHyprutils(Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform));
-    Mat3x3 matrix   = m_renderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
-    Mat3x3 glMatrix = m_renderData.projection.copy().multiply(matrix);
+    const auto TRANSFORM = Math::wlTransformToHyprutils(
+        Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : g_pHyprRenderer->m_renderData.pMonitor->m_transform));
+    Mat3x3 matrix   = g_pHyprRenderer->m_renderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
+    Mat3x3 glMatrix = g_pHyprRenderer->m_renderData.projection.copy().multiply(matrix);
 
     glActiveTexture(GL_TEXTURE0);
     tex->bind();
 
     // ensure the final blit uses the desired sampling filter
     // when cursor zoom is active we want nearest-neighbor (no anti-aliasing)
-    if (m_renderData.useNearestNeighbor) {
+    if (g_pHyprRenderer->m_renderData.useNearestNeighbor) {
         tex->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_NEAREST);
         tex->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     } else {
@@ -1605,8 +1617,8 @@ void CHyprOpenGLImpl::renderTexturePrimitive(SP<ITexture> tex, const CBox& box)
     shader->setUniformInt(SHADER_TEX, 0);
     glBindVertexArray(shader->getUniformLocation(SHADER_SHADER_VAO));
 
-    m_renderData.damage.forEachRect([this](const auto& RECT) {
-        scissor(&RECT, m_renderData.transformDamage);
+    g_pHyprRenderer->m_renderData.damage.forEachRect([this](const auto& RECT) {
+        scissor(&RECT, g_pHyprRenderer->m_renderData.transformDamage);
         glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
     });
 
@@ -1616,22 +1628,22 @@ void CHyprOpenGLImpl::renderTexturePrimitive(SP<ITexture> tex, const CBox& box)
 }
 
 void CHyprOpenGLImpl::renderTextureMatte(SP<ITexture> tex, const CBox& box, SP<IFramebuffer> matte) {
-    RASSERT(m_renderData.pMonitor, "Tried to render texture without begin()!");
+    RASSERT(g_pHyprRenderer->m_renderData.pMonitor, "Tried to render texture without begin()!");
     RASSERT((tex->ok()), "Attempted to draw nullptr texture!");
 
     TRACY_GPU_ZONE("RenderTextureMatte");
 
-    if (m_renderData.damage.empty())
+    if (g_pHyprRenderer->m_renderData.damage.empty())
         return;
 
     CBox newBox = box;
-    m_renderData.renderModif.applyToBox(newBox);
+    g_pHyprRenderer->m_renderData.renderModif.applyToBox(newBox);
 
     // get transform
-    const auto TRANSFORM =
-        Math::wlTransformToHyprutils(Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform));
-    Mat3x3 matrix   = m_renderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
-    Mat3x3 glMatrix = m_renderData.projection.copy().multiply(matrix);
+    const auto TRANSFORM = Math::wlTransformToHyprutils(
+        Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : g_pHyprRenderer->m_renderData.pMonitor->m_transform));
+    Mat3x3 matrix   = g_pHyprRenderer->m_renderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
+    Mat3x3 glMatrix = g_pHyprRenderer->m_renderData.projection.copy().multiply(matrix);
 
     auto   shader = useShader(getShaderVariant(SH_FRAG_MATTE));
     shader->setUniformMatrix3fv(SHADER_PROJ, 1, GL_TRUE, glMatrix.getMatrix());
@@ -1647,8 +1659,8 @@ void CHyprOpenGLImpl::renderTextureMatte(SP<ITexture> tex, const CBox& box, SP<I
 
     glBindVertexArray(shader->getUniformLocation(SHADER_SHADER_VAO));
 
-    m_renderData.damage.forEachRect([this](const auto& RECT) {
-        scissor(&RECT, m_renderData.transformDamage);
+    g_pHyprRenderer->m_renderData.damage.forEachRect([this](const auto& RECT) {
+        scissor(&RECT, g_pHyprRenderer->m_renderData.transformDamage);
         glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
     });
 
@@ -1662,12 +1674,12 @@ void CHyprOpenGLImpl::renderTextureMatte(SP<ITexture> tex, const CBox& box, SP<I
 //
 // Dual (or more) kawase blur
 SP<IFramebuffer> CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, CRegion* originalDamage) {
-    if (!m_renderData.currentFB->getTexture()) {
+    if (!g_pHyprRenderer->m_renderData.currentFB->getTexture()) {
         Log::logger->log(Log::ERR, "BUG THIS: null fb texture while attempting to blur main fb?! (introspection off?!)");
-        return m_renderData.pMonitor->m_mirrorFB; // return something to sample from at least
+        return g_pHyprRenderer->m_renderData.pMonitor->m_mirrorFB; // return something to sample from at least
     }
 
-    return blurFramebufferWithDamage(a, originalDamage, *GLFB(m_renderData.currentFB));
+    return blurFramebufferWithDamage(a, originalDamage, *GLFB(g_pHyprRenderer->m_renderData.currentFB));
 }
 
 SP<IFramebuffer> CHyprOpenGLImpl::blurFramebufferWithDamage(float a, CRegion* originalDamage, CGLFramebuffer& source) {
@@ -1678,10 +1690,10 @@ SP<IFramebuffer> CHyprOpenGLImpl::blurFramebufferWithDamage(float a, CRegion* or
     setCapStatus(GL_STENCIL_TEST, false);
 
     // get transforms for the full monitor
-    const auto TRANSFORM  = Math::wlTransformToHyprutils(Math::invertTransform(m_renderData.pMonitor->m_transform));
-    CBox       MONITORBOX = {0, 0, m_renderData.pMonitor->m_transformedSize.x, m_renderData.pMonitor->m_transformedSize.y};
-    Mat3x3     matrix     = m_renderData.monitorProjection.projectBox(MONITORBOX, TRANSFORM);
-    Mat3x3     glMatrix   = m_renderData.projection.copy().multiply(matrix);
+    const auto TRANSFORM  = Math::wlTransformToHyprutils(Math::invertTransform(g_pHyprRenderer->m_renderData.pMonitor->m_transform));
+    CBox       MONITORBOX = {0, 0, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y};
+    Mat3x3     matrix     = g_pHyprRenderer->m_renderData.monitorProjection.projectBox(MONITORBOX, TRANSFORM);
+    Mat3x3     glMatrix   = g_pHyprRenderer->m_renderData.projection.copy().multiply(matrix);
 
     // get the config settings
     static auto PBLURSIZE             = CConfigValue<Hyprlang::INT>("decoration:blur:size");
@@ -1693,13 +1705,13 @@ SP<IFramebuffer> CHyprOpenGLImpl::blurFramebufferWithDamage(float a, CRegion* or
 
     // prep damage
     CRegion damage{*originalDamage};
-    damage.transform(Math::wlTransformToHyprutils(Math::invertTransform(m_renderData.pMonitor->m_transform)), m_renderData.pMonitor->m_transformedSize.x,
-                     m_renderData.pMonitor->m_transformedSize.y);
+    damage.transform(Math::wlTransformToHyprutils(Math::invertTransform(g_pHyprRenderer->m_renderData.pMonitor->m_transform)),
+                     g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y);
     damage.expand(std::clamp(*PBLURSIZE, sc<int64_t>(1), sc<int64_t>(40)) * pow(2, BLUR_PASSES));
 
     // helper
-    const auto PMIRRORFB     = m_renderData.pMonitor->m_mirrorFB;
-    const auto PMIRRORSWAPFB = m_renderData.pMonitor->m_mirrorSwapFB;
+    const auto PMIRRORFB     = g_pHyprRenderer->m_renderData.pMonitor->m_mirrorFB;
+    const auto PMIRRORSWAPFB = g_pHyprRenderer->m_renderData.pMonitor->m_mirrorSwapFB;
 
     auto       currentRenderToFB = PMIRRORFB;
 
@@ -1725,22 +1737,24 @@ SP<IFramebuffer> CHyprOpenGLImpl::blurFramebufferWithDamage(float a, CRegion* or
         const bool skipCM = !m_cmSupported || g_pHyprRenderer->workBufferImageDescription()->id() == DEFAULT_IMAGE_DESCRIPTION->id();
         if (!skipCM) {
             shader = useShader(getShaderVariant(SH_FRAG_BLURPREPARE, SH_FEAT_CM));
-            passCMUniforms(shader, m_renderData.pMonitor->m_imageDescription, DEFAULT_IMAGE_DESCRIPTION);
+            passCMUniforms(shader, g_pHyprRenderer->m_renderData.pMonitor->m_imageDescription, DEFAULT_IMAGE_DESCRIPTION);
             shader->setUniformFloat(SHADER_SDR_SATURATION,
-                                    m_renderData.pMonitor->m_sdrSaturation > 0 &&
-                                            m_renderData.pMonitor->m_imageDescription->value().transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ?
-                                        m_renderData.pMonitor->m_sdrSaturation :
+                                    g_pHyprRenderer->m_renderData.pMonitor->m_sdrSaturation > 0 &&
+                                            g_pHyprRenderer->m_renderData.pMonitor->m_imageDescription->value().transferFunction ==
+                                                NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ?
+                                        g_pHyprRenderer->m_renderData.pMonitor->m_sdrSaturation :
                                         1.0f);
             shader->setUniformFloat(SHADER_SDR_BRIGHTNESS,
-                                    m_renderData.pMonitor->m_sdrBrightness > 0 &&
-                                            m_renderData.pMonitor->m_imageDescription->value().transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ?
-                                        m_renderData.pMonitor->m_sdrBrightness :
+                                    g_pHyprRenderer->m_renderData.pMonitor->m_sdrBrightness > 0 &&
+                                            g_pHyprRenderer->m_renderData.pMonitor->m_imageDescription->value().transferFunction ==
+                                                NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ?
+                                        g_pHyprRenderer->m_renderData.pMonitor->m_sdrBrightness :
                                         1.0f);
         } else
             shader = useShader(getShaderVariant(SH_FRAG_BLURPREPARE));
 
-        Mat3x3 matrix   = m_renderData.monitorProjection.projectBox(MONITORBOX, *PBLEND ? HYPRUTILS_TRANSFORM_NORMAL : TRANSFORM);
-        Mat3x3 glMatrix = m_renderData.projection.copy().multiply(matrix);
+        Mat3x3 matrix   = g_pHyprRenderer->m_renderData.monitorProjection.projectBox(MONITORBOX, *PBLEND ? HYPRUTILS_TRANSFORM_NORMAL : TRANSFORM);
+        Mat3x3 glMatrix = g_pHyprRenderer->m_renderData.projection.copy().multiply(matrix);
         shader->setUniformMatrix3fv(SHADER_PROJ, 1, GL_TRUE, glMatrix.getMatrix());
         shader->setUniformFloat(SHADER_CONTRAST, *PBLURCONTRAST);
         shader->setUniformFloat(SHADER_BRIGHTNESS, *PBLURBRIGHTNESS);
@@ -1778,12 +1792,14 @@ SP<IFramebuffer> CHyprOpenGLImpl::blurFramebufferWithDamage(float a, CRegion* or
         shader->setUniformMatrix3fv(SHADER_PROJ, 1, GL_TRUE, glMatrix.getMatrix());
         shader->setUniformFloat(SHADER_RADIUS, *PBLURSIZE * a); // this makes the blursize change with a
         if (frag == SH_FRAG_BLUR1) {
-            shader->setUniformFloat2(SHADER_HALFPIXEL, 0.5f / (m_renderData.pMonitor->m_pixelSize.x / 2.f), 0.5f / (m_renderData.pMonitor->m_pixelSize.y / 2.f));
+            shader->setUniformFloat2(SHADER_HALFPIXEL, 0.5f / (g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.x / 2.f),
+                                     0.5f / (g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.y / 2.f));
             shader->setUniformInt(SHADER_PASSES, BLUR_PASSES);
             shader->setUniformFloat(SHADER_VIBRANCY, *PBLURVIBRANCY);
             shader->setUniformFloat(SHADER_VIBRANCY_DARKNESS, *PBLURVIBRANCYDARKNESS);
         } else
-            shader->setUniformFloat2(SHADER_HALFPIXEL, 0.5f / (m_renderData.pMonitor->m_pixelSize.x * 2.f), 0.5f / (m_renderData.pMonitor->m_pixelSize.y * 2.f));
+            shader->setUniformFloat2(SHADER_HALFPIXEL, 0.5f / (g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.x * 2.f),
+                                     0.5f / (g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.y * 2.f));
         shader->setUniformInt(SHADER_TEX, 0);
 
         glBindVertexArray(shader->getUniformLocation(SHADER_SHADER_VAO));
@@ -1961,34 +1977,36 @@ void CHyprOpenGLImpl::preBlurForCurrentMonitor() {
 
     TRACY_GPU_ZONE("RenderPreBlurForCurrentMonitor");
 
-    const auto SAVEDRENDERMODIF = m_renderData.renderModif;
-    m_renderData.renderModif    = {}; // fix shit
+    const auto SAVEDRENDERMODIF               = g_pHyprRenderer->m_renderData.renderModif;
+    g_pHyprRenderer->m_renderData.renderModif = {}; // fix shit
 
     // make the fake dmg
-    CRegion    fakeDamage{0, 0, m_renderData.pMonitor->m_transformedSize.x, m_renderData.pMonitor->m_transformedSize.y};
+    CRegion    fakeDamage{0, 0, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y};
     const auto POUTFB = blurMainFramebufferWithDamage(1, &fakeDamage);
 
     // render onto blurFB
-    if (!m_renderData.pMonitor->m_blurFB)
-        m_renderData.pMonitor->m_blurFB = g_pHyprRenderer->createFB();
+    if (!g_pHyprRenderer->m_renderData.pMonitor->m_blurFB)
+        g_pHyprRenderer->m_renderData.pMonitor->m_blurFB = g_pHyprRenderer->createFB();
 
-    m_renderData.pMonitor->m_blurFB->alloc(m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y, m_renderData.pMonitor->m_output->state->state().drmFormat);
-    m_renderData.pMonitor->m_blurFB->bind();
+    g_pHyprRenderer->m_renderData.pMonitor->m_blurFB->alloc(g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.y,
+                                                            g_pHyprRenderer->m_renderData.pMonitor->m_output->state->state().drmFormat);
+    g_pHyprRenderer->m_renderData.pMonitor->m_blurFB->bind();
 
     clear(CHyprColor(0, 0, 0, 0));
 
     g_pHyprRenderer->pushMonitorTransformEnabled(true);
-    renderTextureInternal(POUTFB->getTexture(), CBox{0, 0, m_renderData.pMonitor->m_transformedSize.x, m_renderData.pMonitor->m_transformedSize.y},
+    renderTextureInternal(POUTFB->getTexture(),
+                          CBox{0, 0, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y},
                           STextureRenderData{.damage = &fakeDamage, .a = 1, .round = 0, .roundingPower = 2.F, .discardActive = false, .allowCustomUV = false, .noAA = true});
     g_pHyprRenderer->popMonitorTransformEnabled();
 
-    m_renderData.currentFB->bind();
+    g_pHyprRenderer->m_renderData.currentFB->bind();
 
-    m_renderData.pMonitor->m_blurFBDirty = false;
+    g_pHyprRenderer->m_renderData.pMonitor->m_blurFBDirty = false;
 
-    m_renderData.renderModif = SAVEDRENDERMODIF;
+    g_pHyprRenderer->m_renderData.renderModif = SAVEDRENDERMODIF;
 
-    m_renderData.pMonitor->m_blurFBShouldRender = false;
+    g_pHyprRenderer->m_renderData.pMonitor->m_blurFBShouldRender = false;
 }
 
 void CHyprOpenGLImpl::preWindowPass() {
@@ -2002,34 +2020,34 @@ bool CHyprOpenGLImpl::preBlurQueued() {
     static auto PBLURNEWOPTIMIZE = CConfigValue<Hyprlang::INT>("decoration:blur:new_optimizations");
     static auto PBLUR            = CConfigValue<Hyprlang::INT>("decoration:blur:enabled");
 
-    return m_renderData.pMonitor->m_blurFBDirty && *PBLURNEWOPTIMIZE && *PBLUR && m_renderData.pMonitor->m_blurFBShouldRender;
+    return g_pHyprRenderer->m_renderData.pMonitor->m_blurFBDirty && *PBLURNEWOPTIMIZE && *PBLUR && g_pHyprRenderer->m_renderData.pMonitor->m_blurFBShouldRender;
 }
 
 void CHyprOpenGLImpl::renderTextureWithBlurInternal(SP<ITexture> tex, const CBox& box, const STextureRenderData& data) {
-    RASSERT(m_renderData.pMonitor, "Tried to render texture with blur without begin()!");
+    RASSERT(g_pHyprRenderer->m_renderData.pMonitor, "Tried to render texture with blur without begin()!");
 
     TRACY_GPU_ZONE("RenderTextureWithBlur");
 
     static auto PBLEND = CConfigValue<Hyprlang::INT>("render:use_shader_blur_blend");
 
     // make a damage region for this window
-    CRegion texDamage{m_renderData.damage};
+    CRegion texDamage{g_pHyprRenderer->m_renderData.damage};
     texDamage.intersect(box.x, box.y, box.width, box.height);
 
     // While renderTextureInternalWithDamage will clip the blur as well,
     // clipping texDamage here allows blur generation to be optimized.
-    if (!m_renderData.clipRegion.empty())
-        texDamage.intersect(m_renderData.clipRegion);
+    if (!g_pHyprRenderer->m_renderData.clipRegion.empty())
+        texDamage.intersect(g_pHyprRenderer->m_renderData.clipRegion);
 
     if (texDamage.empty())
         return;
 
-    m_renderData.renderModif.applyToRegion(texDamage);
+    g_pHyprRenderer->m_renderData.renderModif.applyToRegion(texDamage);
 
     // amazing hack: the surface has an opaque region!
     CRegion inverseOpaque;
-    if (data.a >= 1.f && data.surface && std::round(data.surface->m_current.size.x * m_renderData.pMonitor->m_scale) == box.w &&
-        std::round(data.surface->m_current.size.y * m_renderData.pMonitor->m_scale) == box.h) {
+    if (data.a >= 1.f && data.surface && std::round(data.surface->m_current.size.x * g_pHyprRenderer->m_renderData.pMonitor->m_scale) == box.w &&
+        std::round(data.surface->m_current.size.y * g_pHyprRenderer->m_renderData.pMonitor->m_scale) == box.h) {
         pixman_box32_t surfbox = {0, 0, data.surface->m_current.size.x * data.surface->m_current.scale, data.surface->m_current.size.y * data.surface->m_current.scale};
         inverseOpaque          = data.surface->m_current.opaque;
         inverseOpaque.invert(&surfbox).intersect(0, 0, data.surface->m_current.size.x * data.surface->m_current.scale,
@@ -2042,25 +2060,27 @@ void CHyprOpenGLImpl::renderTextureWithBlurInternal(SP<ITexture> tex, const CBox
     } else
         inverseOpaque = {0, 0, box.width, box.height};
 
-    inverseOpaque.scale(m_renderData.pMonitor->m_scale);
+    inverseOpaque.scale(g_pHyprRenderer->m_renderData.pMonitor->m_scale);
 
     //   vvv TODO: layered blur fbs?
-    const bool USENEWOPTIMIZE = g_pHyprRenderer->shouldUseNewBlurOptimizations(m_renderData.currentLS.lock(), m_renderData.currentWindow.lock()) && !data.blockBlurOptimization;
+    const bool USENEWOPTIMIZE =
+        g_pHyprRenderer->shouldUseNewBlurOptimizations(g_pHyprRenderer->m_renderData.currentLS.lock(), g_pHyprRenderer->m_renderData.currentWindow.lock()) &&
+        !data.blockBlurOptimization;
 
     SP<IFramebuffer> POUTFB = nullptr;
     if (!USENEWOPTIMIZE) {
         inverseOpaque.translate(box.pos());
-        m_renderData.renderModif.applyToRegion(inverseOpaque);
+        g_pHyprRenderer->m_renderData.renderModif.applyToRegion(inverseOpaque);
         inverseOpaque.intersect(texDamage);
         POUTFB = blurMainFramebufferWithDamage(data.a, &inverseOpaque);
     } else
-        POUTFB = m_renderData.pMonitor->m_blurFB;
+        POUTFB = g_pHyprRenderer->m_renderData.pMonitor->m_blurFB;
 
-    m_renderData.currentFB->bind();
+    g_pHyprRenderer->m_renderData.currentFB->bind();
 
     auto       blurredBG = POUTFB->getTexture();
 
-    const auto NEEDS_STENCIL = m_renderData.discardMode != 0 && (!data.blockBlurOptimization || (m_renderData.discardMode & DISCARD_ALPHA));
+    const auto NEEDS_STENCIL = g_pHyprRenderer->m_renderData.discardMode != 0 && (!data.blockBlurOptimization || (g_pHyprRenderer->m_renderData.discardMode & DISCARD_ALPHA));
     if (!*PBLEND) {
 
         if (NEEDS_STENCIL) {
@@ -2090,24 +2110,24 @@ void CHyprOpenGLImpl::renderTextureWithBlurInternal(SP<ITexture> tex, const CBox
         }
 
         // stencil done. Render everything.
-        const auto LASTTL = m_renderData.primarySurfaceUVTopLeft;
-        const auto LASTBR = m_renderData.primarySurfaceUVBottomRight;
+        const auto LASTTL = g_pHyprRenderer->m_renderData.primarySurfaceUVTopLeft;
+        const auto LASTBR = g_pHyprRenderer->m_renderData.primarySurfaceUVBottomRight;
 
         CBox       transformedBox = box;
-        transformedBox.transform(Math::wlTransformToHyprutils(Math::invertTransform(m_renderData.pMonitor->m_transform)), m_renderData.pMonitor->m_transformedSize.x,
-                                 m_renderData.pMonitor->m_transformedSize.y);
+        transformedBox.transform(Math::wlTransformToHyprutils(Math::invertTransform(g_pHyprRenderer->m_renderData.pMonitor->m_transform)),
+                                 g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y);
 
-        CBox monitorSpaceBox = {transformedBox.pos().x / m_renderData.pMonitor->m_pixelSize.x * m_renderData.pMonitor->m_transformedSize.x,
-                                transformedBox.pos().y / m_renderData.pMonitor->m_pixelSize.y * m_renderData.pMonitor->m_transformedSize.y,
-                                transformedBox.width / m_renderData.pMonitor->m_pixelSize.x * m_renderData.pMonitor->m_transformedSize.x,
-                                transformedBox.height / m_renderData.pMonitor->m_pixelSize.y * m_renderData.pMonitor->m_transformedSize.y};
+        CBox monitorSpaceBox = {transformedBox.pos().x / g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.x * g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x,
+                                transformedBox.pos().y / g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.y * g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y,
+                                transformedBox.width / g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.x * g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x,
+                                transformedBox.height / g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.y * g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y};
 
-        m_renderData.primarySurfaceUVTopLeft     = monitorSpaceBox.pos() / m_renderData.pMonitor->m_transformedSize;
-        m_renderData.primarySurfaceUVBottomRight = (monitorSpaceBox.pos() + monitorSpaceBox.size()) / m_renderData.pMonitor->m_transformedSize;
+        g_pHyprRenderer->m_renderData.primarySurfaceUVTopLeft     = monitorSpaceBox.pos() / g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize;
+        g_pHyprRenderer->m_renderData.primarySurfaceUVBottomRight = (monitorSpaceBox.pos() + monitorSpaceBox.size()) / g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize;
 
         static auto PBLURIGNOREOPACITY = CConfigValue<Hyprlang::INT>("decoration:blur:ignore_opacity");
         g_pHyprRenderer->pushMonitorTransformEnabled(true);
-        bool renderModif = m_renderData.renderModif.enabled;
+        bool renderModif = g_pHyprRenderer->m_renderData.renderModif.enabled;
         if (!USENEWOPTIMIZE)
             setRenderModifEnabled(false);
         renderTextureInternal(blurredBG, box,
@@ -2129,8 +2149,8 @@ void CHyprOpenGLImpl::renderTextureWithBlurInternal(SP<ITexture> tex, const CBox
         if (NEEDS_STENCIL)
             setCapStatus(GL_STENCIL_TEST, false);
 
-        m_renderData.primarySurfaceUVTopLeft     = LASTTL;
-        m_renderData.primarySurfaceUVBottomRight = LASTBR;
+        g_pHyprRenderer->m_renderData.primarySurfaceUVTopLeft     = LASTTL;
+        g_pHyprRenderer->m_renderData.primarySurfaceUVBottomRight = LASTBR;
     }
 
     // draw window
@@ -2150,27 +2170,27 @@ void CHyprOpenGLImpl::renderTextureWithBlurInternal(SP<ITexture> tex, const CBox
                               .blurredBG     = blurredBG,
                           });
 
-    GLFB(m_renderData.currentFB)->invalidate({GL_STENCIL_ATTACHMENT});
+    GLFB(g_pHyprRenderer->m_renderData.currentFB)->invalidate({GL_STENCIL_ATTACHMENT});
     scissor(nullptr);
 }
 
 void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& grad, SBorderRenderData data) {
     RASSERT((box.width > 0 && box.height > 0), "Tried to render rect with width/height < 0!");
-    RASSERT(m_renderData.pMonitor, "Tried to render rect without begin()!");
+    RASSERT(g_pHyprRenderer->m_renderData.pMonitor, "Tried to render rect without begin()!");
 
     TRACY_GPU_ZONE("RenderBorder");
 
-    if (m_renderData.damage.empty())
+    if (g_pHyprRenderer->m_renderData.damage.empty())
         return;
 
     CBox newBox = box;
-    m_renderData.renderModif.applyToBox(newBox);
+    g_pHyprRenderer->m_renderData.renderModif.applyToBox(newBox);
 
     if (data.borderSize < 1)
         return;
 
-    int scaledBorderSize = std::round(data.borderSize * m_renderData.pMonitor->m_scale);
-    scaledBorderSize     = std::round(scaledBorderSize * m_renderData.renderModif.combinedScale());
+    int scaledBorderSize = std::round(data.borderSize * g_pHyprRenderer->m_renderData.pMonitor->m_scale);
+    scaledBorderSize     = std::round(scaledBorderSize * g_pHyprRenderer->m_renderData.renderModif.combinedScale());
 
     // adjust box
     newBox.x -= scaledBorderSize;
@@ -2180,10 +2200,12 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
 
     float  round = data.round + (data.round == 0 ? 0 : scaledBorderSize);
 
-    Mat3x3 matrix = m_renderData.monitorProjection.projectBox(
-        newBox, Math::wlTransformToHyprutils(Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform)),
+    Mat3x3 matrix = g_pHyprRenderer->m_renderData.monitorProjection.projectBox(
+        newBox,
+        Math::wlTransformToHyprutils(
+            Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : g_pHyprRenderer->m_renderData.pMonitor->m_transform)),
         newBox.rot);
-    Mat3x3     glMatrix = m_renderData.projection.copy().multiply(matrix);
+    Mat3x3     glMatrix = g_pHyprRenderer->m_renderData.projection.copy().multiply(matrix);
 
     const auto BLEND = m_blend;
     blend(true);
@@ -2206,8 +2228,8 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
     shader->setUniformInt(SHADER_GRADIENT2_LENGTH, 0);
 
     CBox transformedBox = newBox;
-    transformedBox.transform(Math::wlTransformToHyprutils(Math::invertTransform(m_renderData.pMonitor->m_transform)), m_renderData.pMonitor->m_transformedSize.x,
-                             m_renderData.pMonitor->m_transformedSize.y);
+    transformedBox.transform(Math::wlTransformToHyprutils(Math::invertTransform(g_pHyprRenderer->m_renderData.pMonitor->m_transform)),
+                             g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y);
 
     const auto TOPLEFT  = Vector2D(transformedBox.x, transformedBox.y);
     const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height);
@@ -2224,15 +2246,15 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
 
     // calculate the border's region, which we need to render over. No need to run the shader on
     // things outside there
-    CRegion borderRegion = m_renderData.damage.copy().intersect(newBox);
+    CRegion borderRegion = g_pHyprRenderer->m_renderData.damage.copy().intersect(newBox);
     borderRegion.subtract(box.copy().expand(-scaledBorderSize - round));
 
-    if (m_renderData.clipBox.width != 0 && m_renderData.clipBox.height != 0)
-        borderRegion.intersect(m_renderData.clipBox);
+    if (g_pHyprRenderer->m_renderData.clipBox.width != 0 && g_pHyprRenderer->m_renderData.clipBox.height != 0)
+        borderRegion.intersect(g_pHyprRenderer->m_renderData.clipBox);
 
     if (!borderRegion.empty()) {
         borderRegion.forEachRect([this](const auto& RECT) {
-            scissor(&RECT, m_renderData.transformDamage);
+            scissor(&RECT, g_pHyprRenderer->m_renderData.transformDamage);
             glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
         });
     }
@@ -2244,21 +2266,21 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
 
 void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& grad1, const CGradientValueData& grad2, float lerp, SBorderRenderData data) {
     RASSERT((box.width > 0 && box.height > 0), "Tried to render rect with width/height < 0!");
-    RASSERT(m_renderData.pMonitor, "Tried to render rect without begin()!");
+    RASSERT(g_pHyprRenderer->m_renderData.pMonitor, "Tried to render rect without begin()!");
 
     TRACY_GPU_ZONE("RenderBorder2");
 
-    if (m_renderData.damage.empty())
+    if (g_pHyprRenderer->m_renderData.damage.empty())
         return;
 
     CBox newBox = box;
-    m_renderData.renderModif.applyToBox(newBox);
+    g_pHyprRenderer->m_renderData.renderModif.applyToBox(newBox);
 
     if (data.borderSize < 1)
         return;
 
-    int scaledBorderSize = std::round(data.borderSize * m_renderData.pMonitor->m_scale);
-    scaledBorderSize     = std::round(scaledBorderSize * m_renderData.renderModif.combinedScale());
+    int scaledBorderSize = std::round(data.borderSize * g_pHyprRenderer->m_renderData.pMonitor->m_scale);
+    scaledBorderSize     = std::round(scaledBorderSize * g_pHyprRenderer->m_renderData.renderModif.combinedScale());
 
     // adjust box
     newBox.x -= scaledBorderSize;
@@ -2268,10 +2290,12 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
 
     float  round = data.round + (data.round == 0 ? 0 : scaledBorderSize);
 
-    Mat3x3 matrix = m_renderData.monitorProjection.projectBox(
-        newBox, Math::wlTransformToHyprutils(Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform)),
+    Mat3x3 matrix = g_pHyprRenderer->m_renderData.monitorProjection.projectBox(
+        newBox,
+        Math::wlTransformToHyprutils(
+            Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : g_pHyprRenderer->m_renderData.pMonitor->m_transform)),
         newBox.rot);
-    Mat3x3     glMatrix = m_renderData.projection.copy().multiply(matrix);
+    Mat3x3     glMatrix = g_pHyprRenderer->m_renderData.projection.copy().multiply(matrix);
 
     const auto BLEND = m_blend;
     blend(true);
@@ -2297,8 +2321,8 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
     shader->setUniformFloat(SHADER_GRADIENT_LERP, lerp);
 
     CBox transformedBox = newBox;
-    transformedBox.transform(Math::wlTransformToHyprutils(Math::invertTransform(m_renderData.pMonitor->m_transform)), m_renderData.pMonitor->m_transformedSize.x,
-                             m_renderData.pMonitor->m_transformedSize.y);
+    transformedBox.transform(Math::wlTransformToHyprutils(Math::invertTransform(g_pHyprRenderer->m_renderData.pMonitor->m_transform)),
+                             g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y);
 
     const auto TOPLEFT  = Vector2D(transformedBox.x, transformedBox.y);
     const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height);
@@ -2315,15 +2339,15 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
 
     // calculate the border's region, which we need to render over. No need to run the shader on
     // things outside there
-    CRegion borderRegion = m_renderData.damage.copy().intersect(newBox);
+    CRegion borderRegion = g_pHyprRenderer->m_renderData.damage.copy().intersect(newBox);
     borderRegion.subtract(box.copy().expand(-scaledBorderSize - round));
 
-    if (m_renderData.clipBox.width != 0 && m_renderData.clipBox.height != 0)
-        borderRegion.intersect(m_renderData.clipBox);
+    if (g_pHyprRenderer->m_renderData.clipBox.width != 0 && g_pHyprRenderer->m_renderData.clipBox.height != 0)
+        borderRegion.intersect(g_pHyprRenderer->m_renderData.clipBox);
 
     if (!borderRegion.empty()) {
         borderRegion.forEachRect([this](const auto& RECT) {
-            scissor(&RECT, m_renderData.transformDamage);
+            scissor(&RECT, g_pHyprRenderer->m_renderData.transformDamage);
             glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
         });
     }
@@ -2333,16 +2357,16 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
 }
 
 void CHyprOpenGLImpl::renderRoundedShadow(const CBox& box, int round, float roundingPower, int range, const CHyprColor& color, float a) {
-    RASSERT(m_renderData.pMonitor, "Tried to render shadow without begin()!");
+    RASSERT(g_pHyprRenderer->m_renderData.pMonitor, "Tried to render shadow without begin()!");
     RASSERT((box.width > 0 && box.height > 0), "Tried to render shadow with width/height < 0!");
 
-    if (m_renderData.damage.empty())
+    if (g_pHyprRenderer->m_renderData.damage.empty())
         return;
 
     TRACY_GPU_ZONE("RenderShadow");
 
     CBox newBox = box;
-    m_renderData.renderModif.applyToBox(newBox);
+    g_pHyprRenderer->m_renderData.renderModif.applyToBox(newBox);
 
     static auto PSHADOWPOWER = CConfigValue<Hyprlang::INT>("decoration:shadow:render_power");
 
@@ -2350,10 +2374,12 @@ void CHyprOpenGLImpl::renderRoundedShadow(const CBox& box, int round, float roun
 
     const auto  col = color;
 
-    Mat3x3      matrix = m_renderData.monitorProjection.projectBox(
-        newBox, Math::wlTransformToHyprutils(Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform)),
+    Mat3x3      matrix = g_pHyprRenderer->m_renderData.monitorProjection.projectBox(
+        newBox,
+        Math::wlTransformToHyprutils(
+            Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : g_pHyprRenderer->m_renderData.pMonitor->m_transform)),
         newBox.rot);
-    Mat3x3 glMatrix = m_renderData.projection.copy().multiply(matrix);
+    Mat3x3 glMatrix = g_pHyprRenderer->m_renderData.projection.copy().multiply(matrix);
 
     blend(true);
 
@@ -2381,19 +2407,20 @@ void CHyprOpenGLImpl::renderRoundedShadow(const CBox& box, int round, float roun
 
     glBindVertexArray(shader->getUniformLocation(SHADER_SHADER_VAO));
 
-    if (m_renderData.clipBox.width != 0 && m_renderData.clipBox.height != 0) {
-        CRegion damageClip{m_renderData.clipBox.x, m_renderData.clipBox.y, m_renderData.clipBox.width, m_renderData.clipBox.height};
-        damageClip.intersect(m_renderData.damage);
+    if (g_pHyprRenderer->m_renderData.clipBox.width != 0 && g_pHyprRenderer->m_renderData.clipBox.height != 0) {
+        CRegion damageClip{g_pHyprRenderer->m_renderData.clipBox.x, g_pHyprRenderer->m_renderData.clipBox.y, g_pHyprRenderer->m_renderData.clipBox.width,
+                           g_pHyprRenderer->m_renderData.clipBox.height};
+        damageClip.intersect(g_pHyprRenderer->m_renderData.damage);
 
         if (!damageClip.empty()) {
             damageClip.forEachRect([this](const auto& RECT) {
-                scissor(&RECT, m_renderData.transformDamage);
+                scissor(&RECT, g_pHyprRenderer->m_renderData.transformDamage);
                 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
             });
         }
     } else {
-        m_renderData.damage.forEachRect([this](const auto& RECT) {
-            scissor(&RECT, m_renderData.transformDamage);
+        g_pHyprRenderer->m_renderData.damage.forEachRect([this](const auto& RECT) {
+            scissor(&RECT, g_pHyprRenderer->m_renderData.transformDamage);
             glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
         });
     }
@@ -2402,20 +2429,21 @@ void CHyprOpenGLImpl::renderRoundedShadow(const CBox& box, int round, float roun
 }
 
 void CHyprOpenGLImpl::saveBufferForMirror(const CBox& box) {
-    if (!m_renderData.pMonitor->m_monitorMirrorFB)
-        m_renderData.pMonitor->m_monitorMirrorFB = g_pHyprRenderer->createFB();
+    if (!g_pHyprRenderer->m_renderData.pMonitor->m_monitorMirrorFB)
+        g_pHyprRenderer->m_renderData.pMonitor->m_monitorMirrorFB = g_pHyprRenderer->createFB();
 
-    if (!m_renderData.pMonitor->m_monitorMirrorFB->isAllocated())
-        m_renderData.pMonitor->m_monitorMirrorFB->alloc(m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y,
-                                                        m_renderData.pMonitor->m_output->state->state().drmFormat);
+    if (!g_pHyprRenderer->m_renderData.pMonitor->m_monitorMirrorFB->isAllocated())
+        g_pHyprRenderer->m_renderData.pMonitor->m_monitorMirrorFB->alloc(g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.x,
+                                                                         g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.y,
+                                                                         g_pHyprRenderer->m_renderData.pMonitor->m_output->state->state().drmFormat);
 
-    m_renderData.pMonitor->m_monitorMirrorFB->bind();
+    g_pHyprRenderer->m_renderData.pMonitor->m_monitorMirrorFB->bind();
 
     blend(false);
 
-    renderTexture(m_renderData.currentFB->getTexture(), box,
+    renderTexture(g_pHyprRenderer->m_renderData.currentFB->getTexture(), box,
                   STextureRenderData{
-                      .damage        = &m_renderData.finalDamage,
+                      .damage        = &g_pHyprRenderer->m_renderData.finalDamage,
                       .a             = 1.F,
                       .round         = 0,
                       .discardActive = false,
@@ -2425,12 +2453,12 @@ void CHyprOpenGLImpl::saveBufferForMirror(const CBox& box) {
 
     blend(true);
 
-    m_renderData.currentFB->bind();
+    g_pHyprRenderer->m_renderData.currentFB->bind();
 }
 
 void CHyprOpenGLImpl::renderMirrored() {
 
-    auto         monitor  = m_renderData.pMonitor;
+    auto         monitor  = g_pHyprRenderer->m_renderData.pMonitor;
     auto         mirrored = monitor->m_mirrorOf;
 
     const double scale  = std::min(monitor->m_transformedSize.x / mirrored->m_transformedSize.x, monitor->m_transformedSize.y / mirrored->m_transformedSize.y);
@@ -2531,7 +2559,7 @@ WP<CShader> CHyprOpenGLImpl::useShader(WP<CShader> prog) {
 }
 
 void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
-    RASSERT(m_renderData.pMonitor, "Tried to createBGTex without begin()!");
+    RASSERT(g_pHyprRenderer->m_renderData.pMonitor, "Tried to createBGTex without begin()!");
 
     Log::logger->log(Log::DEBUG, "Creating a texture for BGTex");
 
@@ -2608,17 +2636,17 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
 
     // first render the background
     if (backgroundTexture) {
-        const double MONRATIO = m_renderData.pMonitor->m_transformedSize.x / m_renderData.pMonitor->m_transformedSize.y;
+        const double MONRATIO = g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x / g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y;
         const double WPRATIO  = backgroundTexture->m_size.x / backgroundTexture->m_size.y;
         Vector2D     origin;
         double       scale = 1.0;
 
         if (MONRATIO > WPRATIO) {
-            scale    = m_renderData.pMonitor->m_transformedSize.x / backgroundTexture->m_size.x;
-            origin.y = (m_renderData.pMonitor->m_transformedSize.y - backgroundTexture->m_size.y * scale) / 2.0;
+            scale    = g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x / backgroundTexture->m_size.x;
+            origin.y = (g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y - backgroundTexture->m_size.y * scale) / 2.0;
         } else {
-            scale    = m_renderData.pMonitor->m_transformedSize.y / backgroundTexture->m_size.y;
-            origin.x = (m_renderData.pMonitor->m_transformedSize.x - backgroundTexture->m_size.x * scale) / 2.0;
+            scale    = g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y / backgroundTexture->m_size.y;
+            origin.x = (g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x - backgroundTexture->m_size.x * scale) / 2.0;
         }
 
         CBox texbox = CBox{origin, backgroundTexture->m_size * scale};
@@ -2629,8 +2657,8 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
     renderTextureInternal(tex, monbox, {.damage = &fakeDamage, .a = 1.0});
 
     // bind back
-    if (m_renderData.currentFB)
-        m_renderData.currentFB->bind();
+    if (g_pHyprRenderer->m_renderData.currentFB)
+        g_pHyprRenderer->m_renderData.currentFB->bind();
 
     Log::logger->log(Log::DEBUG, "Background created for monitor {}", pMonitor->m_name);
 
@@ -2643,21 +2671,21 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
 }
 
 void CHyprOpenGLImpl::clearWithTex() {
-    RASSERT(m_renderData.pMonitor, "Tried to render BGtex without begin()!");
+    RASSERT(g_pHyprRenderer->m_renderData.pMonitor, "Tried to render BGtex without begin()!");
 
     static auto PBACKGROUNDCOLOR = CConfigValue<Hyprlang::INT>("misc:background_color");
 
-    auto        TEXIT = m_monitorBGFBs.find(m_renderData.pMonitor);
+    auto        TEXIT = m_monitorBGFBs.find(g_pHyprRenderer->m_renderData.pMonitor);
 
     if (TEXIT == m_monitorBGFBs.end()) {
-        createBGTextureForMonitor(m_renderData.pMonitor.lock());
+        createBGTextureForMonitor(g_pHyprRenderer->m_renderData.pMonitor.lock());
         g_pHyprRenderer->m_renderPass.add(makeUnique<CClearPassElement>(CClearPassElement::SClearData{CHyprColor(*PBACKGROUNDCOLOR)}));
     }
 
     if (TEXIT != m_monitorBGFBs.end()) {
         CTexPassElement::SRenderData data;
-        data.box          = {0, 0, m_renderData.pMonitor->m_transformedSize.x, m_renderData.pMonitor->m_transformedSize.y};
-        data.a            = m_renderData.pMonitor->m_backgroundOpacity->value();
+        data.box          = {0, 0, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y};
+        data.a            = g_pHyprRenderer->m_renderData.pMonitor->m_backgroundOpacity->value();
         data.flipEndFrame = true;
         data.tex          = TEXIT->second->getTexture();
         g_pHyprRenderer->m_renderPass.add(makeUnique<CTexPassElement>(std::move(data)));
@@ -2681,44 +2709,44 @@ void CHyprOpenGLImpl::destroyMonitorResources(PHLMONITORREF pMonitor) {
 }
 
 void CHyprOpenGLImpl::saveMatrix() {
-    m_renderData.savedProjection = m_renderData.projection;
+    g_pHyprRenderer->m_renderData.savedProjection = g_pHyprRenderer->m_renderData.projection;
 }
 
 void CHyprOpenGLImpl::setMatrixScaleTranslate(const Vector2D& translate, const float& scale) {
-    m_renderData.projection.scale(scale).translate(translate);
+    g_pHyprRenderer->m_renderData.projection.scale(scale).translate(translate);
 }
 
 void CHyprOpenGLImpl::restoreMatrix() {
-    m_renderData.projection = m_renderData.savedProjection;
+    g_pHyprRenderer->m_renderData.projection = g_pHyprRenderer->m_renderData.savedProjection;
 }
 
 void CHyprOpenGLImpl::bindOffMain() {
-    if (!m_renderData.pMonitor->m_offMainFB)
-        m_renderData.pMonitor->m_offMainFB = g_pHyprRenderer->createFB();
+    if (!g_pHyprRenderer->m_renderData.pMonitor->m_offMainFB)
+        g_pHyprRenderer->m_renderData.pMonitor->m_offMainFB = g_pHyprRenderer->createFB();
 
-    if (!m_renderData.pMonitor->m_offMainFB->isAllocated()) {
-        m_renderData.pMonitor->m_offMainFB->addStencil(m_renderData.pMonitor->m_stencilTex);
-        m_renderData.pMonitor->m_offMainFB->alloc(m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y,
-                                                  m_renderData.pMonitor->m_output->state->state().drmFormat);
+    if (!g_pHyprRenderer->m_renderData.pMonitor->m_offMainFB->isAllocated()) {
+        g_pHyprRenderer->m_renderData.pMonitor->m_offMainFB->addStencil(g_pHyprRenderer->m_renderData.pMonitor->m_stencilTex);
+        g_pHyprRenderer->m_renderData.pMonitor->m_offMainFB->alloc(g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.y,
+                                                                   g_pHyprRenderer->m_renderData.pMonitor->m_output->state->state().drmFormat);
     }
 
-    m_renderData.pMonitor->m_offMainFB->bind();
+    g_pHyprRenderer->m_renderData.pMonitor->m_offMainFB->bind();
     clear(CHyprColor(0, 0, 0, 0));
-    m_renderData.currentFB = m_renderData.pMonitor->m_offMainFB;
+    g_pHyprRenderer->m_renderData.currentFB = g_pHyprRenderer->m_renderData.pMonitor->m_offMainFB;
 }
 
 void CHyprOpenGLImpl::renderOffToMain(CGLFramebuffer* off) {
-    CBox monbox = {0, 0, m_renderData.pMonitor->m_transformedSize.x, m_renderData.pMonitor->m_transformedSize.y};
+    CBox monbox = {0, 0, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_transformedSize.y};
     renderTexturePrimitive(off->getTexture(), monbox);
 }
 
 void CHyprOpenGLImpl::bindBackOnMain() {
-    m_renderData.mainFB->bind();
-    m_renderData.currentFB = m_renderData.mainFB;
+    g_pHyprRenderer->m_renderData.mainFB->bind();
+    g_pHyprRenderer->m_renderData.currentFB = g_pHyprRenderer->m_renderData.mainFB;
 }
 
 void CHyprOpenGLImpl::setRenderModifEnabled(bool enabled) {
-    m_renderData.renderModif.enabled = enabled;
+    g_pHyprRenderer->m_renderData.renderModif.enabled = enabled;
 }
 
 void CHyprOpenGLImpl::setViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
diff --git a/src/render/OpenGL.hpp b/src/render/OpenGL.hpp
index aa8354dd..77d715a9 100644
--- a/src/render/OpenGL.hpp
+++ b/src/render/OpenGL.hpp
@@ -277,8 +277,6 @@ class CHyprOpenGLImpl {
     bool                                      m_shadersInitialized = false;
     SP<SPreparedShaders>                      m_shaders;
 
-    SCurrentRenderData                        m_renderData;
-
     Hyprutils::OS::CFileDescriptor            m_gbmFD;
     gbm_device*                               m_gbmDevice  = nullptr;
     EGLContext                                m_eglContext = nullptr;
diff --git a/src/render/Renderer.cpp b/src/render/Renderer.cpp
index 82dd4ce1..f8cf6c6d 100644
--- a/src/render/Renderer.cpp
+++ b/src/render/Renderer.cpp
@@ -566,14 +566,14 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
     renderdata.pWindow = pWindow;
 
     // for plugins
-    g_pHyprOpenGL->m_renderData.currentWindow = pWindow;
+    m_renderData.currentWindow = pWindow;
 
     Event::bus()->m_events.render.stage.emit(RENDER_PRE_WINDOW);
 
     const auto fullAlpha = renderdata.alpha * renderdata.fadeAlpha;
 
     if (*PDIMAROUND && pWindow->m_ruleApplicator->dimAround().valueOrDefault() && !m_bRenderingSnapshot && mode != RENDER_PASS_POPUP) {
-        CBox                        monbox = {0, 0, g_pHyprOpenGL->m_renderData.pMonitor->m_transformedSize.x, g_pHyprOpenGL->m_renderData.pMonitor->m_transformedSize.y};
+        CBox                        monbox = {0, 0, m_renderData.pMonitor->m_transformedSize.x, m_renderData.pMonitor->m_transformedSize.y};
         CRectPassElement::SRectData data;
         data.color = CHyprColor(0, 0, 0, *PDIMAROUND * fullAlpha);
         data.box   = monbox;
@@ -667,7 +667,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
         }
 
         if (TRANSFORMERSPRESENT) {
-            IFramebuffer* last = g_pHyprOpenGL->m_renderData.currentFB.get();
+            IFramebuffer* last = m_renderData.currentFB.get();
             for (auto const& t : pWindow->m_transformers) {
                 last = t->transform(last);
             }
@@ -677,7 +677,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
         }
     }
 
-    g_pHyprOpenGL->m_renderData.clipBox = CBox();
+    m_renderData.clipBox = CBox();
 
     if (mode == RENDER_PASS_ALL || mode == RENDER_PASS_POPUP) {
         if (!pWindow->m_isX11) {
@@ -754,7 +754,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
 
     Event::bus()->m_events.render.stage.emit(RENDER_POST_WINDOW);
 
-    g_pHyprOpenGL->m_renderData.currentWindow.reset();
+    m_renderData.currentWindow.reset();
 }
 
 void CHyprRenderer::draw(WP<IPassElement> element, const CRegion& damage) {
@@ -799,9 +799,9 @@ void CHyprRenderer::draw(CFramebufferElement* element, const CRegion& damage) {
 
     if (m_data.main) {
         switch (m_data.framebufferID) {
-            case FB_MONITOR_RENDER_MAIN: fb = g_pHyprOpenGL->m_renderData.mainFB; break;
-            case FB_MONITOR_RENDER_CURRENT: fb = g_pHyprOpenGL->m_renderData.currentFB; break;
-            case FB_MONITOR_RENDER_OUT: fb = g_pHyprOpenGL->m_renderData.outFB; break;
+            case FB_MONITOR_RENDER_MAIN: fb = m_renderData.mainFB; break;
+            case FB_MONITOR_RENDER_CURRENT: fb = m_renderData.currentFB; break;
+            case FB_MONITOR_RENDER_OUT: fb = m_renderData.outFB; break;
         }
 
         if (!fb) {
@@ -811,12 +811,12 @@ void CHyprRenderer::draw(CFramebufferElement* element, const CRegion& damage) {
 
     } else {
         switch (m_data.framebufferID) {
-            case FB_MONITOR_RENDER_EXTRA_OFFLOAD: fb = g_pHyprOpenGL->m_renderData.pMonitor->m_offloadFB; break;
-            case FB_MONITOR_RENDER_EXTRA_MIRROR: fb = g_pHyprOpenGL->m_renderData.pMonitor->m_mirrorFB; break;
-            case FB_MONITOR_RENDER_EXTRA_MIRROR_SWAP: fb = g_pHyprOpenGL->m_renderData.pMonitor->m_mirrorSwapFB; break;
-            case FB_MONITOR_RENDER_EXTRA_OFF_MAIN: fb = g_pHyprOpenGL->m_renderData.pMonitor->m_offMainFB; break;
-            case FB_MONITOR_RENDER_EXTRA_MONITOR_MIRROR: fb = g_pHyprOpenGL->m_renderData.pMonitor->m_monitorMirrorFB; break;
-            case FB_MONITOR_RENDER_EXTRA_BLUR: fb = g_pHyprOpenGL->m_renderData.pMonitor->m_blurFB; break;
+            case FB_MONITOR_RENDER_EXTRA_OFFLOAD: fb = m_renderData.pMonitor->m_offloadFB; break;
+            case FB_MONITOR_RENDER_EXTRA_MIRROR: fb = m_renderData.pMonitor->m_mirrorFB; break;
+            case FB_MONITOR_RENDER_EXTRA_MIRROR_SWAP: fb = m_renderData.pMonitor->m_mirrorSwapFB; break;
+            case FB_MONITOR_RENDER_EXTRA_OFF_MAIN: fb = m_renderData.pMonitor->m_offMainFB; break;
+            case FB_MONITOR_RENDER_EXTRA_MONITOR_MIRROR: fb = m_renderData.pMonitor->m_monitorMirrorFB; break;
+            case FB_MONITOR_RENDER_EXTRA_BLUR: fb = m_renderData.pMonitor->m_blurFB; break;
         }
 
         if (!fb) {
@@ -838,7 +838,7 @@ void CHyprRenderer::draw(CRectPassElement* element, const CRegion& damage) {
         return;
 
     if (!m_data.clipBox.empty())
-        g_pHyprOpenGL->m_renderData.clipBox = m_data.clipBox;
+        m_renderData.clipBox = m_data.clipBox;
 
     if (m_data.color.a == 1.F || !m_data.blur)
         g_pHyprOpenGL->renderRect(m_data.box, m_data.color, {.damage = &damage, .round = m_data.round, .roundingPower = m_data.roundingPower});
@@ -846,45 +846,45 @@ void CHyprRenderer::draw(CRectPassElement* element, const CRegion& damage) {
         g_pHyprOpenGL->renderRect(m_data.box, m_data.color,
                                   {.round = m_data.round, .roundingPower = m_data.roundingPower, .blur = true, .blurA = m_data.blurA, .xray = m_data.xray});
 
-    g_pHyprOpenGL->m_renderData.clipBox = {};
+    m_renderData.clipBox = {};
 };
 
 void CHyprRenderer::draw(CRendererHintsPassElement* element, const CRegion& damage) {
     const auto& m_data = element->m_data;
     if (m_data.renderModif.has_value())
-        g_pHyprOpenGL->m_renderData.renderModif = *m_data.renderModif;
+        m_renderData.renderModif = *m_data.renderModif;
 };
 
 void CHyprRenderer::draw(CShadowPassElement* element, const CRegion& damage) {
     const auto& m_data = element->m_data;
-    m_data.deco->render(g_pHyprOpenGL->m_renderData.pMonitor.lock(), m_data.a);
+    m_data.deco->render(m_renderData.pMonitor.lock(), m_data.a);
 };
 
 void CHyprRenderer::draw(CSurfacePassElement* element, const CRegion& damage) {
     const auto& m_data = element->m_data;
 
-    g_pHyprOpenGL->m_renderData.currentWindow      = m_data.pWindow;
-    g_pHyprOpenGL->m_renderData.surface            = m_data.surface;
-    g_pHyprOpenGL->m_renderData.currentLS          = m_data.pLS;
-    g_pHyprOpenGL->m_renderData.clipBox            = m_data.clipBox;
-    g_pHyprOpenGL->m_renderData.discardMode        = m_data.discardMode;
-    g_pHyprOpenGL->m_renderData.discardOpacity     = m_data.discardOpacity;
-    g_pHyprOpenGL->m_renderData.useNearestNeighbor = m_data.useNearestNeighbor;
+    m_renderData.currentWindow      = m_data.pWindow;
+    m_renderData.surface            = m_data.surface;
+    m_renderData.currentLS          = m_data.pLS;
+    m_renderData.clipBox            = m_data.clipBox;
+    m_renderData.discardMode        = m_data.discardMode;
+    m_renderData.discardOpacity     = m_data.discardOpacity;
+    m_renderData.useNearestNeighbor = m_data.useNearestNeighbor;
     pushMonitorTransformEnabled(m_data.flipEndFrame);
 
-    CScopeGuard x = {[]() {
-        g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft     = Vector2D(-1, -1);
-        g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
-        g_pHyprOpenGL->m_renderData.useNearestNeighbor          = false;
-        g_pHyprOpenGL->m_renderData.clipBox                     = {};
-        g_pHyprOpenGL->m_renderData.clipRegion                  = {};
-        g_pHyprOpenGL->m_renderData.discardMode                 = 0;
-        g_pHyprOpenGL->m_renderData.discardOpacity              = 0;
-        g_pHyprOpenGL->m_renderData.useNearestNeighbor          = false;
+    CScopeGuard x = {[&]() {
+        m_renderData.primarySurfaceUVTopLeft     = Vector2D(-1, -1);
+        m_renderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
+        m_renderData.useNearestNeighbor          = false;
+        m_renderData.clipBox                     = {};
+        m_renderData.clipRegion                  = {};
+        m_renderData.discardMode                 = 0;
+        m_renderData.discardOpacity              = 0;
+        m_renderData.useNearestNeighbor          = false;
         g_pHyprRenderer->popMonitorTransformEnabled();
-        g_pHyprOpenGL->m_renderData.currentWindow.reset();
-        g_pHyprOpenGL->m_renderData.surface.reset();
-        g_pHyprOpenGL->m_renderData.currentLS.reset();
+        m_renderData.currentWindow.reset();
+        m_renderData.surface.reset();
+        m_renderData.currentLS.reset();
     }};
 
     if (!m_data.texture)
@@ -926,8 +926,8 @@ void CHyprRenderer::draw(CSurfacePassElement* element, const CRegion& damage) {
 
     calculateUVForSurface(m_data.pWindow, m_data.surface, m_data.pMonitor->m_self.lock(), m_data.mainSurface, windowBox.size(), PROJSIZEUNSCALED, MISALIGNEDFSV1);
 
-    auto cancelRender                      = false;
-    g_pHyprOpenGL->m_renderData.clipRegion = element->visibleRegion(cancelRender);
+    auto cancelRender       = false;
+    m_renderData.clipRegion = element->visibleRegion(cancelRender);
     if (cancelRender)
         return;
 
@@ -936,7 +936,7 @@ void CHyprRenderer::draw(CSurfacePassElement* element, const CRegion& damage) {
     // as long as the window is not animated. During those it'd look weird.
     // UV will fixup it as well
     if (MISALIGNEDFSV1)
-        g_pHyprOpenGL->m_renderData.useNearestNeighbor = true;
+        m_renderData.useNearestNeighbor = true;
 
     float rounding      = m_data.rounding;
     float roundingPower = m_data.roundingPower;
@@ -1013,22 +1013,22 @@ void CHyprRenderer::draw(CTexPassElement* element, const CRegion& damage) {
     CScopeGuard x = {[&]() {
         //
         g_pHyprRenderer->popMonitorTransformEnabled();
-        g_pHyprOpenGL->m_renderData.clipBox = {};
+        m_renderData.clipBox = {};
         if (m_data.replaceProjection)
-            g_pHyprOpenGL->m_renderData.monitorProjection = g_pHyprOpenGL->m_renderData.pMonitor->m_projMatrix;
+            m_renderData.monitorProjection = m_renderData.pMonitor->m_projMatrix;
         if (m_data.ignoreAlpha.has_value())
-            g_pHyprOpenGL->m_renderData.discardMode = 0;
+            m_renderData.discardMode = 0;
     }};
 
     if (!m_data.clipBox.empty())
-        g_pHyprOpenGL->m_renderData.clipBox = m_data.clipBox;
+        m_renderData.clipBox = m_data.clipBox;
 
     if (m_data.replaceProjection)
-        g_pHyprOpenGL->m_renderData.monitorProjection = *m_data.replaceProjection;
+        m_renderData.monitorProjection = *m_data.replaceProjection;
 
     if (m_data.ignoreAlpha.has_value()) {
-        g_pHyprOpenGL->m_renderData.discardMode    = DISCARD_ALPHA;
-        g_pHyprOpenGL->m_renderData.discardOpacity = *m_data.ignoreAlpha;
+        m_renderData.discardMode    = DISCARD_ALPHA;
+        m_renderData.discardOpacity = *m_data.ignoreAlpha;
     }
 
     if (m_data.blur) {
@@ -1117,7 +1117,7 @@ void CHyprRenderer::renderLayer(PHLLS pLayer, PHLMONITOR pMonitor, const Time::s
 
     if (*PDIMAROUND && pLayer->m_ruleApplicator->dimAround().valueOrDefault() && !m_bRenderingSnapshot && !popups) {
         CRectPassElement::SRectData data;
-        data.box   = {0, 0, g_pHyprOpenGL->m_renderData.pMonitor->m_transformedSize.x, g_pHyprOpenGL->m_renderData.pMonitor->m_transformedSize.y};
+        data.box   = {0, 0, m_renderData.pMonitor->m_transformedSize.x, m_renderData.pMonitor->m_transformedSize.y};
         data.color = CHyprColor(0, 0, 0, *PDIMAROUND * pLayer->m_alpha->value());
         m_renderPass.add(makeUnique<CRectPassElement>(data));
     }
@@ -1539,7 +1539,7 @@ bool CHyprRenderer::shouldUseNewBlurOptimizations(PHLLS pLayer, PHLWINDOW pWindo
     static auto PBLURNEWOPTIMIZE = CConfigValue<Hyprlang::INT>("decoration:blur:new_optimizations");
     static auto PBLURXRAY        = CConfigValue<Hyprlang::INT>("decoration:blur:xray");
 
-    if (!g_pHyprOpenGL->m_renderData.pMonitor || !g_pHyprOpenGL->m_renderData.pMonitor->m_blurFB || !g_pHyprOpenGL->m_renderData.pMonitor->m_blurFB->getTexture())
+    if (!m_renderData.pMonitor || !m_renderData.pMonitor->m_blurFB || !m_renderData.pMonitor->m_blurFB->getTexture())
         return false;
 
     if (pWindow && pWindow->m_ruleApplicator->xray().hasValue() && !pWindow->m_ruleApplicator->xray().valueOrDefault())
@@ -1833,13 +1833,13 @@ void CHyprRenderer::calculateUVForSurface(PHLWINDOW pWindow, SP<CWLSurfaceResour
             }
         }
 
-        g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft     = uvTL;
-        g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight = uvBR;
+        m_renderData.primarySurfaceUVTopLeft     = uvTL;
+        m_renderData.primarySurfaceUVBottomRight = uvBR;
 
-        if (g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft == Vector2D() && g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight == Vector2D(1, 1)) {
+        if (m_renderData.primarySurfaceUVTopLeft == Vector2D() && m_renderData.primarySurfaceUVBottomRight == Vector2D(1, 1)) {
             // No special UV mods needed
-            g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft     = Vector2D(-1, -1);
-            g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
+            m_renderData.primarySurfaceUVTopLeft     = Vector2D(-1, -1);
+            m_renderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
         }
 
         if (!main || !pWindow)
@@ -1861,17 +1861,17 @@ void CHyprRenderer::calculateUVForSurface(PHLWINDOW pWindow, SP<CWLSurfaceResour
         //     uvTL               = uvTL + TOADDTL;
         // }
 
-        g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft     = uvTL;
-        g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight = uvBR;
+        m_renderData.primarySurfaceUVTopLeft     = uvTL;
+        m_renderData.primarySurfaceUVBottomRight = uvBR;
 
-        if (g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft == Vector2D() && g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight == Vector2D(1, 1)) {
+        if (m_renderData.primarySurfaceUVTopLeft == Vector2D() && m_renderData.primarySurfaceUVBottomRight == Vector2D(1, 1)) {
             // No special UV mods needed
-            g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft     = Vector2D(-1, -1);
-            g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
+            m_renderData.primarySurfaceUVTopLeft     = Vector2D(-1, -1);
+            m_renderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
         }
     } else {
-        g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft     = Vector2D(-1, -1);
-        g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
+        m_renderData.primarySurfaceUVTopLeft     = Vector2D(-1, -1);
+        m_renderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
     }
 }
 
@@ -1896,7 +1896,6 @@ SCMSettings CHyprRenderer::getCMSettings(const NColorManagement::PImageDescripti
     const auto                          sdrEOTF = NTransferFunction::fromConfig();
     NColorManagement::eTransferFunction srcTF;
 
-    auto&                               m_renderData = g_pHyprOpenGL->m_renderData;
     if (m_renderData.surface.valid()) {
         if (m_renderData.surface->m_colorManagement.valid()) {
             if (sdrEOTF == NTransferFunction::TF_FORCED_GAMMA22 && imageDescription->value().transferFunction == NColorManagement::eTransferFunction::CM_TRANSFER_FUNCTION_SRGB)
@@ -2055,14 +2054,14 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor, bool commit) {
     }
 
     if (pMonitor == g_pCompositor->getMonitorFromCursor())
-        g_pHyprOpenGL->m_renderData.mouseZoomFactor = std::clamp(ZOOMFACTOR, 1.f, INFINITY);
+        m_renderData.mouseZoomFactor = std::clamp(ZOOMFACTOR, 1.f, INFINITY);
     else
-        g_pHyprOpenGL->m_renderData.mouseZoomFactor = 1.f;
+        m_renderData.mouseZoomFactor = 1.f;
 
     if (pMonitor->m_zoomAnimProgress->value() != 1) {
-        g_pHyprOpenGL->m_renderData.mouseZoomFactor    = 2.0 - pMonitor->m_zoomAnimProgress->value(); // 2x zoom -> 1x zoom
-        g_pHyprOpenGL->m_renderData.mouseZoomUseMouse  = false;
-        g_pHyprOpenGL->m_renderData.useNearestNeighbor = false;
+        m_renderData.mouseZoomFactor    = 2.0 - pMonitor->m_zoomAnimProgress->value(); // 2x zoom -> 1x zoom
+        m_renderData.mouseZoomUseMouse  = false;
+        m_renderData.useNearestNeighbor = false;
     }
 
     CRegion damage, finalDamage;
@@ -2139,7 +2138,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor, bool commit) {
 
     if (renderCursor) {
         TRACY_GPU_ZONE("RenderCursor");
-        g_pPointerManager->renderSoftwareCursorsFor(pMonitor->m_self.lock(), NOW, g_pHyprOpenGL->m_renderData.damage);
+        g_pPointerManager->renderSoftwareCursorsFor(pMonitor->m_self.lock(), NOW, m_renderData.damage);
     }
 
     if (pMonitor->m_dpmsBlackOpacity->value() != 0.F) {
@@ -2156,7 +2155,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor, bool commit) {
 
     TRACY_GPU_COLLECT;
 
-    CRegion    frameDamage{g_pHyprOpenGL->m_renderData.damage};
+    CRegion    frameDamage{m_renderData.damage};
 
     const auto TRANSFORM = Math::invertTransform(pMonitor->m_transform);
     frameDamage.transform(Math::wlTransformToHyprutils(TRANSFORM), pMonitor->m_transformedSize.x, pMonitor->m_transformedSize.y);
@@ -2928,6 +2927,10 @@ void CHyprRenderer::initiateManualCrash() {
     **PDT = 0;
 }
 
+const SRenderData& CHyprRenderer::renderData() {
+    return m_renderData;
+}
+
 SP<IRenderbuffer> CHyprRenderer::getOrCreateRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t fmt) {
     auto it = std::ranges::find_if(m_renderbuffers, [&](const auto& other) { return other->m_hlBuffer == buffer; });
 
@@ -2951,7 +2954,7 @@ bool CHyprRenderer::beginRender(PHLMONITOR pMonitor, CRegion& damage, eRenderMod
 
     m_renderMode = mode;
 
-    g_pHyprOpenGL->m_renderData.pMonitor = pMonitor; // has to be set cuz allocs
+    m_renderData.pMonitor = pMonitor; // has to be set cuz allocs
 
     if (mode == RENDER_MODE_FULL_FAKE) {
         RASSERT(fb, "Cannot render FULL_FAKE without a provided fb!");
@@ -3001,10 +3004,10 @@ bool CHyprRenderer::beginRender(PHLMONITOR pMonitor, CRegion& damage, eRenderMod
 }
 
 void CHyprRenderer::endRender(const std::function<void()>& renderingDoneCallback) {
-    const auto  PMONITOR           = g_pHyprOpenGL->m_renderData.pMonitor;
+    const auto  PMONITOR           = m_renderData.pMonitor;
     static auto PNVIDIAANTIFLICKER = CConfigValue<Hyprlang::INT>("opengl:nvidia_anti_flicker");
 
-    g_pHyprOpenGL->m_renderData.damage = m_renderPass.render(g_pHyprOpenGL->m_renderData.damage);
+    m_renderData.damage = m_renderPass.render(m_renderData.damage);
 
     auto cleanup = CScopeGuard([this]() {
         if (m_currentRenderbuffer)
@@ -3016,9 +3019,9 @@ void CHyprRenderer::endRender(const std::function<void()>& renderingDoneCallback
     if (m_renderMode != RENDER_MODE_TO_BUFFER_READ_ONLY)
         g_pHyprOpenGL->end();
     else {
-        g_pHyprOpenGL->m_renderData.pMonitor.reset();
-        g_pHyprOpenGL->m_renderData.mouseZoomFactor   = 1.f;
-        g_pHyprOpenGL->m_renderData.mouseZoomUseMouse = true;
+        m_renderData.pMonitor.reset();
+        m_renderData.mouseZoomFactor   = 1.f;
+        m_renderData.mouseZoomUseMouse = true;
     }
 
     if (m_renderMode == RENDER_MODE_FULL_FAKE)
@@ -3274,7 +3277,7 @@ void CHyprRenderer::renderSnapshot(PHLWINDOW pWindow) {
     if (*PDIMAROUND && pWindow->m_ruleApplicator->dimAround().valueOrDefault()) {
         CRectPassElement::SRectData data;
 
-        data.box   = {0, 0, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize.x, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize.y};
+        data.box   = {0, 0, m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y};
         data.color = CHyprColor(0, 0, 0, *PDIMAROUND * pWindow->m_alpha->value());
 
         m_renderPass.add(makeUnique<CRectPassElement>(data));
@@ -3381,7 +3384,6 @@ void CHyprRenderer::renderSnapshot(WP<Desktop::View::CPopup> popup) {
 }
 
 NColorManagement::PImageDescription CHyprRenderer::workBufferImageDescription() {
-    const auto& m_renderData = g_pHyprOpenGL->m_renderData;
     // TODO
     // const bool  IS_MONITOR_ICC  = m_renderData.pMonitor->m_imageDescription.valid() && m_renderData.pMonitor->m_imageDescription->value().icc.present;
     // const auto  sdrEOTF         = NTransferFunction::fromConfig(IS_MONITOR_ICC);
diff --git a/src/render/Renderer.hpp b/src/render/Renderer.hpp
index 53ca9f12..70aaca91 100644
--- a/src/render/Renderer.hpp
+++ b/src/render/Renderer.hpp
@@ -73,6 +73,51 @@ struct SRenderWorkspaceUntilData {
     PHLWINDOW w;
 };
 
+struct SRenderData {
+    // can be private
+    Mat3x3 targetProjection;
+
+    // ----------------------
+
+    // used by public
+    Vector2D         fbSize = {-1, -1};
+    PHLMONITORREF    pMonitor;
+
+    Mat3x3           projection;
+    Mat3x3           savedProjection;
+    Mat3x3           monitorProjection;
+
+    SP<IFramebuffer> currentFB = nullptr; // current rendering to
+    SP<IFramebuffer> mainFB    = nullptr; // main to render to
+    SP<IFramebuffer> outFB     = nullptr; // out to render to (if offloaded, etc)
+
+    CRegion          damage;
+    CRegion          finalDamage; // damage used for funal off -> main
+
+    SRenderModifData renderModif;
+    float            mouseZoomFactor    = 1.f;
+    bool             mouseZoomUseMouse  = true; // true by default
+    bool             useNearestNeighbor = false;
+    bool             blockScreenShader  = false;
+
+    Vector2D         primarySurfaceUVTopLeft     = Vector2D(-1, -1);
+    Vector2D         primarySurfaceUVBottomRight = Vector2D(-1, -1);
+
+    // TODO remove and pass directly
+    CBox                   clipBox = {}; // scaled coordinates
+    CRegion                clipRegion;
+
+    uint32_t               discardMode    = DISCARD_OPAQUE;
+    float                  discardOpacity = 0.f;
+
+    PHLLSREF               currentLS;
+    PHLWINDOWREF           currentWindow;
+    WP<CWLSurfaceResource> surface;
+
+    bool                   transformDamage = true;
+    bool                   noSimplify      = false;
+};
+
 struct STFRange {
     float min = 0;
     float max = 80;
@@ -152,7 +197,9 @@ class CHyprRenderer {
     bool                            m_directScanoutBlocked = false;
 
     void                            setSurfaceScanoutMode(SP<CWLSurfaceResource> surface, PHLMONITOR monitor); // nullptr monitor resets
+
     void                            initiateManualCrash();
+    const SRenderData&              renderData();
 
     bool                            m_crashingInProgress = false;
     float                           m_crashingDistort    = 0.5f;
@@ -174,6 +221,7 @@ class CHyprRenderer {
     CRenderPass       m_renderPass = {};
 
     SP<IRenderbuffer> getOrCreateRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t fmt); // TODO? move to protected and fix CPointerManager::renderHWCursorBuffer
+    SRenderData       m_renderData;                                                          // TODO? move to protected and fix CRenderPass
     SP<ITexture>      m_screencopyDeniedTexture;                                             // TODO? make readonly
     uint              m_failedAssetsNo     = 0;                                              // TODO? make readonly
     bool              m_reloadScreenShader = true;                                           // at launch it can be set
diff --git a/src/render/ShaderLoader.cpp b/src/render/ShaderLoader.cpp
index 0d2d0ee4..1b8f98c8 100644
--- a/src/render/ShaderLoader.cpp
+++ b/src/render/ShaderLoader.cpp
@@ -14,6 +14,8 @@
 
 using namespace Render;
 
+using namespace Render;
+
 CShaderLoader::CShaderLoader(const std::vector<std::string> includes, const std::array<std::string, SH_FRAG_LAST>& frags, const std::string shaderPath) : m_shaderPath(shaderPath) {
     m_callbacks = glsl_include_callbacks_t{
         .include_local =
diff --git a/src/render/decorations/CHyprDropShadowDecoration.cpp b/src/render/decorations/CHyprDropShadowDecoration.cpp
index 1042cd1f..69caa2cd 100644
--- a/src/render/decorations/CHyprDropShadowDecoration.cpp
+++ b/src/render/decorations/CHyprDropShadowDecoration.cpp
@@ -152,12 +152,12 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
         return; // don't draw invisible shadows
 
     g_pHyprOpenGL->scissor(nullptr);
-    g_pHyprOpenGL->m_renderData.currentWindow = m_window;
+    g_pHyprRenderer->m_renderData.currentWindow = m_window;
 
     // we'll take the liberty of using this as it should not be used rn
-    auto alphaFB     = g_pHyprOpenGL->m_renderData.pMonitor->m_mirrorFB;
-    auto alphaSwapFB = g_pHyprOpenGL->m_renderData.pMonitor->m_mirrorSwapFB;
-    auto LASTFB      = g_pHyprOpenGL->m_renderData.currentFB;
+    auto alphaFB     = g_pHyprRenderer->m_renderData.pMonitor->m_mirrorFB;
+    auto alphaSwapFB = g_pHyprRenderer->m_renderData.pMonitor->m_mirrorSwapFB;
+    auto LASTFB      = g_pHyprRenderer->m_renderData.currentFB;
 
     fullBox.scale(pMonitor->m_scale).round();
 
@@ -182,11 +182,11 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
         if (windowBox.width < 1 || windowBox.height < 1)
             return; // prevent assert failed
 
-        CRegion saveDamage = g_pHyprOpenGL->m_renderData.damage;
+        CRegion saveDamage = g_pHyprRenderer->m_renderData.damage;
 
-        g_pHyprOpenGL->m_renderData.damage = fullBox;
-        g_pHyprOpenGL->m_renderData.damage.subtract(windowBox.copy().expand(-ROUNDING * pMonitor->m_scale)).intersect(saveDamage);
-        g_pHyprOpenGL->m_renderData.renderModif.applyToRegion(g_pHyprOpenGL->m_renderData.damage);
+        g_pHyprRenderer->m_renderData.damage = fullBox;
+        g_pHyprRenderer->m_renderData.damage.subtract(windowBox.copy().expand(-ROUNDING * pMonitor->m_scale)).intersect(saveDamage);
+        g_pHyprRenderer->m_renderData.renderModif.applyToRegion(g_pHyprRenderer->m_renderData.damage);
 
         alphaFB->bind();
 
@@ -217,14 +217,14 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
         g_pHyprOpenGL->setRenderModifEnabled(true);
         g_pHyprRenderer->popMonitorTransformEnabled();
 
-        g_pHyprOpenGL->m_renderData.damage = saveDamage;
+        g_pHyprRenderer->m_renderData.damage = saveDamage;
     } else
         drawShadowInternal(fullBox, ROUNDING * pMonitor->m_scale, ROUNDINGPOWER, *PSHADOWSIZE * pMonitor->m_scale, PWINDOW->m_realShadowColor->value(), a);
 
     if (m_extents != m_reportedExtents)
         g_pDecorationPositioner->repositionDeco(this);
 
-    g_pHyprOpenGL->m_renderData.currentWindow.reset();
+    g_pHyprRenderer->m_renderData.currentWindow.reset();
 }
 
 eDecorationLayer CHyprDropShadowDecoration::getDecorationLayer() {
diff --git a/src/render/gl/GLFramebuffer.cpp b/src/render/gl/GLFramebuffer.cpp
index 39bfba7f..f3952556 100644
--- a/src/render/gl/GLFramebuffer.cpp
+++ b/src/render/gl/GLFramebuffer.cpp
@@ -72,7 +72,7 @@ void CGLFramebuffer::bind() {
     glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fb);
 
     if (g_pHyprOpenGL)
-        g_pHyprOpenGL->setViewport(0, 0, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize.x, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize.y);
+        g_pHyprOpenGL->setViewport(0, 0, g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.x, g_pHyprRenderer->m_renderData.pMonitor->m_pixelSize.y);
     else
         glViewport(0, 0, m_size.x, m_size.y);
 }
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, {});
     }
 }
diff --git a/src/render/pass/RectPassElement.cpp b/src/render/pass/RectPassElement.cpp
index f6f88faa..042dfd2a 100644
--- a/src/render/pass/RectPassElement.cpp
+++ b/src/render/pass/RectPassElement.cpp
@@ -14,7 +14,7 @@ bool CRectPassElement::needsPrecomputeBlur() {
 }
 
 std::optional<CBox> CRectPassElement::boundingBox() {
-    return m_data.box.copy().scale(1.F / g_pHyprOpenGL->m_renderData.pMonitor->m_scale).round();
+    return m_data.box.copy().scale(1.F / g_pHyprRenderer->m_renderData.pMonitor->m_scale).round();
 }
 
 CRegion CRectPassElement::opaqueRegion() {
diff --git a/src/render/pass/SurfacePassElement.cpp b/src/render/pass/SurfacePassElement.cpp
index ce62998e..d3c4e3fc 100644
--- a/src/render/pass/SurfacePassElement.cpp
+++ b/src/render/pass/SurfacePassElement.cpp
@@ -149,8 +149,8 @@ CRegion CSurfacePassElement::visibleRegion(bool& cancel) {
     // deal with any rounding errors that might come from scaling
     visibleRegion.expand(1);
 
-    auto uvTL = g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft;
-    auto uvBR = g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight;
+    auto uvTL = g_pHyprRenderer->m_renderData.primarySurfaceUVTopLeft;
+    auto uvBR = g_pHyprRenderer->m_renderData.primarySurfaceUVBottomRight;
 
     if (uvTL == Vector2D(-1, -1))
         uvTL = Vector2D(0, 0);
diff --git a/src/render/pass/TexPassElement.cpp b/src/render/pass/TexPassElement.cpp
index ad132226..94b4cf76 100644
--- a/src/render/pass/TexPassElement.cpp
+++ b/src/render/pass/TexPassElement.cpp
@@ -18,7 +18,7 @@ bool CTexPassElement::needsPrecomputeBlur() {
 }
 
 std::optional<CBox> CTexPassElement::boundingBox() {
-    return m_data.box.copy().scale(1.F / g_pHyprOpenGL->m_renderData.pMonitor->m_scale).round();
+    return m_data.box.copy().scale(1.F / g_pHyprRenderer->m_renderData.pMonitor->m_scale).round();
 }
 
 CRegion CTexPassElement::opaqueRegion() {