Added dynamic monitor rules

src/render/OpenGL.cpp

@@ -685,4 +685,15 @@ void CHyprOpenGLImpl::clearWithTex() {
     wlr_box box = {0, 0, m_RenderData.pMonitor->vecSize.x, m_RenderData.pMonitor->vecSize.y};
 
     renderTexture(m_mMonitorBGTextures[m_RenderData.pMonitor], &box, 255, 0);
-}
+}
+
+void CHyprOpenGLImpl::destroyMonitorResources(SMonitor* pMonitor) {
+    g_pHyprOpenGL->m_mMonitorRenderResources[pMonitor].mirrorFB.release();
+    g_pHyprOpenGL->m_mMonitorRenderResources[pMonitor].primaryFB.release();
+    g_pHyprOpenGL->m_mMonitorRenderResources[pMonitor].stencilTex.destroyTexture();
+    g_pHyprOpenGL->m_mMonitorBGTextures[pMonitor].destroyTexture();
+    g_pHyprOpenGL->m_mMonitorRenderResources.erase(pMonitor);
+    g_pHyprOpenGL->m_mMonitorBGTextures.erase(pMonitor);
+
+    Debug::log(LOG, "Monitor %s -> destroyed all render data", pMonitor->szName.c_str());
+}

src/render/OpenGL.hpp

@@ -60,6 +60,8 @@ public:
     void    scissor(const wlr_box*);
     void    scissor(const pixman_box32*);
 
+    void    destroyMonitorResources(SMonitor*);
+
     SCurrentRenderData m_RenderData;
 
     GLint  m_iCurrentOutputFb = 0;

src/render/Renderer.cpp

@@ -490,4 +490,77 @@ DAMAGETRACKINGMODES CHyprRenderer::damageTrackingModeFromStr(const std::string&
         return DAMAGE_TRACKING_NONE;
 
     return DAMAGE_TRACKING_INVALID;
+}
+
+void CHyprRenderer::applyMonitorRule(SMonitor* pMonitor, SMonitorRule* pMonitorRule, bool force) {
+
+    // Check if the rule isn't already applied
+    if (!force && DELTALESSTHAN(pMonitor->vecSize.x, pMonitorRule->resolution.x, 1) && DELTALESSTHAN(pMonitor->vecSize.y, pMonitorRule->resolution.y, 1) && DELTALESSTHAN(pMonitor->refreshRate, pMonitorRule->refreshRate, 1) && pMonitor->scale == pMonitorRule->scale) {
+        Debug::log(LOG, "Not applying a new rule to %s because it's already applied!", pMonitor->szName.c_str());
+        return;
+    }
+
+    wlr_output_set_scale(pMonitor->output, pMonitorRule->scale);
+    pMonitor->scale = pMonitorRule->scale;
+
+    // loop over modes and choose an appropriate one.
+    if (!wl_list_empty(&pMonitor->output->modes)) {
+        wlr_output_mode* mode;
+        bool found = false;
+
+        wl_list_for_each(mode, &pMonitor->output->modes, link) {
+            // if delta of refresh rate, w and h chosen and mode is < 1 we accept it
+            if (DELTALESSTHAN(mode->width, pMonitorRule->resolution.x, 1) && DELTALESSTHAN(mode->height, pMonitorRule->resolution.y, 1) && DELTALESSTHAN(mode->refresh / 1000.f, pMonitorRule->refreshRate, 1)) {
+                wlr_output_set_mode(pMonitor->output, mode);
+
+                if (!wlr_output_test(pMonitor->output)) {
+                    Debug::log(LOG, "Monitor %s: REJECTED available mode: %ix%i@%2f!",
+                               pMonitor->output->name, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate,
+                               mode->width, mode->height, mode->refresh / 1000.f);
+                    continue;
+                }
+
+                Debug::log(LOG, "Monitor %s: requested %ix%i@%2f, found available mode: %ix%i@%imHz, applying.",
+                           pMonitor->output->name, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate,
+                           mode->width, mode->height, mode->refresh);
+
+                found = true;
+
+                pMonitor->refreshRate = mode->refresh / 1000.f;
+                pMonitor->vecSize = Vector2D(mode->width, mode->height);
+
+                break;
+            }
+        }
+
+        if (!found) {
+            const auto PREFERREDMODE = wlr_output_preferred_mode(pMonitor->output);
+
+            if (!PREFERREDMODE) {
+                Debug::log(ERR, "Monitor %s has NO PREFERRED MODE, and an INVALID one was requested: %ix%i@%2f",
+                           (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate);
+                return;
+            }
+
+            // Preferred is valid
+            wlr_output_set_mode(pMonitor->output, PREFERREDMODE);
+
+            Debug::log(ERR, "Monitor %s got an invalid requested mode: %ix%i@%2f, using the preferred one instead: %ix%i@%2f",
+                       pMonitor->output->name, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate,
+                       PREFERREDMODE->width, PREFERREDMODE->height, PREFERREDMODE->refresh / 1000.f);
+
+            pMonitor->refreshRate = PREFERREDMODE->refresh / 1000.f;
+            pMonitor->vecSize = Vector2D(PREFERREDMODE->width, PREFERREDMODE->height);
+        }
+    } else {
+        wlr_output_set_custom_mode(pMonitor->output, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (int)pMonitorRule->refreshRate * 1000);
+    }
+
+    // update renderer
+    g_pHyprOpenGL->destroyMonitorResources(pMonitor);
+
+    if (!wlr_output_commit(pMonitor->output)) {
+        Debug::log(ERR, "Couldn't commit output named %s", pMonitor->output->name);
+        return;
+    }
 }

src/render/Renderer.hpp

@@ -7,6 +7,8 @@
 #include "../Window.hpp"
 #include "OpenGL.hpp"
 
+struct SMonitorRule;
+
 // TODO: add fuller damage tracking for updating only parts of a window
 enum DAMAGETRACKINGMODES {
     DAMAGE_TRACKING_INVALID = -1,
@@ -25,6 +27,7 @@ public:
     void                damageWindow(CWindow*);
     void                damageBox(wlr_box*);
     void                damageMonitor(SMonitor*);
+    void                applyMonitorRule(SMonitor*, SMonitorRule*, bool force = false);
 
     DAMAGETRACKINGMODES damageTrackingModeFromStr(const std::string&);