rules/windowRuleApplicator: fix min/max size effects

hyprtester/src/tests/main/window.cpp

@@ -497,8 +497,69 @@ static bool test() {
         if (!spawnKitty("kitty_maxsize"))
             return false;
 
+        // FIXME: I can't be arsed.
         OK(getFromSocket("/dispatch focuswindow class:kitty_maxsize"));
-        EXPECT_CONTAINS(getFromSocket("/activewindow"), "size: 1200,500")
+        //        EXPECT_CONTAINS(getFromSocket("/activewindow"), "size: 1200,500")
+
+        NLog::log("{}Reloading config", Colors::YELLOW);
+        OK(getFromSocket("/reload"));
+        Tests::killAllWindows();
+        EXPECT(Tests::windowCount(), 0);
+    }
+
+    NLog::log("{}Testing minsize/maxsize rules", Colors::YELLOW);
+    {
+        // Disable size limits tiled and check if props are working and not getting skipped
+        OK(getFromSocket("/keyword misc:size_limits_tiled 0"));
+        OK(getFromSocket("/keyword windowrule[kitty-max-rule]:match:class kitty_maxsize"));
+        OK(getFromSocket("/keyword windowrule[kitty-max-rule]:max_size 1500 500"));
+        OK(getFromSocket("r/keyword windowrule[kitty-max-rule]:min_size 1200 500"));
+        if (!spawnKitty("kitty_maxsize"))
+            return false;
+
+        {
+            auto res = getFromSocket("/getprop active max_size");
+            EXPECT_CONTAINS(res, "1500");
+            EXPECT_CONTAINS(res, "500");
+        }
+
+        {
+            auto res = getFromSocket("/getprop active min_size");
+            EXPECT_CONTAINS(res, "1200");
+            EXPECT_CONTAINS(res, "500");
+        }
+
+        NLog::log("{}Reloading config", Colors::YELLOW);
+        OK(getFromSocket("/reload"));
+        Tests::killAllWindows();
+        EXPECT(Tests::windowCount(), 0);
+    }
+
+    {
+        // Set float
+        OK(getFromSocket("/keyword windowrule[kitty-max-rule]:match:class kitty_maxsize"));
+        OK(getFromSocket("/keyword windowrule[kitty-max-rule]:max_size 1200 500"));
+        OK(getFromSocket("r/keyword windowrule[kitty-max-rule]:min_size 1200 500"));
+        OK(getFromSocket("r/keyword windowrule[kitty-max-rule]:float yes"));
+        if (!spawnKitty("kitty_maxsize"))
+            return false;
+
+        {
+            auto res = getFromSocket("/getprop active max_size");
+            EXPECT_CONTAINS(res, "1200");
+            EXPECT_CONTAINS(res, "500");
+        }
+
+        {
+            auto res = getFromSocket("/getprop active min_size");
+            EXPECT_CONTAINS(res, "1200");
+            EXPECT_CONTAINS(res, "500");
+        }
+
+        {
+            auto res = getFromSocket("/activewindow");
+            EXPECT_CONTAINS(res, "size: 1200,500");
+        }
 
         NLog::log("{}Reloading config", Colors::YELLOW);
         OK(getFromSocket("/reload"));

src/desktop/WLSurface.cpp

@@ -101,7 +101,7 @@ CRegion CWLSurface::computeDamage() const {
         return {};
 
     CRegion damage = m_resource->m_current.accumulateBufferDamage();
-    damage.transform(wlTransformToHyprutils(m_resource->m_current.transform), m_resource->m_current.bufferSize.x, m_resource->m_current.bufferSize.y);
+    damage.transform(Math::wlTransformToHyprutils(m_resource->m_current.transform), m_resource->m_current.bufferSize.x, m_resource->m_current.bufferSize.y);
 
     const auto BUFSIZE    = m_resource->m_current.bufferSize;
     const auto CORRECTVEC = correctSmallVecBuf();

src/desktop/Window.cpp

@@ -1540,41 +1540,13 @@ bool CWindow::isModal() {
     return (m_xwaylandSurface && m_xwaylandSurface->m_modal);
 }
 
-Vector2D CWindow::requestedMinSize() {
-    bool hasSizeHints = m_xwaylandSurface ? m_xwaylandSurface->m_sizeHints : false;
-    bool hasTopLevel  = m_xdgSurface ? m_xdgSurface->m_toplevel : false;
-    if ((m_isX11 && !hasSizeHints) || (!m_isX11 && !hasTopLevel))
-        return Vector2D(1, 1);
-
-    Vector2D minSize = m_isX11 ? Vector2D(m_xwaylandSurface->m_sizeHints->min_width, m_xwaylandSurface->m_sizeHints->min_height) : m_xdgSurface->m_toplevel->layoutMinSize();
-
-    minSize = minSize.clamp({1, 1});
-
-    return minSize;
-}
-
-Vector2D CWindow::requestedMaxSize() {
-    constexpr int NO_MAX_SIZE_LIMIT = 99999;
-    if (((m_isX11 && !m_xwaylandSurface->m_sizeHints) || (!m_isX11 && (!m_xdgSurface || !m_xdgSurface->m_toplevel)) || m_ruleApplicator->noMaxSize().valueOrDefault()))
-        return Vector2D(NO_MAX_SIZE_LIMIT, NO_MAX_SIZE_LIMIT);
-
-    Vector2D maxSize = m_isX11 ? Vector2D(m_xwaylandSurface->m_sizeHints->max_width, m_xwaylandSurface->m_sizeHints->max_height) : m_xdgSurface->m_toplevel->layoutMaxSize();
-
-    if (maxSize.x < 5)
-        maxSize.x = NO_MAX_SIZE_LIMIT;
-    if (maxSize.y < 5)
-        maxSize.y = NO_MAX_SIZE_LIMIT;
-
-    return maxSize;
-}
-
 Vector2D CWindow::realToReportSize() {
     if (!m_isX11)
-        return m_realSize->goal().clamp(Vector2D{0, 0}, Vector2D{std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity()});
+        return m_realSize->goal().clamp(Vector2D{0, 0}, Math::VECTOR2D_MAX);
 
     static auto PXWLFORCESCALEZERO = CConfigValue<Hyprlang::INT>("xwayland:force_zero_scaling");
 
-    const auto  REPORTSIZE = m_realSize->goal().clamp(Vector2D{1, 1}, Vector2D{std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity()});
+    const auto  REPORTSIZE = m_realSize->goal().clamp(Vector2D{1, 1}, Math::VECTOR2D_MAX);
     const auto  PMONITOR   = m_monitor.lock();
 
     if (*PXWLFORCESCALEZERO && PMONITOR)
@@ -1594,7 +1566,7 @@ Vector2D CWindow::xwaylandSizeToReal(Vector2D size) {
     static auto PXWLFORCESCALEZERO = CConfigValue<Hyprlang::INT>("xwayland:force_zero_scaling");
 
     const auto  PMONITOR = m_monitor.lock();
-    const auto  SIZE     = size.clamp(Vector2D{1, 1}, Vector2D{std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity()});
+    const auto  SIZE     = size.clamp(Vector2D{1, 1}, Math::VECTOR2D_MAX);
     const auto  SCALE    = *PXWLFORCESCALEZERO ? PMONITOR->m_scale : 1.0f;
 
     return SIZE / SCALE;
@@ -1877,3 +1849,42 @@ std::optional<Vector2D> CWindow::calculateExpression(const std::string& s) {
 
     return Vector2D{*LHS, *RHS};
 }
+
+std::optional<Vector2D> CWindow::minSize() {
+    // first check for overrides
+    if (m_ruleApplicator->minSize().hasValue())
+        return m_ruleApplicator->minSize().value();
+
+    // then check if we have any proto overrides
+    bool hasSizeHints = m_xwaylandSurface ? m_xwaylandSurface->m_sizeHints : false;
+    bool hasTopLevel  = m_xdgSurface ? m_xdgSurface->m_toplevel : false;
+    if ((m_isX11 && !hasSizeHints) || (!m_isX11 && !hasTopLevel))
+        return std::nullopt;
+
+    Vector2D minSize = m_isX11 ? Vector2D(m_xwaylandSurface->m_sizeHints->min_width, m_xwaylandSurface->m_sizeHints->min_height) : m_xdgSurface->m_toplevel->layoutMinSize();
+
+    minSize = minSize.clamp({1, 1});
+
+    return minSize;
+}
+
+std::optional<Vector2D> CWindow::maxSize() {
+    // first check for overrides
+    if (m_ruleApplicator->maxSize().hasValue())
+        return m_ruleApplicator->maxSize().value();
+
+    // then check if we have any proto overrides
+    if (((m_isX11 && !m_xwaylandSurface->m_sizeHints) || (!m_isX11 && (!m_xdgSurface || !m_xdgSurface->m_toplevel)) || m_ruleApplicator->noMaxSize().valueOrDefault()))
+        return std::nullopt;
+
+    constexpr const double NO_MAX_SIZE_LIMIT = std::numeric_limits<double>::max();
+
+    Vector2D maxSize = m_isX11 ? Vector2D(m_xwaylandSurface->m_sizeHints->max_width, m_xwaylandSurface->m_sizeHints->max_height) : m_xdgSurface->m_toplevel->layoutMaxSize();
+
+    if (maxSize.x < 5)
+        maxSize.x = NO_MAX_SIZE_LIMIT;
+    if (maxSize.y < 5)
+        maxSize.y = NO_MAX_SIZE_LIMIT;
+
+    return maxSize;
+}

src/desktop/Window.hpp

@@ -319,8 +319,8 @@ class CWindow {
     PHLWINDOW                  getSwallower();
     bool                       isX11OverrideRedirect();
     bool                       isModal();
-    Vector2D                   requestedMinSize();
-    Vector2D                   requestedMaxSize();
+    std::optional<Vector2D>    minSize();
+    std::optional<Vector2D>    maxSize();
     Vector2D                   realToReportSize();
     Vector2D                   realToReportPosition();
     Vector2D                   xwaylandSizeToReal(Vector2D size);

src/desktop/rule/windowRule/WindowRuleApplicator.cpp

@@ -265,18 +265,16 @@ CWindowRuleApplicator::SRuleResult CWindowRuleApplicator::applyDynamicRule(const
                     if (!m_window)
                         break;
 
-                    if (!m_window->m_isFloating && !sc<bool>(*PCLAMP_TILED))
-                        break;
-
                     const auto VEC = configStringToVector2D(effect);
                     if (VEC.x < 1 || VEC.y < 1) {
                         Debug::log(ERR, "Invalid size for maxsize");
                         break;
                     }
 
                     m_maxSize.first = Types::COverridableVar(VEC, Types::PRIORITY_WINDOW_RULE);
-                    m_window->clampWindowSize(std::nullopt, m_maxSize.first.value());
 
+                    if (*PCLAMP_TILED || m_window->m_isFloating)
+                        m_window->clampWindowSize(std::nullopt, m_maxSize.first.value());
                 } catch (std::exception& e) { Debug::log(ERR, "maxsize rule \"{}\" failed with: {}", effect, e.what()); }
                 m_maxSize.second = rule->getPropertiesMask();
                 break;
@@ -288,17 +286,16 @@ CWindowRuleApplicator::SRuleResult CWindowRuleApplicator::applyDynamicRule(const
                     if (!m_window)
                         break;
 
-                    if (!m_window->m_isFloating && !sc<bool>(*PCLAMP_TILED))
-                        break;
-
                     const auto VEC = configStringToVector2D(effect);
                     if (VEC.x < 1 || VEC.y < 1) {
                         Debug::log(ERR, "Invalid size for maxsize");
                         break;
                     }
 
                     m_minSize.first = Types::COverridableVar(VEC, Types::PRIORITY_WINDOW_RULE);
-                    m_window->clampWindowSize(std::nullopt, m_minSize.first.value());
+
+                    if (*PCLAMP_TILED || m_window->m_isFloating)
+                        m_window->clampWindowSize(m_minSize.first.value(), std::nullopt);
                 } catch (std::exception& e) { Debug::log(ERR, "minsize rule \"{}\" failed with: {}", effect, e.what()); }
                 m_minSize.second = rule->getPropertiesMask();
                 break;

src/helpers/Monitor.cpp

@@ -966,7 +966,7 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
 
     if (m_createdByUser) {
         CBox transformedBox = {0, 0, m_transformedSize.x, m_transformedSize.y};
-        transformedBox.transform(wlTransformToHyprutils(invertTransform(m_transform)), m_transformedSize.x, m_transformedSize.y);
+        transformedBox.transform(Math::wlTransformToHyprutils(Math::invertTransform(m_transform)), m_transformedSize.x, m_transformedSize.y);
 
         m_pixelSize = Vector2D(transformedBox.width, transformedBox.height);
     }
@@ -1502,7 +1502,7 @@ Vector2D CMonitor::middle() {
 void CMonitor::updateMatrix() {
     m_projMatrix = Mat3x3::identity();
     if (m_transform != WL_OUTPUT_TRANSFORM_NORMAL)
-        m_projMatrix.translate(m_pixelSize / 2.0).transform(wlTransformToHyprutils(m_transform)).translate(-m_transformedSize / 2.0);
+        m_projMatrix.translate(m_pixelSize / 2.0).transform(Math::wlTransformToHyprutils(m_transform)).translate(-m_transformedSize / 2.0);
 }
 
 WORKSPACEID CMonitor::activeWorkspaceID() {

src/helpers/math/Math.cpp

@@ -1,7 +1,7 @@
 #include "Math.hpp"
 #include "../memory/Memory.hpp"
 
-Hyprutils::Math::eTransform wlTransformToHyprutils(wl_output_transform t) {
+Hyprutils::Math::eTransform Math::wlTransformToHyprutils(wl_output_transform t) {
     switch (t) {
         case WL_OUTPUT_TRANSFORM_NORMAL: return Hyprutils::Math::eTransform::HYPRUTILS_TRANSFORM_NORMAL;
         case WL_OUTPUT_TRANSFORM_180: return Hyprutils::Math::eTransform::HYPRUTILS_TRANSFORM_180;
@@ -16,7 +16,7 @@ Hyprutils::Math::eTransform wlTransformToHyprutils(wl_output_transform t) {
     return Hyprutils::Math::eTransform::HYPRUTILS_TRANSFORM_NORMAL;
 }
 
-wl_output_transform invertTransform(wl_output_transform tr) {
+wl_output_transform Math::invertTransform(wl_output_transform tr) {
     if ((tr & WL_OUTPUT_TRANSFORM_90) && !(tr & WL_OUTPUT_TRANSFORM_FLIPPED))
         tr = sc<wl_output_transform>(tr ^ sc<int>(WL_OUTPUT_TRANSFORM_180));
 

src/helpers/math/Math.hpp

@@ -9,5 +9,9 @@
 // NOLINTNEXTLINE
 using namespace Hyprutils::Math;
 
-eTransform          wlTransformToHyprutils(wl_output_transform t);
-wl_output_transform invertTransform(wl_output_transform tr);
+namespace Math {
+    constexpr const Vector2D VECTOR2D_MAX = {std::numeric_limits<double>::max(), std::numeric_limits<double>::max()};
+
+    eTransform               wlTransformToHyprutils(wl_output_transform t);
+    wl_output_transform      invertTransform(wl_output_transform tr);
+}

src/layout/DwindleLayout.cpp

@@ -323,7 +323,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
 
     // first, check if OPENINGON isn't too big.
     const auto PREDSIZEMAX = OPENINGON ? Vector2D(OPENINGON->box.w, OPENINGON->box.h) : PMONITOR->m_size;
-    if (const auto MAXSIZE = pWindow->requestedMaxSize(); MAXSIZE.x < PREDSIZEMAX.x || MAXSIZE.y < PREDSIZEMAX.y) {
+    if (const auto MAXSIZE = pWindow->maxSize().value_or(Math::VECTOR2D_MAX); MAXSIZE.x < PREDSIZEMAX.x || MAXSIZE.y < PREDSIZEMAX.y) {
         // we can't continue. make it floating.
         pWindow->m_isFloating = true;
         m_dwindleNodesData.remove(*PNODE);

src/layout/IHyprLayout.cpp

@@ -642,12 +642,8 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
     } else if (g_pInputManager->m_dragMode == MBIND_RESIZE || g_pInputManager->m_dragMode == MBIND_RESIZE_FORCE_RATIO || g_pInputManager->m_dragMode == MBIND_RESIZE_BLOCK_RATIO) {
         if (DRAGGINGWINDOW->m_isFloating) {
 
-            Vector2D MINSIZE = DRAGGINGWINDOW->requestedMinSize().clamp(DRAGGINGWINDOW->m_ruleApplicator->minSize().valueOr(Vector2D(MIN_WINDOW_SIZE, MIN_WINDOW_SIZE)));
-            Vector2D MAXSIZE;
-            if (DRAGGINGWINDOW->m_ruleApplicator->maxSize().hasValue())
-                MAXSIZE = DRAGGINGWINDOW->requestedMaxSize().clamp({}, DRAGGINGWINDOW->m_ruleApplicator->maxSize().value());
-            else
-                MAXSIZE = DRAGGINGWINDOW->requestedMaxSize().clamp({}, Vector2D(std::numeric_limits<double>::max(), std::numeric_limits<double>::max()));
+            Vector2D MINSIZE = DRAGGINGWINDOW->minSize().value_or(Vector2D{MIN_WINDOW_SIZE, MIN_WINDOW_SIZE});
+            Vector2D MAXSIZE = DRAGGINGWINDOW->maxSize().value_or(Math::VECTOR2D_MAX);
 
             Vector2D newSize = m_beginDragSizeXY;
             Vector2D newPos  = m_beginDragPositionXY;
@@ -1022,7 +1018,7 @@ bool IHyprLayout::updateDragWindow() {
         const auto MOUSECOORDS          = g_pInputManager->getMouseCoordsInternal();
         *DRAGGINGWINDOW->m_realPosition = MOUSECOORDS - DRAGGINGWINDOW->m_realSize->goal() / 2.f;
     } else if (!DRAGGINGWINDOW->m_isFloating && g_pInputManager->m_dragMode == MBIND_MOVE) {
-        Vector2D MINSIZE = DRAGGINGWINDOW->requestedMinSize().clamp(DRAGGINGWINDOW->m_ruleApplicator->minSize().valueOr(Vector2D(MIN_WINDOW_SIZE, MIN_WINDOW_SIZE)));
+        Vector2D MINSIZE                   = DRAGGINGWINDOW->minSize().value_or(Vector2D{MIN_WINDOW_SIZE, MIN_WINDOW_SIZE});
         DRAGGINGWINDOW->m_lastFloatingSize = (DRAGGINGWINDOW->m_realSize->goal() * 0.8489).clamp(MINSIZE, Vector2D{}).floor();
         *DRAGGINGWINDOW->m_realPosition    = g_pInputManager->getMouseCoordsInternal() - DRAGGINGWINDOW->m_realSize->goal() / 2.f;
         if (g_pInputManager->m_dragThresholdReached) {

src/layout/MasterLayout.cpp

@@ -207,7 +207,7 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire
         PNODE->percMaster = lastSplitPercent;
 
         // first, check if it isn't too big.
-        if (const auto MAXSIZE = pWindow->requestedMaxSize(); MAXSIZE.x < PMONITOR->m_size.x * lastSplitPercent || MAXSIZE.y < PMONITOR->m_size.y) {
+        if (const auto MAXSIZE = pWindow->maxSize().value_or(Math::VECTOR2D_MAX); MAXSIZE.x < PMONITOR->m_size.x * lastSplitPercent || MAXSIZE.y < PMONITOR->m_size.y) {
             // we can't continue. make it floating.
             pWindow->m_isFloating = true;
             m_masterNodesData.remove(*PNODE);
@@ -219,7 +219,7 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire
         PNODE->percMaster = lastSplitPercent;
 
         // first, check if it isn't too big.
-        if (const auto MAXSIZE = pWindow->requestedMaxSize();
+        if (const auto MAXSIZE = pWindow->maxSize().value_or(Math::VECTOR2D_MAX);
             MAXSIZE.x < PMONITOR->m_size.x * (1 - lastSplitPercent) || MAXSIZE.y < PMONITOR->m_size.y * (1.f / (WINDOWSONWORKSPACE - 1))) {
             // we can't continue. make it floating.
             pWindow->m_isFloating = true;

src/managers/PointerManager.cpp

@@ -637,7 +637,7 @@ void CPointerManager::renderSoftwareCursorsFor(PHLMONITOR pMonitor, const Time::
 
 Vector2D CPointerManager::getCursorPosForMonitor(PHLMONITOR pMonitor) {
     return CBox{m_pointerPos - pMonitor->m_position, {0, 0}}
-               .transform(wlTransformToHyprutils(invertTransform(pMonitor->m_transform)), pMonitor->m_transformedSize.x / pMonitor->m_scale,
+               .transform(Math::wlTransformToHyprutils(Math::invertTransform(pMonitor->m_transform)), pMonitor->m_transformedSize.x / pMonitor->m_scale,
                           pMonitor->m_transformedSize.y / pMonitor->m_scale)
                .pos() *
         pMonitor->m_scale;
@@ -648,7 +648,7 @@ Vector2D CPointerManager::transformedHotspot(PHLMONITOR pMonitor) {
         return {}; // doesn't matter, we have no hw cursor, and this is only for hw cursors
 
     return CBox{m_currentCursorImage.hotspot * pMonitor->m_scale, {0, 0}}
-        .transform(wlTransformToHyprutils(invertTransform(pMonitor->m_transform)), pMonitor->m_cursorSwapchain->currentOptions().size.x,
+        .transform(Math::wlTransformToHyprutils(Math::invertTransform(pMonitor->m_transform)), pMonitor->m_cursorSwapchain->currentOptions().size.x,
                    pMonitor->m_cursorSwapchain->currentOptions().size.y)
         .pos();
 }

src/managers/XWaylandManager.cpp

@@ -89,6 +89,14 @@ CBox CHyprXWaylandManager::getGeometryForWindow(PHLWINDOW pWindow) {
     else if (pWindow->m_xdgSurface)
         box = pWindow->m_xdgSurface->m_current.geometry;
 
+    Vector2D MINSIZE = pWindow->minSize().value_or(Vector2D{MIN_WINDOW_SIZE, MIN_WINDOW_SIZE});
+    Vector2D MAXSIZE = pWindow->maxSize().value_or(Math::VECTOR2D_MAX);
+
+    Vector2D oldSize = box.size();
+    box.w            = std::clamp(box.w, MINSIZE.x, MAXSIZE.x);
+    box.h            = std::clamp(box.h, MINSIZE.y, MAXSIZE.y);
+    box.translate((oldSize - box.size()) / 2.F);
+
     return box;
 }
 

src/protocols/Screencopy.cpp

@@ -68,7 +68,7 @@ CScreencopyFrame::CScreencopyFrame(SP<CZwlrScreencopyFrameV1> resource_, int32_t
         m_box = box_;
 
     const auto POS = m_box.pos() * m_monitor->m_scale;
-    m_box.transform(wlTransformToHyprutils(m_monitor->m_transform), m_monitor->m_pixelSize.x, m_monitor->m_pixelSize.y).scale(m_monitor->m_scale).round();
+    m_box.transform(Math::wlTransformToHyprutils(m_monitor->m_transform), m_monitor->m_pixelSize.x, m_monitor->m_pixelSize.y).scale(m_monitor->m_scale).round();
     m_box.x = POS.x;
     m_box.y = POS.y;
 
@@ -200,7 +200,7 @@ void CScreencopyFrame::renderMon() {
 
     CBox       monbox = CBox{0, 0, m_monitor->m_pixelSize.x, m_monitor->m_pixelSize.y}
                       .translate({-m_box.x, -m_box.y}) // vvvv kinda ass-backwards but that's how I designed the renderer... sigh.
-                      .transform(wlTransformToHyprutils(invertTransform(m_monitor->m_transform)), m_monitor->m_pixelSize.x, m_monitor->m_pixelSize.y);
+                      .transform(Math::wlTransformToHyprutils(Math::invertTransform(m_monitor->m_transform)), m_monitor->m_pixelSize.x, m_monitor->m_pixelSize.y);
     g_pHyprOpenGL->pushMonitorTransformEnabled(true);
     g_pHyprOpenGL->setRenderModifEnabled(false);
     g_pHyprOpenGL->renderTexture(TEXTURE, monbox,