[gha] bump flake inputs

inverse_transform the box in renderRectWithDamage.

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1664989420,
-        "narHash": "sha256-Q8IxomUjjmewsoJgO3htkXLfCckQ7HkDJ/ZhdYVf/fA=",
+        "lastModified": 1665259268,
+        "narHash": "sha256-ONFhHBLv5nZKhwV/F2GOH16197PbvpyWhoO0AOyktkU=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "37bd39839acf99c5b738319f42478296f827f274",
+        "rev": "c5924154f000e6306030300592f4282949b2db6c",
         "type": "github"
       },
       "original": {
@@ -26,11 +26,11 @@
       "flake": false,
       "locked": {
         "host": "gitlab.freedesktop.org",
-        "lastModified": 1663507239,
-        "narHash": "sha256-LISZtkPVe8lQ2N8YwVe+KxCkXWLP9mdw6Q2kG93wE8A=",
+        "lastModified": 1665331677,
+        "narHash": "sha256-3Dh1i11mHK80jx5figC1oh1V0rCjieh0Mj+MajXdbPw=",
         "owner": "wlroots",
         "repo": "wlroots",
-        "rev": "2ad25b1460400e66ea26bd6489b04072be7d9dbb",
+        "rev": "ab8341975e62b1f668d8c9779ec8e72d04718a99",
         "type": "gitlab"
       },
       "original": {

src/events/Layers.cpp

@@ -152,6 +152,8 @@ void Events::listener_mapLayerSurface(void* owner, void* data) {
     layersurface->alpha = 255.f;
     layersurface->readyToDelete = false;
     layersurface->fadingOut = false;
+
+    g_pEventManager->postEvent(SHyprIPCEvent{"openlayer", std::string(layersurface->layerSurface->_namespace ? layersurface->layerSurface->_namespace : "")});
 }
 
 void Events::listener_unmapLayerSurface(void* owner, void* data) {
@@ -159,6 +161,8 @@ void Events::listener_unmapLayerSurface(void* owner, void* data) {
 
     Debug::log(LOG, "LayerSurface %x unmapped", layersurface->layerSurface);
 
+    g_pEventManager->postEvent(SHyprIPCEvent{"closelayer", std::string(layersurface->layerSurface->_namespace ? layersurface->layerSurface->_namespace : "")});
+
     if (!g_pCompositor->getMonitorFromID(layersurface->monitorID) || g_pCompositor->m_bUnsafeState) {
         Debug::log(WARN, "Layersurface unmapping on invalid monitor (removed?) ignoring.");
 

src/events/Popups.cpp

@@ -32,8 +32,8 @@ void addPopupGlobalCoords(void* pPopup, int* x, int* y) {
             py -= curPopup->popup->base->current.geometry.y;
         }
 
-        if (curPopup->pSurfaceTree && curPopup->pSurfaceTree->pSurface && !curPopup->parentPopup && !curPopup->parentWindow) {
-            const auto EXTENTSSURFACE = pixman_region32_extents(&curPopup->pSurfaceTree->pSurface->input_region);
+        if (curPopup->popup && !curPopup->parentPopup && !curPopup->parentWindow) {
+            const auto EXTENTSSURFACE = pixman_region32_extents(&curPopup->popup->base->surface->input_region);
             px -= EXTENTSSURFACE->x1;
             py -= EXTENTSSURFACE->y1;
         }

src/events/Windows.cpp

@@ -397,67 +397,59 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
     // verify swallowing
     if (*PSWALLOW) {
-        // check parent
-        int ppid = getPPIDof(PWINDOW->getPID());
+        // don't swallow ourselves
+        std::regex rgx(*PSWALLOWREGEX);
+        if (!std::regex_match(g_pXWaylandManager->getAppIDClass(PWINDOW), rgx)) {
+            // check parent
+            int ppid = getPPIDof(PWINDOW->getPID());
 
-        const auto PPPID = getPPIDof(ppid);
+            int curppid = 0;
 
-        // why? no clue. Blame terminals.
-        if (PPPID > 2) {
-            ppid = PPPID;
-        }
+            for (int i = 0; i < 5; ++i) {
+                curppid = getPPIDof(ppid);
 
-        if (ppid) {
-            // get window by pid
-            std::vector<CWindow*> found;
-            CWindow* finalFound = nullptr;
-            for (auto& w : g_pCompositor->m_vWindows) {
-                if (!w->m_bIsMapped || w->m_bHidden)
-                    continue;
-
-                if (w->getPID() == ppid) {
-                    found.push_back(w.get());
+                if (curppid < 10) {
+                    break;
                 }
+
+                ppid = curppid;
             }
 
-            if (found.size() > 1) {
-                for (auto& w : found) {
-                    // try get the focus
-                    if (w == PFOCUSEDWINDOWPREV) {
-                        finalFound = w;
-                        break;
+            if (ppid) {
+                // get window by pid
+                std::vector<CWindow*> found;
+                CWindow* finalFound = nullptr;
+                for (auto& w : g_pCompositor->m_vWindows) {
+                    if (!w->m_bIsMapped || w->m_bHidden)
+                        continue;
+
+                    if (w->getPID() == ppid) {
+                        found.push_back(w.get());
                     }
                 }
 
-                if (!finalFound) {
-                    // just get the closest (ws)
+                if (found.size() > 1) {
                     for (auto& w : found) {
-                        if (w->m_iWorkspaceID == g_pCompositor->m_pLastMonitor->activeWorkspace) {
+                        // try get the focus, otherwise we'll ignore to avoid swallowing incorrect windows
+                        if (w == PFOCUSEDWINDOWPREV) {
                             finalFound = w;
                             break;
                         }
                     }
-                }
-
-                if (!finalFound) {
-                    // what, just use 0
+                } else if (found.size() == 1) {
                     finalFound = found[0];
                 }
 
-            } else if (found.size() == 1) {
-                finalFound = found[0];
-            }
+                if (finalFound) {
+                    // check if it's the window we want
+                    if (std::regex_match(g_pXWaylandManager->getAppIDClass(finalFound), rgx)) {
+                        // swallow
+                        PWINDOW->m_pSwallowed = finalFound;
 
-            if (finalFound) {
-                // check if it's the window we want
-                std::regex rgx(*PSWALLOWREGEX);
-                if (std::regex_match(g_pXWaylandManager->getAppIDClass(finalFound), rgx)) {
-                    // swallow
-                    PWINDOW->m_pSwallowed = finalFound;
+                        g_pLayoutManager->getCurrentLayout()->onWindowRemoved(finalFound);
 
-                    g_pLayoutManager->getCurrentLayout()->onWindowRemoved(finalFound);
-
-                    finalFound->m_bHidden = true;
+                        finalFound->m_bHidden = true;
+                    }
                 }
             }
         }

src/helpers/SubsurfaceTree.cpp

@@ -178,19 +178,23 @@ void Events::listener_unmapSubsurface(void* owner, void* data) {
     if (subsurface->pChild) {
         const auto PNODE = subsurface->pChild;
 
-        int lx = 0, ly = 0;
-        addSurfaceGlobalOffset(PNODE, &lx, &ly);
+        const auto IT = std::find_if(SubsurfaceTree::surfaceTreeNodes.begin(), SubsurfaceTree::surfaceTreeNodes.end(), [&](const SSurfaceTreeNode& other) { return &other == PNODE; });
 
-        wlr_box extents = {lx, ly, 0, 0};
-        if (PNODE->pSurface) {
-            extents.width = PNODE->pSurface->current.width;
-            extents.height = PNODE->pSurface->current.height;
+        if (IT != SubsurfaceTree::surfaceTreeNodes.end()) {
+            int lx = 0, ly = 0;
+            addSurfaceGlobalOffset(PNODE, &lx, &ly);
 
-            g_pHyprRenderer->damageBox(&extents);
+            wlr_box extents = {lx, ly, 0, 0};
+            if (PNODE->pSurface) {
+                extents.width = PNODE->pSurface->current.width;
+                extents.height = PNODE->pSurface->current.height;
+
+                g_pHyprRenderer->damageBox(&extents);
+            }
+
+            // SubsurfaceTree::destroySurfaceTree(subsurface->pChild);
+            // subsurface->pChild = nullptr;
         }
-
-        //SubsurfaceTree::destroySurfaceTree(subsurface->pChild);
-        //subsurface->pChild = nullptr;
     }
 }
 

src/managers/input/Swipe.cpp

@@ -42,6 +42,7 @@ void CInputManager::onSwipeEnd(wlr_pointer_swipe_end_event* e) {
     static auto *const PSWIPEPERC = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_cancel_ratio")->floatValue;
     static auto *const PSWIPEDIST = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_distance")->intValue;
     static auto *const PSWIPEFORC = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_min_speed_to_force")->intValue;
+    const bool VERTANIMS = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.getConfig()->pValues->internalStyle == "slidevert";
 
     // commit
     std::string wsname = "";
@@ -64,10 +65,16 @@ void CInputManager::onSwipeEnd(wlr_pointer_swipe_end_event* e) {
         } else {
             if (m_sActiveSwipe.delta < 0) {
                 // to left
-                PWORKSPACEL->m_vRenderOffset = Vector2D({-m_sActiveSwipe.pMonitor->vecSize.x, 0});
+                if (VERTANIMS)
+                    PWORKSPACEL->m_vRenderOffset = Vector2D({0, -m_sActiveSwipe.pMonitor->vecSize.y});
+                else
+                    PWORKSPACEL->m_vRenderOffset = Vector2D({-m_sActiveSwipe.pMonitor->vecSize.x, 0});
             } else {
                 // to right
-                PWORKSPACER->m_vRenderOffset = Vector2D({m_sActiveSwipe.pMonitor->vecSize.x, 0});
+                if (VERTANIMS)
+                    PWORKSPACER->m_vRenderOffset = Vector2D({0, m_sActiveSwipe.pMonitor->vecSize.y});
+                else
+                    PWORKSPACER->m_vRenderOffset = Vector2D({m_sActiveSwipe.pMonitor->vecSize.x, 0});
             }
 
             m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D();
@@ -84,7 +91,10 @@ void CInputManager::onSwipeEnd(wlr_pointer_swipe_end_event* e) {
         PWORKSPACEL->m_fAlpha.setValueAndWarp(255.f);
 
         m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValue(RENDEROFFSETMIDDLE);
-        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(m_sActiveSwipe.pMonitor->vecSize.x, 0);
+        if (VERTANIMS)
+            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(0, m_sActiveSwipe.pMonitor->vecSize.y);
+        else
+            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(m_sActiveSwipe.pMonitor->vecSize.x, 0);
         m_sActiveSwipe.pWorkspaceBegin->m_fAlpha.setValueAndWarp(255.f);
 
         g_pInputManager->unconstrainMouse();
@@ -102,7 +112,10 @@ void CInputManager::onSwipeEnd(wlr_pointer_swipe_end_event* e) {
         PWORKSPACER->m_fAlpha.setValueAndWarp(255.f);
 
         m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValue(RENDEROFFSETMIDDLE);
-        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(-m_sActiveSwipe.pMonitor->vecSize.x, 0);
+        if (VERTANIMS)
+            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(0, -m_sActiveSwipe.pMonitor->vecSize.y);
+        else
+            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(-m_sActiveSwipe.pMonitor->vecSize.x, 0);
         m_sActiveSwipe.pWorkspaceBegin->m_fAlpha.setValueAndWarp(255.f);
 
         g_pInputManager->unconstrainMouse();
@@ -135,7 +148,9 @@ void CInputManager::onSwipeUpdate(wlr_pointer_swipe_update_event* e) {
     static auto *const PSWIPEDIST = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_distance")->intValue;
     static auto *const PSWIPEINVR = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_invert")->intValue;
 
-    m_sActiveSwipe.delta += *PSWIPEINVR ? -e->dx : e->dx;
+    const bool VERTANIMS = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.getConfig()->pValues->internalStyle == "slidevert";
+
+    m_sActiveSwipe.delta += VERTANIMS ? (*PSWIPEINVR ? -e->dy : e->dy) : (*PSWIPEINVR ? -e->dx : e->dx);
 
     m_sActiveSwipe.avgSpeed = (m_sActiveSwipe.avgSpeed * m_sActiveSwipe.speedPoints + abs(e->dx)) / (m_sActiveSwipe.speedPoints + 1);
     m_sActiveSwipe.speedPoints++;
@@ -171,8 +186,13 @@ void CInputManager::onSwipeUpdate(wlr_pointer_swipe_update_event* e) {
             PWORKSPACER->m_fAlpha.setValueAndWarp(0.f);
         }
 
-        PWORKSPACE->m_vRenderOffset.setValueAndWarp(Vector2D(((- m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.x - m_sActiveSwipe.pMonitor->vecSize.x, 0));
-        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(((- m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.x, 0));
+        if (VERTANIMS) {
+            PWORKSPACE->m_vRenderOffset.setValueAndWarp(Vector2D(0, ((-m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.y - m_sActiveSwipe.pMonitor->vecSize.y));
+            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(0, ((-m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.y));
+        } else {
+            PWORKSPACE->m_vRenderOffset.setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.x - m_sActiveSwipe.pMonitor->vecSize.x, 0));
+            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.x, 0));
+        }
 
         g_pCompositor->updateWorkspaceWindowDecos(workspaceIDLeft);
     } else {
@@ -193,8 +213,13 @@ void CInputManager::onSwipeUpdate(wlr_pointer_swipe_update_event* e) {
             PWORKSPACEL->m_fAlpha.setValueAndWarp(0.f);
         }
 
-        PWORKSPACE->m_vRenderOffset.setValueAndWarp(Vector2D(((- m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.x + m_sActiveSwipe.pMonitor->vecSize.x, 0));
-        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(((- m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.x, 0));
+        if (VERTANIMS) {
+            PWORKSPACE->m_vRenderOffset.setValueAndWarp(Vector2D(0, ((-m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.y + m_sActiveSwipe.pMonitor->vecSize.y));
+            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(0, ((-m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.y));
+        } else {
+            PWORKSPACE->m_vRenderOffset.setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.x + m_sActiveSwipe.pMonitor->vecSize.x, 0));
+            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.x, 0));
+        }
 
         g_pCompositor->updateWorkspaceWindowDecos(workspaceIDRight);
     }

src/render/OpenGL.cpp

@@ -310,7 +310,8 @@ void CHyprOpenGLImpl::scissor(const int x, const int y, const int w, const int h
 }
 
 void CHyprOpenGLImpl::renderRect(wlr_box* box, const CColor& col, int round) {
-    renderRectWithDamage(box, col, m_RenderData.pDamage, round);
+    if(pixman_region32_not_empty(m_RenderData.pDamage))
+	renderRectWithDamage(box, col, m_RenderData.pDamage, round);
 }
 
 void CHyprOpenGLImpl::renderRectWithDamage(wlr_box* box, const CColor& col, pixman_region32_t* damage, int round) {
@@ -334,8 +335,12 @@ void CHyprOpenGLImpl::renderRectWithDamage(wlr_box* box, const CColor& col, pixm
     glUniformMatrix3fv(m_RenderData.pCurrentMonData->m_shQUAD.proj, 1, GL_FALSE, glMatrix);
     glUniform4f(m_RenderData.pCurrentMonData->m_shQUAD.color, col.r / 255.f, col.g / 255.f, col.b / 255.f, col.a / 255.f);
 
-    const auto TOPLEFT = Vector2D(box->x, box->y);
-    const auto FULLSIZE = Vector2D(box->width, box->height);
+    wlr_box transformedBox;
+    wlr_box_transform(&transformedBox, box, wlr_output_transform_invert(m_RenderData.pMonitor->transform),
+		      m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y);
+
+    const auto TOPLEFT = Vector2D(transformedBox.x, transformedBox.y);
+    const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height);
 
     static auto *const PMULTISAMPLEEDGES = &g_pConfigManager->getConfigValuePtr("decoration:multisample_edges")->intValue;
 
@@ -351,12 +356,26 @@ void CHyprOpenGLImpl::renderRectWithDamage(wlr_box* box, const CColor& col, pixm
     glEnableVertexAttribArray(m_RenderData.pCurrentMonData->m_shQUAD.posAttrib);
     glEnableVertexAttribArray(m_RenderData.pCurrentMonData->m_shQUAD.texAttrib);
 
-    if (pixman_region32_not_empty(damage)) {
-        PIXMAN_DAMAGE_FOREACH(damage) {
-            const auto RECT = RECTSARR[i];
-            scissor(&RECT);
-            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+    if (m_RenderData.clipBox.width != 0 && m_RenderData.clipBox.height != 0) {
+        pixman_region32_t damageClip;
+        pixman_region32_init(&damageClip);
+        pixman_region32_intersect_rect(&damageClip, damage, m_RenderData.clipBox.x, m_RenderData.clipBox.y, m_RenderData.clipBox.width, m_RenderData.clipBox.height);
+
+        if (pixman_region32_not_empty(&damageClip)) {
+            PIXMAN_DAMAGE_FOREACH(&damageClip) {
+                const auto RECT = RECTSARR[i];
+                scissor(&RECT);
+                glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+            }
         }
+
+	pixman_region32_fini(&damageClip);
+    } else {
+	PIXMAN_DAMAGE_FOREACH(damage) {
+	    const auto RECT = RECTSARR[i];
+	    scissor(&RECT);
+	    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+	}
     }
 
     glDisableVertexAttribArray(m_RenderData.pCurrentMonData->m_shQUAD.posAttrib);
@@ -383,6 +402,9 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_b
     RASSERT(m_RenderData.pMonitor, "Tried to render texture without begin()!");
     RASSERT((tex.m_iTexID > 0), "Attempted to draw NULL texture!");
 
+    if (!pixman_region32_not_empty(m_RenderData.pDamage))
+	return;
+
     static auto *const PDIMINACTIVE = &g_pConfigManager->getConfigValuePtr("decoration:dim_inactive")->intValue;
 
     // get transform
@@ -427,17 +449,17 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_b
     glUniform1f(shader->alpha, alpha / 255.f);
     glUniform1i(shader->discardOpaque, (int)discardOpaque);
 
-    // round is in px
-    // so we need to do some maf
+    wlr_box transformedBox;
+    wlr_box_transform(&transformedBox, pBox, wlr_output_transform_invert(m_RenderData.pMonitor->transform),
+		      m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y);
 
-    const auto TOPLEFT = Vector2D(round, round);
-    const auto BOTTOMRIGHT = Vector2D(pBox->width - round, pBox->height - round);
-    const auto FULLSIZE = Vector2D(pBox->width, pBox->height);
+    const auto TOPLEFT = Vector2D(transformedBox.x, transformedBox.y);
+    const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height);
     static auto *const PMULTISAMPLEEDGES = &g_pConfigManager->getConfigValuePtr("decoration:multisample_edges")->intValue;
 
     // Rounded corners
-    glUniform2f(shader->topLeft, pBox->x, pBox->y);
-    glUniform2f(shader->fullSize, pBox->width, pBox->height);
+    glUniform2f(shader->topLeft, TOPLEFT.x, TOPLEFT.y);
+    glUniform2f(shader->fullSize, FULLSIZE.x ,FULLSIZE.y);
     glUniform1f(shader->radius, round);
     glUniform1i(shader->primitiveMultisample, (int)(*PMULTISAMPLEEDGES == 1 && round != 0 && !noAA));
 
@@ -467,12 +489,26 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_b
     glEnableVertexAttribArray(shader->posAttrib);
     glEnableVertexAttribArray(shader->texAttrib);
 
-    if (pixman_region32_not_empty(m_RenderData.pDamage)) {
-        PIXMAN_DAMAGE_FOREACH(m_RenderData.pDamage) {
-            const auto RECT = RECTSARR[i];
-            scissor(&RECT);
-            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+    if (m_RenderData.clipBox.width != 0 && m_RenderData.clipBox.height != 0) {
+        pixman_region32_t damageClip;
+        pixman_region32_init(&damageClip);
+        pixman_region32_intersect_rect(&damageClip, damage, m_RenderData.clipBox.x, m_RenderData.clipBox.y, m_RenderData.clipBox.width, m_RenderData.clipBox.height);
+
+        if (pixman_region32_not_empty(&damageClip)) {
+            PIXMAN_DAMAGE_FOREACH(&damageClip) {
+                const auto RECT = RECTSARR[i];
+                scissor(&RECT);
+                glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+            }
         }
+
+	pixman_region32_fini(&damageClip);
+    } else {
+	PIXMAN_DAMAGE_FOREACH(damage) {
+	    const auto RECT = RECTSARR[i];
+	    scissor(&RECT);
+	    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+	}
     }
 
     glDisableVertexAttribArray(shader->posAttrib);
@@ -642,6 +678,8 @@ void CHyprOpenGLImpl::preBlurForCurrentMonitor() {
     renderTextureInternalWithDamage(POUTFB->m_cTex, &wholeMonitor, 255, &fakeDamage, 0, false, true, false);
     m_bEndFrame = false;
 
+    pixman_region32_fini(&fakeDamage);
+
     m_RenderData.pCurrentMonData->primaryFB.bind();
 
     m_RenderData.pCurrentMonData->blurFBDirty = false;
@@ -675,16 +713,19 @@ void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox,
     static auto *const PNOBLUROVERSIZED = &g_pConfigManager->getConfigValuePtr("decoration:no_blur_on_oversized")->intValue;
     static auto *const PBLURNEWOPTIMIZE = &g_pConfigManager->getConfigValuePtr("decoration:blur_new_optimizations")->intValue;
 
-    if (*PBLURENABLED == 0 || (*PNOBLUROVERSIZED && m_RenderData.primarySurfaceUVTopLeft != Vector2D(-1, -1)) || (m_pCurrentWindow && m_pCurrentWindow->m_sAdditionalConfigData.forceNoBlur)) {
-        renderTexture(tex, pBox, a, round, false, true);
-        return;
-    }
-
     // make a damage region for this window
     pixman_region32_t damage;
     pixman_region32_init(&damage);
     pixman_region32_intersect_rect(&damage, m_RenderData.pDamage, pBox->x, pBox->y, pBox->width, pBox->height);  // clip it to the box
 
+    if(!pixman_region32_not_empty(&damage))
+	return;
+
+    if (*PBLURENABLED == 0 || (*PNOBLUROVERSIZED && m_RenderData.primarySurfaceUVTopLeft != Vector2D(-1, -1)) || (m_pCurrentWindow && m_pCurrentWindow->m_sAdditionalConfigData.forceNoBlur)) {
+        renderTexture(tex, pBox, a, round, false, true);
+        return;
+    }
+
     // amazing hack: the surface has an opaque region!
     pixman_region32_t inverseOpaque;
     pixman_region32_init(&inverseOpaque);
@@ -735,21 +776,19 @@ void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox,
 
     // stencil done. Render everything.
     wlr_box MONITORBOX = {0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y};
-    if (pixman_region32_not_empty(&damage)) {
-        // render our great blurred FB
-        static auto *const PBLURIGNOREOPACITY = &g_pConfigManager->getConfigValuePtr("decoration:blur_ignore_opacity")->intValue;
-        m_bEndFrame = true; // fix transformed
-        renderTextureInternalWithDamage(POUTFB->m_cTex, &MONITORBOX, *PBLURIGNOREOPACITY ? 255.f : a, &damage, 0, false, false, false);
-        m_bEndFrame = false;
+    // render our great blurred FB
+    static auto *const PBLURIGNOREOPACITY = &g_pConfigManager->getConfigValuePtr("decoration:blur_ignore_opacity")->intValue;
+    m_bEndFrame = true; // fix transformed
+    renderTextureInternalWithDamage(POUTFB->m_cTex, &MONITORBOX, *PBLURIGNOREOPACITY ? 255.f : a, &damage, 0, false, false, false);
+    m_bEndFrame = false;
 
-        // render the window, but clear stencil
-        glClearStencil(0);
-        glClear(GL_STENCIL_BUFFER_BIT);
+    // render the window, but clear stencil
+    glClearStencil(0);
+    glClear(GL_STENCIL_BUFFER_BIT);
 
-        // draw window
-        glDisable(GL_STENCIL_TEST);
-        renderTextureInternalWithDamage(tex, pBox, a, &damage, round, false, false, true, true);
-    }
+    // draw window
+    glDisable(GL_STENCIL_TEST);
+    renderTextureInternalWithDamage(tex, pBox, a, &damage, round, false, false, true, true);
 
     glStencilMask(-1);
     glStencilFunc(GL_ALWAYS, 1, 0xFF);
@@ -768,6 +807,9 @@ void CHyprOpenGLImpl::renderBorder(wlr_box* box, const CColor& col, int round) {
     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()!");
 
+    if (!pixman_region32_not_empty(m_RenderData.pDamage))
+	return;
+
     static auto *const PBORDERSIZE = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
     static auto *const PMULTISAMPLE = &g_pConfigManager->getConfigValuePtr("decoration:multisample_edges")->intValue;
 
@@ -832,12 +874,26 @@ void CHyprOpenGLImpl::renderBorder(wlr_box* box, const CColor& col, int round) {
     glEnableVertexAttribArray(m_RenderData.pCurrentMonData->m_shBORDER1.posAttrib);
     glEnableVertexAttribArray(m_RenderData.pCurrentMonData->m_shBORDER1.texAttrib);
 
-    if (pixman_region32_not_empty(m_RenderData.pDamage)) {
-        PIXMAN_DAMAGE_FOREACH(m_RenderData.pDamage) {
-            const auto RECT = RECTSARR[i];
-            scissor(&RECT);
-            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+    if (m_RenderData.clipBox.width != 0 && m_RenderData.clipBox.height != 0) {
+        pixman_region32_t damageClip;
+        pixman_region32_init(&damageClip);
+        pixman_region32_intersect_rect(&damageClip, m_RenderData.pDamage, m_RenderData.clipBox.x, m_RenderData.clipBox.y, m_RenderData.clipBox.width, m_RenderData.clipBox.height);
+
+        if (pixman_region32_not_empty(&damageClip)) {
+            PIXMAN_DAMAGE_FOREACH(&damageClip) {
+                const auto RECT = RECTSARR[i];
+                scissor(&RECT);
+                glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+            }
         }
+
+	pixman_region32_fini(&damageClip);
+    } else {
+	PIXMAN_DAMAGE_FOREACH(m_RenderData.pDamage) {
+	    const auto RECT = RECTSARR[i];
+	    scissor(&RECT);
+	    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+	}
     }
 
     glDisableVertexAttribArray(m_RenderData.pCurrentMonData->m_shBORDER1.posAttrib);
@@ -1033,6 +1089,9 @@ void CHyprOpenGLImpl::renderRoundedShadow(wlr_box* box, int round, int range, fl
     RASSERT((box->width > 0 && box->height > 0), "Tried to render shadow with width/height < 0!");
     RASSERT(m_pCurrentWindow, "Tried to render shadow without a window!");
 
+    if (!pixman_region32_not_empty(m_RenderData.pDamage))
+	return;
+
     static auto *const PSHADOWPOWER = &g_pConfigManager->getConfigValuePtr("decoration:shadow_render_power")->intValue;
 
     const auto SHADOWPOWER = std::clamp((int)*PSHADOWPOWER, 1, 4);
@@ -1074,12 +1133,26 @@ void CHyprOpenGLImpl::renderRoundedShadow(wlr_box* box, int round, int range, fl
     glEnableVertexAttribArray(m_RenderData.pCurrentMonData->m_shSHADOW.posAttrib);
     glEnableVertexAttribArray(m_RenderData.pCurrentMonData->m_shSHADOW.texAttrib);
 
-    if (pixman_region32_not_empty(m_RenderData.pDamage)) {
-        PIXMAN_DAMAGE_FOREACH(m_RenderData.pDamage) {
-            const auto RECT = RECTSARR[i];
-            scissor(&RECT);
-            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+    if (m_RenderData.clipBox.width != 0 && m_RenderData.clipBox.height != 0) {
+        pixman_region32_t damageClip;
+        pixman_region32_init(&damageClip);
+        pixman_region32_intersect_rect(&damageClip, m_RenderData.pDamage, m_RenderData.clipBox.x, m_RenderData.clipBox.y, m_RenderData.clipBox.width, m_RenderData.clipBox.height);
+
+        if (pixman_region32_not_empty(&damageClip)) {
+            PIXMAN_DAMAGE_FOREACH(&damageClip) {
+                const auto RECT = RECTSARR[i];
+                scissor(&RECT);
+                glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+            }
         }
+
+	pixman_region32_fini(&damageClip);
+    } else {
+	PIXMAN_DAMAGE_FOREACH(m_RenderData.pDamage) {
+	    const auto RECT = RECTSARR[i];
+	    scissor(&RECT);
+	    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+	}
     }
 
     glDisableVertexAttribArray(m_RenderData.pCurrentMonData->m_shSHADOW.posAttrib);
@@ -1218,17 +1291,32 @@ void CHyprOpenGLImpl::clearWithTex() {
     static auto *const PRENDERTEX = &g_pConfigManager->getConfigValuePtr("misc:disable_hyprland_logo")->intValue;
 
     if (!*PRENDERTEX) {
-        renderTexture(m_mMonitorBGTextures[m_RenderData.pMonitor], &m_mMonitorRenderResources[m_RenderData.pMonitor].backgroundTexBox, 255, 0);
+        auto TEXIT = m_mMonitorBGTextures.find(m_RenderData.pMonitor);
+
+        if (TEXIT == m_mMonitorBGTextures.end()) {
+            createBGTextureForMonitor(m_RenderData.pMonitor);
+            TEXIT = m_mMonitorBGTextures.find(m_RenderData.pMonitor);
+        }
+
+        if (TEXIT != m_mMonitorBGTextures.end())
+            renderTexture(TEXIT->second, &m_mMonitorRenderResources[m_RenderData.pMonitor].backgroundTexBox, 255, 0);
     }
 }
 
 void CHyprOpenGLImpl::destroyMonitorResources(CMonitor* pMonitor) {
+    wlr_output_attach_render(pMonitor->output, nullptr);
+
     g_pHyprOpenGL->m_mMonitorRenderResources[pMonitor].mirrorFB.release();
     g_pHyprOpenGL->m_mMonitorRenderResources[pMonitor].primaryFB.release();
+    g_pHyprOpenGL->m_mMonitorRenderResources[pMonitor].mirrorSwapFB.release();
+    g_pHyprOpenGL->m_mMonitorRenderResources[pMonitor].monitorMirrorFB.release();
+    g_pHyprOpenGL->m_mMonitorRenderResources[pMonitor].blurFB.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());
+
+    wlr_output_rollback(pMonitor->output);
 }

src/render/OpenGL.hpp

@@ -67,6 +67,8 @@ struct SCurrentRenderData {
 
     Vector2D    primarySurfaceUVTopLeft = Vector2D(-1, -1);
     Vector2D    primarySurfaceUVBottomRight = Vector2D(-1, -1);
+
+    wlr_box     clipBox = {};
 };
 
 class CHyprOpenGLImpl {

src/render/Renderer.cpp

@@ -248,11 +248,38 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, CMonitor* pMonitor, timespec*
 
     g_pHyprOpenGL->m_pCurrentWindow = pWindow;
 
+    // clip box for animated offsets
+    Vector2D offset;
+    if (PWORKSPACE->m_vRenderOffset.vec().x != 0) {
+        const auto PWSMON = g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID);
+        const auto PROGRESS = PWORKSPACE->m_vRenderOffset.vec().x / PWSMON->vecSize.x;
+        const auto WINBB = pWindow->getFullWindowBoundingBox();
+
+        if (WINBB.x < PWSMON->vecPosition.x) {
+            offset.x = (PWSMON->vecPosition.x - WINBB.x) * PROGRESS;
+        } else if (WINBB.x > PWSMON->vecPosition.x + PWSMON->vecSize.x) {
+            offset.x = (WINBB.x - PWSMON->vecPosition.x + PWSMON->vecSize.x) * PROGRESS;
+        }
+    } else if (PWORKSPACE->m_vRenderOffset.vec().y) {
+        const auto PWSMON = g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID);
+        const auto PROGRESS = PWORKSPACE->m_vRenderOffset.vec().y / PWSMON->vecSize.y;
+        const auto WINBB = pWindow->getFullWindowBoundingBox();
+
+        if (WINBB.y < PWSMON->vecPosition.y) {
+            offset.y = (PWSMON->vecPosition.y - WINBB.y) * PROGRESS;
+        } else if (WINBB.y > PWSMON->vecPosition.y + PWSMON->vecSize.y) {
+            offset.y = (WINBB.y - PWSMON->vecPosition.y + PWSMON->vecSize.y) * PROGRESS;
+        }
+    }
+
+    renderdata.x += offset.x;
+    renderdata.y += offset.y;
+
     // render window decorations first, if not fullscreen full
 
     if (mode == RENDER_PASS_ALL || mode == RENDER_PASS_MAIN) {
         if (!pWindow->m_bIsFullscreen || PWORKSPACE->m_efFullscreenMode != FULLSCREEN_FULL) for (auto& wd : pWindow->m_dWindowDecorations)
-                wd->draw(pMonitor, renderdata.alpha * renderdata.fadeAlpha / 255.f);
+                wd->draw(pMonitor, renderdata.alpha * renderdata.fadeAlpha / 255.f, offset);
 
         wlr_surface_for_each_surface(g_pXWaylandManager->getWindowSurface(pWindow), renderSurface, &renderdata);
 
@@ -289,6 +316,7 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, CMonitor* pMonitor, timespec*
     }
 
     g_pHyprOpenGL->m_pCurrentWindow = nullptr;
+    g_pHyprOpenGL->m_RenderData.clipBox = { 0, 0, 0, 0 };
 }
 
 void CHyprRenderer::renderLayer(SLayerSurface* pLayer, CMonitor* pMonitor, timespec* time) {
@@ -1131,9 +1159,6 @@ bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorR
         wlr_output_enable_adaptive_sync(pMonitor->output, 0);
     }
 
-    // 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 true;
@@ -1165,6 +1190,9 @@ bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorR
 
     wlr_output_enable(pMonitor->output, true);
 
+    // update renderer (here because it will call rollback, so we cannot do this before committing)
+    g_pHyprOpenGL->destroyMonitorResources(pMonitor);
+
     // updato wlroots
     Events::listener_change(nullptr, nullptr);
 

src/render/decorations/CHyprDropShadowDecoration.cpp

@@ -48,7 +48,7 @@ void CHyprDropShadowDecoration::updateWindow(CWindow* pWindow) {
     }
 }
 
-void CHyprDropShadowDecoration::draw(CMonitor* pMonitor, float a) {
+void CHyprDropShadowDecoration::draw(CMonitor* pMonitor, float a, const Vector2D& offset) {
 
     if (!g_pCompositor->windowValidMapped(m_pWindow))
         return;
@@ -79,6 +79,9 @@ void CHyprDropShadowDecoration::draw(CMonitor* pMonitor, float a) {
     fullBox.x -= pMonitor->vecPosition.x;
     fullBox.y -= pMonitor->vecPosition.y;
 
+    fullBox.x += offset.x;
+    fullBox.y += offset.y;
+
     if (fullBox.width < 1 || fullBox.height < 1)
         return; // don't draw invisible shadows
 

src/render/decorations/CHyprDropShadowDecoration.hpp

@@ -9,7 +9,7 @@ public:
 
     virtual SWindowDecorationExtents getWindowDecorationExtents();
 
-    virtual void draw(CMonitor*, float a);
+    virtual void draw(CMonitor*, float a, const Vector2D& offset);
 
     virtual eDecorationType getDecorationType();
 

src/render/decorations/CHyprGroupBarDecoration.cpp

@@ -63,7 +63,7 @@ void CHyprGroupBarDecoration::damageEntire() {
     g_pHyprRenderer->damageBox(&dm);
 }
 
-void CHyprGroupBarDecoration::draw(CMonitor* pMonitor, float a) {
+void CHyprGroupBarDecoration::draw(CMonitor* pMonitor, float a, const Vector2D& offset) {
     // get how many bars we will draw
     int barsToDraw = m_dwGroupMembers.size();
 
@@ -80,7 +80,7 @@ void CHyprGroupBarDecoration::draw(CMonitor* pMonitor, float a) {
     int xoff = 0;
 
     for (int i = 0; i < barsToDraw; ++i) {
-        wlr_box rect = {m_vLastWindowPos.x + xoff - pMonitor->vecPosition.x, m_vLastWindowPos.y - m_seExtents.topLeft.y - pMonitor->vecPosition.y, BARW, 3};
+        wlr_box rect = {m_vLastWindowPos.x + xoff - pMonitor->vecPosition.x + offset.x, m_vLastWindowPos.y - m_seExtents.topLeft.y - pMonitor->vecPosition.y + offset.y, BARW, 3};
 
         if (rect.width <= 0 || rect.height <= 0)
             break;

src/render/decorations/CHyprGroupBarDecoration.hpp

@@ -10,7 +10,7 @@ public:
 
     virtual SWindowDecorationExtents getWindowDecorationExtents();
 
-    virtual void draw(CMonitor*, float a);
+    virtual void draw(CMonitor*, float a, const Vector2D& offset);
 
     virtual eDecorationType getDecorationType();
 

src/render/decorations/IHyprWindowDecoration.hpp

@@ -22,7 +22,7 @@ public:
 
     virtual SWindowDecorationExtents getWindowDecorationExtents() = 0;
 
-    virtual void draw(CMonitor*, float a) = 0;
+    virtual void draw(CMonitor*, float a, const Vector2D& offset = Vector2D()) = 0;
 
     virtual eDecorationType getDecorationType() = 0;