[gha] bump flake inputs

update wlroots dep
better subsurface handling on unmaps
2025-08-26 09:23:48 -07:00 · 2022-10-09 20:30:56 +00:00 · 2022-10-09 21:29:54 +01:00 · 2022-10-09 17:40:30 +01:00 · 2022-10-09 17:10:20 +01:00 · 2022-10-09 17:02:39 +01:00
35 changed files with 611 additions and 365 deletions
--- a/flake.lock
+++ b/flake.lock
@@ -2,11 +2,11 @@
  "nodes": {
    "nixpkgs": {
      "locked": {
-        "lastModified": 1664687381,
-        "narHash": "sha256-9czSuDzS+OGGwq2kC4KXBLXWfYaup+oLB+AA1Md25U4=",
+        "lastModified": 1665259268,
+        "narHash": "sha256-ONFhHBLv5nZKhwV/F2GOH16197PbvpyWhoO0AOyktkU=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "59d2991d4256cdca1c0cda45d876c80a0fe45c31",
+        "rev": "c5924154f000e6306030300592f4282949b2db6c",
        "type": "github"
      },
      "original": {
@@ -26,11 +26,11 @@
      "flake": false,
      "locked": {
        "host": "gitlab.freedesktop.org",
-        "lastModified": 1664816798,
-        "narHash": "sha256-oLJyFT1Fc4UNNaDSN+EYUAWL4CufCBpuS5AV4Z4XANo=",
+        "lastModified": 1665331677,
+        "narHash": "sha256-3Dh1i11mHK80jx5figC1oh1V0rCjieh0Mj+MajXdbPw=",
        "owner": "wlroots",
        "repo": "wlroots",
-        "rev": "50cc1ef4d3791d86854dd83c15fff17e5ea1a5b6",
+        "rev": "ab8341975e62b1f668d8c9779ec8e72d04718a99",
        "type": "gitlab"
      },
      "original": {
--- a/flake.nix
+++ b/flake.nix
@@ -58,7 +58,7 @@
      };
      hyprland = prev.callPackage ./nix/default.nix {
        stdenv = prev.gcc12Stdenv;
-        version = "0.14.0beta" + "+date=" + (mkDate (self.lastModifiedDate or "19700101")) + "_" + (self.shortRev or "dirty");
+        version = "0.15.0beta" + "+date=" + (mkDate (self.lastModifiedDate or "19700101")) + "_" + (self.shortRev or "dirty");
        wlroots = wlroots-hyprland;
      };
      hyprland-debug = hyprland.override {debug = true;};
--- a/meson.build
+++ b/meson.build
@@ -1,5 +1,5 @@
 project('Hyprland', 'cpp', 'c',
-  version : '0.14.0beta',
+  version : '0.15.0beta',
  default_options : [
    'warning_level=2',
    'default_library=static',
--- a/src/Compositor.cpp
+++ b/src/Compositor.cpp
@@ -240,10 +240,8 @@ void CCompositor::cleanup() {

    // accumulate all PIDs for killing, also request closing.
    for (auto& w : m_vWindows) {
-        if (w->m_bIsMapped || !w->m_bIsX11)
+        if (w->m_bIsMapped && !w->m_bHidden)
            m_dProcessPIDsOnShutdown.push_back(w->getPID());
-
-        closeWindow(w.get());
    }

    // end threads
@@ -252,6 +250,8 @@ void CCompositor::cleanup() {
    m_vWorkspaces.clear();
    m_vWindows.clear();

+    m_bIsShuttingDown = true;
+
    for (auto& m : m_vMonitors) {
        g_pHyprOpenGL->destroyMonitorResources(m.get());

@@ -259,6 +259,8 @@ void CCompositor::cleanup() {
        wlr_output_commit(m->output);
    }

+    m_vMonitors.clear();
+
    if (g_pXWaylandManager->m_sWLRXWayland) {
        wlr_xwayland_destroy(g_pXWaylandManager->m_sWLRXWayland);
        g_pXWaylandManager->m_sWLRXWayland = nullptr;
@@ -266,8 +268,6 @@ void CCompositor::cleanup() {

    wl_display_terminate(m_sWLDisplay);

-    m_bIsShuttingDown = true;
-
    g_pKeybindManager->spawn("sleep 5 && kill -9 " + std::to_string(m_iHyprlandPID));  // this is to prevent that random "freezing"
                                                                                       // the PID should not be reused.
 }
--- a/src/Window.hpp
+++ b/src/Window.hpp
@@ -23,6 +23,7 @@ struct SWindowAdditionalConfigData {
    bool forceNoBlur = false;
    bool forceOpaque = false;
    bool forceAllowsInput = false;
+    bool forceNoAnims = false;
 };

 class CWindow {
--- a/src/config/ConfigManager.cpp
+++ b/src/config/ConfigManager.cpp
@@ -125,6 +125,7 @@ void CConfigManager::setDefaultVars() {
    configValues["animations:workspaces"].intValue = 1;

    configValues["input:sensitivity"].floatValue = 0.f;
+    configValues["input:accel_profile"].strValue = STRVAL_EMPTY;
    configValues["input:kb_file"].strValue = STRVAL_EMPTY;
    configValues["input:kb_layout"].strValue = "us";
    configValues["input:kb_variant"].strValue = STRVAL_EMPTY;
@@ -137,12 +138,15 @@ void CConfigManager::setDefaultVars() {
    configValues["input:numlock_by_default"].intValue = 0;
    configValues["input:force_no_accel"].intValue = 0;
    configValues["input:float_switch_override_focus"].intValue = 1;
+    configValues["input:left_handed"].intValue = 0;
+    configValues["input:scroll_method"].strValue = STRVAL_EMPTY;
    configValues["input:touchpad:natural_scroll"].intValue = 0;
    configValues["input:touchpad:disable_while_typing"].intValue = 1;
    configValues["input:touchpad:clickfinger_behavior"].intValue = 0;
    configValues["input:touchpad:middle_button_emulation"].intValue = 0;
    configValues["input:touchpad:tap-to-click"].intValue = 1;
    configValues["input:touchpad:drag_lock"].intValue = 0;
+    configValues["input:touchpad:scroll_factor"].floatValue = 1.f;

    configValues["binds:pass_mouse_when_bound"].intValue = 0;
    configValues["binds:scroll_event_delay"].intValue = 300;
@@ -165,6 +169,7 @@ void CConfigManager::setDeviceDefaultVars(const std::string& dev) {
    auto& cfgValues = deviceConfigs[dev];

    cfgValues["sensitivity"].floatValue = 0.f;
+    cfgValues["accel_profile"].strValue = STRVAL_EMPTY;
    cfgValues["kb_file"].strValue = STRVAL_EMPTY;
    cfgValues["kb_layout"].strValue = "us";
    cfgValues["kb_variant"].strValue = STRVAL_EMPTY;
@@ -180,6 +185,8 @@ void CConfigManager::setDeviceDefaultVars(const std::string& dev) {
    cfgValues["middle_button_emulation"].intValue = 0;
    cfgValues["tap-to-click"].intValue = 1;
    cfgValues["drag_lock"].intValue = 0;
+    cfgValues["left_handed"].intValue = 0;
+    cfgValues["scroll_method"].strValue = STRVAL_EMPTY;
 }

 void CConfigManager::setDefaultAnimationVars() {
@@ -373,6 +380,11 @@ void CConfigManager::handleRawExec(const std::string& command, const std::string
    if (child == 0) {
        // run in child
        grandchild = fork();
+
+        sigset_t set;
+        sigemptyset(&set);
+        sigprocmask(SIG_SETMASK, &set, NULL);
+
        if (grandchild == 0) {
            // run in grandchild
            close(socket[0]);
@@ -705,6 +717,7 @@ bool windowRuleValid(const std::string& RULE) {
        && RULE.find("opacity") != 0
        && RULE.find("move") != 0
        && RULE.find("size") != 0
+        && RULE.find("minsize") != 0
        && RULE.find("pseudo") != 0
        && RULE.find("monitor") != 0
        && RULE != "nofocus"
@@ -714,6 +727,7 @@ bool windowRuleValid(const std::string& RULE) {
        && RULE != "forceinput"
        && RULE != "fullscreen"
        && RULE != "pin"
+        && RULE != "noanim"
        && RULE.find("animation") != 0
        && RULE.find("rounding") != 0
        && RULE.find("workspace") != 0);
@@ -1124,7 +1138,7 @@ void CConfigManager::loadConfigLoadVars() {
    // Update the keyboard layout to the cfg'd one if this is not the first launch
    if (!isFirstLaunch) {
        g_pInputManager->setKeyboardLayout();
-        g_pInputManager->setMouseConfigs();
+        g_pInputManager->setPointerConfigs();
    }

    // Calculate the internal vars
@@ -1294,11 +1308,11 @@ void CConfigManager::setString(std::string v, std::string val) {
    configValues[v].strValue = val;
 }

-SMonitorRule CConfigManager::getMonitorRuleFor(std::string name) {
+SMonitorRule CConfigManager::getMonitorRuleFor(std::string name, std::string displayName) {
    SMonitorRule* found = nullptr;

    for (auto& r : m_dMonitorRules) {
-        if (r.name == name) {
+        if (r.name == name || (r.name.find("desc:") == 0 && (r.name.substr(5) == displayName || r.name.substr(5) == removeBeginEndSpacesTabs(displayName.substr(0, displayName.find_first_of('(')))))) {
            found = &r;
            break;
        }
@@ -1409,7 +1423,7 @@ void CConfigManager::dispatchExecOnce() {

    // set input, fixes some certain issues
    g_pInputManager->setKeyboardLayout();
-    g_pInputManager->setMouseConfigs();
+    g_pInputManager->setPointerConfigs();

    // set ws names again
    for (auto& ws : g_pCompositor->m_vWorkspaces) {
@@ -1422,7 +1436,7 @@ void CConfigManager::performMonitorReload() {
    bool overAgain = false;

    for (auto& m : g_pCompositor->m_vRealMonitors) {
-        auto rule = getMonitorRuleFor(m->szName);
+        auto rule = getMonitorRuleFor(m->szName, m->output->description ? m->output->description : "");

        // ensure mirror
        m->setMirror(rule.mirrorOf);
@@ -1475,7 +1489,7 @@ bool CConfigManager::shouldBlurLS(const std::string& ns) {

 void CConfigManager::ensureDPMS() {
    for (auto& rm : g_pCompositor->m_vRealMonitors) {
-        auto rule = getMonitorRuleFor(rm->szName);
+        auto rule = getMonitorRuleFor(rm->szName, rm->output->description ? rm->output->description : "");

        if (rule.disabled == rm->m_bEnabled) {
 	        rm->m_pThisWrap = &rm;
--- a/src/config/ConfigManager.hpp
+++ b/src/config/ConfigManager.hpp
@@ -135,7 +135,7 @@ public:
    SConfigValue*       getConfigValuePtr(std::string);
    SConfigValue*       getConfigValuePtrSafe(std::string);

-    SMonitorRule        getMonitorRuleFor(std::string);
+    SMonitorRule        getMonitorRuleFor(std::string, std::string displayName = "");

    CMonitor*           getBoundMonitorForWS(std::string);

--- a/src/debug/HyprCtl.cpp
+++ b/src/debug/HyprCtl.cpp
@@ -23,6 +23,7 @@ std::string monitorsRequest(HyprCtl::eHyprCtlOutputFormat format) {
 R"#({
    "id": %i,
    "name": "%s",
+    "description": "%s",
    "width": %i,
    "height": %i,
    "refreshRate": %f,
@@ -35,10 +36,12 @@ R"#({
    "reserved": [%i, %i, %i, %i],
    "scale": %.2f,
    "transform": %i,
-    "focused": %s
+    "focused": %s,
+    "dpmsStatus": %s
 },)#",
                m->ID,
                escapeJSONStrings(m->szName).c_str(),
+                escapeJSONStrings(m->output->description ? m->output->description : "").c_str(),
                (int)m->vecPixelSize.x, (int)m->vecPixelSize.y,
                m->refreshRate,
                (int)m->vecPosition.x, (int)m->vecPosition.y,
@@ -46,7 +49,8 @@ R"#({
                (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y,
                m->scale,
                (int)m->transform,
-                (m.get() == g_pCompositor->m_pLastMonitor ? "true" : "false")
+                (m.get() == g_pCompositor->m_pLastMonitor ? "true" : "false"),
+                (m->dpmsStatus ? "true" : "false")
            );
        }

@@ -56,8 +60,8 @@ R"#({
        result += "]";
    } else {
        for (auto& m : g_pCompositor->m_vMonitors) {
-            result += getFormat("Monitor %s (ID %i):\n\t%ix%i@%f at %ix%i\n\tactive workspace: %i (%s)\n\treserved: %i %i %i %i\n\tscale: %.2f\n\ttransform: %i\n\tfocused: %s\n\n",
-                                m->szName.c_str(), m->ID, (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y, m->activeWorkspace, g_pCompositor->getWorkspaceByID(m->activeWorkspace)->m_szName.c_str(), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m.get() == g_pCompositor->m_pLastMonitor ? "yes" : "no"));
+            result += getFormat("Monitor %s (ID %i):\n\t%ix%i@%f at %ix%i\n\tdescription: %s\n\tactive workspace: %i (%s)\n\treserved: %i %i %i %i\n\tscale: %.2f\n\ttransform: %i\n\tfocused: %s\n\tdpmsStatus: %i\n\n",
+                                m->szName.c_str(), m->ID, (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y, (m->output->description ? m->output->description : ""), m->activeWorkspace, g_pCompositor->getWorkspaceByID(m->activeWorkspace)->m_szName.c_str(), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m.get() == g_pCompositor->m_pLastMonitor ? "yes" : "no"), (int)m->dpmsStatus);
        }
    }

@@ -91,8 +95,8 @@ R"#({
    "fullscreenMode": %i
 },)#",
                    w.get(),
-                    (int)w->m_vRealPosition.vec().x, (int)w->m_vRealPosition.vec().y,
-                    (int)w->m_vRealSize.vec().x, (int)w->m_vRealSize.vec().y,
+                    (int)w->m_vRealPosition.goalv().x, (int)w->m_vRealPosition.goalv().y,
+                    (int)w->m_vRealSize.goalv().x, (int)w->m_vRealSize.goalv().y,
                    w->m_iWorkspaceID, escapeJSONStrings(w->m_iWorkspaceID == -1 ? "" : g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_szName : std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID))).c_str(),
                    ((int)w->m_bIsFloating == 1 ? "true" : "false"),
                    w->m_iMonitorID,
@@ -116,7 +120,7 @@ R"#({
        for (auto& w : g_pCompositor->m_vWindows) {
            if (w->m_bIsMapped) {
                result += getFormat("Window %x -> %s:\n\tat: %i,%i\n\tsize: %i,%i\n\tworkspace: %i (%s)\n\tfloating: %i\n\tmonitor: %i\n\tclass: %s\n\ttitle: %s\n\tpid: %i\n\txwayland: %i\n\tpinned: %i\n\tfullscreen: %i\n\tfullscreenmode: %i\n\n",
-                                w.get(), w->m_szTitle.c_str(), (int)w->m_vRealPosition.vec().x, (int)w->m_vRealPosition.vec().y, (int)w->m_vRealSize.vec().x, (int)w->m_vRealSize.vec().y, w->m_iWorkspaceID, (w->m_iWorkspaceID == -1 ? "" : g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_szName.c_str() : std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID)).c_str()), (int)w->m_bIsFloating, w->m_iMonitorID, g_pXWaylandManager->getAppIDClass(w.get()).c_str(), g_pXWaylandManager->getTitle(w.get()).c_str(), w->getPID(), (int)w->m_bIsX11, (int)w->m_bPinned, (int)w->m_bIsFullscreen, (w->m_bIsFullscreen ? (g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_efFullscreenMode : 0) : 0));
+                                w.get(), w->m_szTitle.c_str(), (int)w->m_vRealPosition.goalv().x, (int)w->m_vRealPosition.goalv().y, (int)w->m_vRealSize.goalv().x, (int)w->m_vRealSize.goalv().y, w->m_iWorkspaceID, (w->m_iWorkspaceID == -1 ? "" : g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_szName.c_str() : std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID)).c_str()), (int)w->m_bIsFloating, w->m_iMonitorID, g_pXWaylandManager->getAppIDClass(w.get()).c_str(), g_pXWaylandManager->getTitle(w.get()).c_str(), w->getPID(), (int)w->m_bIsX11, (int)w->m_bPinned, (int)w->m_bIsFullscreen, (w->m_bIsFullscreen ? (g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_efFullscreenMode : 0) : 0));

            }
        }
@@ -402,6 +406,24 @@ R"#(    {
            );
        }

+        // remove trailing comma
+        if (result[result.size() - 1] == ',')
+            result.pop_back();
+        result += "\n],\n";
+
+        result += "\"switches\": [\n";
+
+        for (auto& d : g_pInputManager->m_lSwitches) {
+            result += getFormat(
+R"#(    {
+        "address": "0x%x",
+        "name": "%s"
+    },)#",
+                &d,
+                d.pWlrDevice ? d.pWlrDevice->name : ""
+            );
+        }
+
        // remove trailing comma
        if (result[result.size() - 1] == ',')
            result.pop_back();
@@ -442,6 +464,12 @@ R"#(    {
        for (auto& d : g_pInputManager->m_lTouchDevices) {
            result += getFormat("\tTouch Device at %x:\n\t\t%s\n", &d, d.pWlrDevice ? d.pWlrDevice->name : "");
        }
+
+        result += "\n\nSwitches:\n";
+
+        for (auto& d : g_pInputManager->m_lSwitches) {
+            result += getFormat("\tSwitch Device at %x:\n\t\t%s\n", &d, d.pWlrDevice ? d.pWlrDevice->name : "");
+        }
    }

    return result;
@@ -533,7 +561,7 @@ std::string dispatchKeyword(std::string in) {

    if (COMMAND.contains("input") || COMMAND.contains("device:")) {
        g_pInputManager->setKeyboardLayout(); // update kb layout
-        g_pInputManager->setMouseConfigs(); // update mouse cfgs
+        g_pInputManager->setPointerConfigs(); // update mouse cfgs
    }

    if (COMMAND.contains("general:layout"))
--- a/src/events/Devices.cpp
+++ b/src/events/Devices.cpp
@@ -82,6 +82,10 @@ void Events::listener_newInput(wl_listener* listener, void* data) {
            Debug::log(LOG, "Attached a tablet pad with name %s", DEVICE->name);
            g_pInputManager->newTabletPad(DEVICE);
            break;
+        case WLR_INPUT_DEVICE_SWITCH:
+            Debug::log(LOG, "Attached a switch device with name %s", DEVICE->name);
+            g_pInputManager->newSwitch(DEVICE);
+            break;
        default:
            Debug::log(WARN, "Unrecognized input device plugged in: %s", DEVICE->name);
            break;
--- a/src/events/Layers.cpp
+++ b/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.");

--- a/src/events/Popups.cpp
+++ b/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;
        }
--- a/src/events/Windows.cpp
+++ b/src/events/Windows.cpp
@@ -166,6 +166,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
            PWINDOW->m_sAdditionalConfigData.forceAllowsInput = true;
        } else if (r.szRule == "pin") {
            PWINDOW->m_bPinned = true;
+        } else if (r.szRule == "noanim") {
+            PWINDOW->m_sAdditionalConfigData.forceNoAnims = true;
        } else if (r.szRule.find("rounding") == 0) {
            try {
                PWINDOW->m_sAdditionalConfigData.rounding = std::stoi(r.szRule.substr(r.szRule.find_first_of(' ') + 1));
@@ -249,6 +251,21 @@ void Events::listener_mapWindow(void* owner, void* data) {
                } catch (...) {
                    Debug::log(LOG, "Rule size failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str());
                }
+            } else if (r.szRule.find("minsize") == 0) {
+                try {
+                    const auto VALUE = r.szRule.substr(r.szRule.find(" ") + 1);
+                    const auto SIZEXSTR = VALUE.substr(0, VALUE.find(" "));
+                    const auto SIZEYSTR = VALUE.substr(VALUE.find(" ") + 1);
+
+                    const auto SIZE = Vector2D(std::max((double)std::stoll(SIZEXSTR), PWINDOW->m_vRealSize.goalv().x), std::max((double)std::stoll(SIZEYSTR), PWINDOW->m_vRealSize.goalv().y));
+
+                    PWINDOW->m_vRealSize = SIZE;
+                    g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
+
+                    PWINDOW->m_bHidden = false;
+                } catch (...) {
+                    Debug::log(LOG, "Rule minsize failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str());
+                }
            } else if (r.szRule.find("move") == 0) {
                try {
                    const auto VALUE = r.szRule.substr(r.szRule.find(" ") + 1);
@@ -380,39 +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
-            CWindow* found = nullptr;
-            for (auto& w : g_pCompositor->m_vWindows) {
-                if (!w->m_bIsMapped || w->m_bHidden)
-                    continue;
-
-                if (w->getPID() == ppid) {
-                    found = w.get();
+                if (curppid < 10) {
                    break;
                }
+
+                ppid = curppid;
            }

-            if (found) {
-                // check if it's the window we want
-                std::regex rgx(*PSWALLOWREGEX);
-                if (std::regex_match(g_pXWaylandManager->getAppIDClass(found), rgx)) {
-                    // swallow
-                    PWINDOW->m_pSwallowed = found;
+            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;

-                    g_pLayoutManager->getCurrentLayout()->onWindowRemoved(found);
+                    if (w->getPID() == ppid) {
+                        found.push_back(w.get());
+                    }
+                }

-                    found->m_bHidden = true;
+                if (found.size() > 1) {
+                    for (auto& w : found) {
+                        // try get the focus, otherwise we'll ignore to avoid swallowing incorrect windows
+                        if (w == PFOCUSEDWINDOWPREV) {
+                            finalFound = w;
+                            break;
+                        }
+                    }
+                } 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;
+
+                        g_pLayoutManager->getCurrentLayout()->onWindowRemoved(finalFound);
+
+                        finalFound->m_bHidden = true;
+                    }
                }
            }
        }
--- a/src/helpers/MiscFunctions.cpp
+++ b/src/helpers/MiscFunctions.cpp
@@ -331,6 +331,15 @@ void logSystemInfo() {
    Debug::log(LOG, "Node name: %s", unameInfo.nodename);
    Debug::log(LOG, "Release: %s", unameInfo.release);
    Debug::log(LOG, "Version: %s", unameInfo.version);
+    
+    Debug::log(NONE, "\n");
+
+    const std::string GPUINFO = execAndGet("lspci -vnn | grep VGA");
+    Debug::log(LOG, "GPU information:\n%s\n", GPUINFO.c_str());
+
+    if (GPUINFO.contains("NVIDIA")) {
+        Debug::log(WARN, "Warning: you're using an NVIDIA GPU. Make sure you follow the instructions on the wiki if anything is amiss.\n");
+    }

    // log etc
    Debug::log(LOG, "os-release:");
--- a/src/helpers/Monitor.cpp
+++ b/src/helpers/Monitor.cpp
@@ -9,7 +9,7 @@ void CMonitor::onConnect(bool noRule) {
    szName = output->name;

    // get monitor rule that matches
-    SMonitorRule monitorRule = g_pConfigManager->getMonitorRuleFor(output->name);
+    SMonitorRule monitorRule = g_pConfigManager->getMonitorRuleFor(output->name, output->description ? output->description : "");

    hyprListener_monitorFrame.initCallback(&output->events.frame, &Events::listener_monitorFrame, this);
    hyprListener_monitorDestroy.initCallback(&output->events.destroy, &Events::listener_monitorDestroy, this);
@@ -140,7 +140,7 @@ void CMonitor::onConnect(bool noRule) {

 void CMonitor::onDisconnect() {

-    if (!m_bEnabled)
+    if (!m_bEnabled || g_pCompositor->m_bIsShuttingDown)
        return;

    // Cleanup everything. Move windows back, snap cursor, shit.
@@ -297,7 +297,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
        pMirrorOf = nullptr;

        // set rule
-        const auto RULE = g_pConfigManager->getMonitorRuleFor(this->szName);
+        const auto RULE = g_pConfigManager->getMonitorRuleFor(this->szName, this->output->description ? this->output->description : "");

        vecPosition = RULE.offset;

--- a/src/helpers/Monitor.hpp
+++ b/src/helpers/Monitor.hpp
@@ -37,6 +37,8 @@ public:
    bool        scheduledRecalc = false;
    wl_output_transform transform = WL_OUTPUT_TRANSFORM_NORMAL;

+    bool        dpmsStatus = true;
+
    // mirroring
    CMonitor*   pMirrorOf = nullptr;
    std::vector<CMonitor*> mirrors;
--- a/src/helpers/SubsurfaceTree.cpp
+++ b/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;
    }
 }

--- a/src/helpers/WLClasses.hpp
+++ b/src/helpers/WLClasses.hpp
@@ -332,3 +332,14 @@ struct STouchDevice {
        return pWlrDevice == other.pWlrDevice;
    }
 };
+
+struct SSwitchDevice {
+    wlr_input_device* pWlrDevice = nullptr;
+
+    DYNLISTENER(destroy);
+    DYNLISTENER(toggle);
+
+    bool operator==(const SSwitchDevice& other) {
+        return pWlrDevice == other.pWlrDevice;
+    }
+};
--- a/src/includes.hpp
+++ b/src/includes.hpp
@@ -101,6 +101,7 @@ extern "C" {
 #include <wlr/types/wlr_input_method_v2.h>
 #include <wlr/types/wlr_text_input_v3.h>
 #include <wlr/types/wlr_touch.h>
+#include <wlr/types/wlr_switch.h>
 }

 #undef delete
--- a/src/managers/AnimationManager.cpp
+++ b/src/managers/AnimationManager.cpp
@@ -21,12 +21,12 @@ void CAnimationManager::addBezierWithName(std::string name, const Vector2D& p1,

 void CAnimationManager::tick() {

-    bool animationsDisabled = false;
+    bool animGlobalDisabled = false;

    static auto *const PANIMENABLED = &g_pConfigManager->getConfigValuePtr("animations:enabled")->intValue;

    if (!*PANIMENABLED)
-        animationsDisabled = true;
+        animGlobalDisabled = true;

    static auto *const  PBORDERSIZE       = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
    static auto *const  PSHADOWSENABLED   = &g_pConfigManager->getConfigValuePtr("decoration:drop_shadow")->intValue;
@@ -56,11 +56,13 @@ void CAnimationManager::tick() {
        const auto PWORKSPACE = (CWorkspace*)av->m_pWorkspace;
        const auto PLAYER = (SLayerSurface*)av->m_pLayer;
        CMonitor* PMONITOR = nullptr;
+        bool animationsDisabled = animGlobalDisabled;

        wlr_box WLRBOXPREV = {0,0,0,0};
        if (PWINDOW) {
            WLRBOXPREV = PWINDOW->getFullWindowBoundingBox();
            PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+            animationsDisabled = animationsDisabled || PWINDOW->m_sAdditionalConfigData.forceNoAnims;
        } else if (PWORKSPACE) {
            PMONITOR = g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID);
            WLRBOXPREV = {(int)PMONITOR->vecPosition.x, (int)PMONITOR->vecPosition.y, (int)PMONITOR->vecSize.x, (int)PMONITOR->vecSize.y};
--- a/src/managers/KeybindManager.cpp
+++ b/src/managers/KeybindManager.cpp
@@ -202,9 +202,9 @@ bool CKeybindManager::onKeyEvent(wlr_keyboard_key_event* e, SKeyboard* pKeyboard
        m_dPressedKeycodes.push_back(KEYCODE);
        m_dPressedKeysyms.push_back(keysym);

-        found = g_pKeybindManager->handleKeybinds(MODS, "", keysym, 0, true, e->time_msec) || found;
+        found = handleKeybinds(MODS, "", keysym, 0, true, e->time_msec) || found;

-        found = g_pKeybindManager->handleKeybinds(MODS, "", 0, KEYCODE, true, e->time_msec) || found;
+        found = handleKeybinds(MODS, "", 0, KEYCODE, true, e->time_msec) || found;

        if (found)
            shadowKeybinds(keysym, KEYCODE);
@@ -219,9 +219,9 @@ bool CKeybindManager::onKeyEvent(wlr_keyboard_key_event* e, SKeyboard* pKeyboard
        m_dPressedKeycodes.erase(std::remove(m_dPressedKeycodes.begin(), m_dPressedKeycodes.end(), KEYCODE), m_dPressedKeycodes.end());
        m_dPressedKeysyms.erase(std::remove(m_dPressedKeysyms.begin(), m_dPressedKeysyms.end(), keysym), m_dPressedKeysyms.end());

-        found = g_pKeybindManager->handleKeybinds(MODS, "", keysym, 0, false, e->time_msec) || found;
+        found = handleKeybinds(MODS, "", keysym, 0, false, e->time_msec) || found;

-        found = g_pKeybindManager->handleKeybinds(MODS, "", 0, KEYCODE, false, e->time_msec) || found;
+        found = handleKeybinds(MODS, "", 0, KEYCODE, false, e->time_msec) || found;

        shadowKeybinds();
    }
@@ -244,9 +244,9 @@ bool CKeybindManager::onAxisEvent(wlr_pointer_axis_event* e) {
    bool found = false;
    if (e->source == WLR_AXIS_SOURCE_WHEEL && e->orientation == WLR_AXIS_ORIENTATION_VERTICAL) {
        if (e->delta < 0) {
-            found = g_pKeybindManager->handleKeybinds(MODS, "mouse_down", 0, 0, true, 0);
+            found = handleKeybinds(MODS, "mouse_down", 0, 0, true, 0);
        } else {
-            found = g_pKeybindManager->handleKeybinds(MODS, "mouse_up", 0, 0, true, 0);
+            found = handleKeybinds(MODS, "mouse_up", 0, 0, true, 0);
        }

        if (found)
@@ -268,12 +268,12 @@ bool CKeybindManager::onMouseEvent(wlr_pointer_button_event* e) {
    bool mouseBindWasActive = ensureMouseBindState();

    if (e->state == WLR_BUTTON_PRESSED) {
-        found = g_pKeybindManager->handleKeybinds(MODS, "mouse:" + std::to_string(e->button), 0, 0, true, 0);
+        found = handleKeybinds(MODS, "mouse:" + std::to_string(e->button), 0, 0, true, 0);

        if (found)
            shadowKeybinds();
    } else {
-        found = g_pKeybindManager->handleKeybinds(MODS, "mouse:" + std::to_string(e->button), 0, 0, false, 0);
+        found = handleKeybinds(MODS, "mouse:" + std::to_string(e->button), 0, 0, false, 0);

        shadowKeybinds();
    }
@@ -281,6 +281,10 @@ bool CKeybindManager::onMouseEvent(wlr_pointer_button_event* e) {
    return !found && !mouseBindWasActive;
 }

+void CKeybindManager::onSwitchEvent(const std::string& switchName) {
+    handleKeybinds(0, "switch:" + switchName, 0, 0, true, 0);
+}
+
 int repeatKeyHandler(void* data) {
    SKeybind** ppActiveKeybind = (SKeybind**)data;

@@ -419,10 +423,29 @@ bool CKeybindManager::handleVT(xkb_keysym_t keysym) {
    if (!(keysym >= XKB_KEY_XF86Switch_VT_1 && keysym <= XKB_KEY_XF86Switch_VT_12))
        return false;

-    const auto PSESSION = wlr_backend_get_session(g_pCompositor->m_sWLRBackend);
-    if (PSESSION) {
-        const int TTY = keysym - XKB_KEY_XF86Switch_VT_1 + 1;
-        wlr_session_change_vt(PSESSION, TTY);
+    // beyond this point, return true to not handle anything else.
+    // we'll avoid printing shit to active windows.
+
+    if (g_pCompositor->m_sWLRSession) {
+        const unsigned int TTY = keysym - XKB_KEY_XF86Switch_VT_1 + 1;
+
+        // vtnr is bugged for some reason.
+        const std::string TTYSTR = execAndGet("head -n 1 /sys/devices/virtual/tty/tty0/active").substr(3);
+        unsigned int ttynum = 0;
+        try {
+            ttynum = std::stoll(TTYSTR);
+        } catch (std::exception &e) {
+            ; // oops?
+        }
+
+        if (ttynum == TTY)
+            return true;
+
+        Debug::log(LOG, "Switching from VT %i to VT %i", ttynum, TTY);
+
+        if (!wlr_session_change_vt(g_pCompositor->m_sWLRSession, TTY))
+            return true; // probably same session
+
        g_pCompositor->m_bSessionActive = false;

        for (auto& m : g_pCompositor->m_vMonitors) {
@@ -435,7 +458,7 @@ bool CKeybindManager::handleVT(xkb_keysym_t keysym) {
        return true;
    }

-    return false;
+    return true;
 }

 bool CKeybindManager::handleInternalKeybinds(xkb_keysym_t keysym) {
@@ -480,6 +503,11 @@ void CKeybindManager::spawn(std::string args) {
    }
    if (child == 0) {
        // run in child
+
+        sigset_t set;
+        sigemptyset(&set);
+        sigprocmask(SIG_SETMASK, &set, NULL);
+
        grandchild = fork();
        if (grandchild == 0) {
            // run in grandchild
@@ -616,12 +644,20 @@ void CKeybindManager::changeworkspace(std::string args) {

    if (*PBACKANDFORTH && PCURRENTWORKSPACE->m_iID == workspaceToChangeTo && PCURRENTWORKSPACE->m_iPrevWorkspaceID != -1 && !internal) {

+        const auto PPREVWORKSPACE = g_pCompositor->getWorkspaceByID(PCURRENTWORKSPACE->m_iPrevWorkspaceID);
+
        workspaceToChangeTo = PCURRENTWORKSPACE->m_iPrevWorkspaceID;
+        
+        if (PPREVWORKSPACE)
+            workspaceName = PPREVWORKSPACE->m_szName;
+        else
+            workspaceName = std::to_string(workspaceToChangeTo);
+
        isSwitchingToPrevious = true;

        // If the previous workspace ID isn't reset, cycles can form when continually going
        // to the previous workspace again and again.
-        static auto *const PALLOWWORKSPACECYCLES = &g_pConfigManager->getConfigValuePtr("binds:allow_workspace_cycles")->intValue;
+        static auto* const PALLOWWORKSPACECYCLES = &g_pConfigManager->getConfigValuePtr("binds:allow_workspace_cycles")->intValue;
        if (!*PALLOWWORKSPACECYCLES)
            PCURRENTWORKSPACE->m_iPrevWorkspaceID = -1;

@@ -988,7 +1024,7 @@ void CKeybindManager::moveFocusTo(std::string args) {
            Vector2D middle = PWINDOWTOCHANGETO->m_vRealPosition.goalv() + PWINDOWTOCHANGETO->m_vRealSize.goalv() / 2.f;
            g_pCompositor->warpCursorTo(middle);

-            if (PWINDOWTOCHANGETO->m_iMonitorID != g_pCompositor->m_pLastMonitor->ID) {
+            if (PLASTWINDOW->m_iMonitorID != PWINDOWTOCHANGETO->m_iMonitorID) {
                // event
                const auto PNEWMON = g_pCompositor->getMonitorFromID(PWINDOWTOCHANGETO->m_iMonitorID);
                const auto PNEWWS = g_pCompositor->getWorkspaceByID(PNEWMON->activeWorkspace);
@@ -1324,7 +1360,7 @@ void CKeybindManager::forceRendererReload(std::string args) {
    bool overAgain = false;

    for (auto& m : g_pCompositor->m_vMonitors) {
-        auto rule = g_pConfigManager->getMonitorRuleFor(m->szName);
+        auto rule = g_pConfigManager->getMonitorRuleFor(m->szName, m->output->description ? m->output->description : "");
        if (!g_pHyprRenderer->applyMonitorRule(m.get(), &rule, true)) {
            overAgain = true;
            break;
@@ -1560,11 +1596,22 @@ void CKeybindManager::toggleOpaque(std::string unused) {
 }

 void CKeybindManager::dpms(std::string arg) {
-    bool enable = arg == "on";
+    bool enable = arg.find("on") == 0;
+    std::string port = "";
+
+    if (arg.find_first_of(' ') != std::string::npos) {
+        port = arg.substr(arg.find_first_of(' ') + 1);
+    }

    for (auto& m : g_pCompositor->m_vMonitors) {
+
+        if (!port.empty() && m->szName != port)
+            continue;
+
        wlr_output_enable(m->output, enable);

+        m->dpmsStatus = enable;
+
        if (!wlr_output_commit(m->output)) {
            Debug::log(ERR, "Couldn't commit output %s", m->szName.c_str());
        }
@@ -1640,7 +1687,7 @@ void CKeybindManager::mouse(std::string args) {
        if (PRESSED) {
            g_pKeybindManager->m_bIsMouseBindActive = true;

-            g_pInputManager->currentlyDraggedWindow = g_pCompositor->windowFromCursor();
+            g_pInputManager->currentlyDraggedWindow = g_pCompositor->vectorToWindowIdeal(g_pInputManager->getMouseCoordsInternal());
            g_pInputManager->dragMode = MBIND_MOVE;

            g_pLayoutManager->getCurrentLayout()->onBeginDragWindow();
@@ -1657,7 +1704,7 @@ void CKeybindManager::mouse(std::string args) {
        if (PRESSED) {
            g_pKeybindManager->m_bIsMouseBindActive = true;

-            g_pInputManager->currentlyDraggedWindow = g_pCompositor->windowFromCursor();
+            g_pInputManager->currentlyDraggedWindow = g_pCompositor->vectorToWindowIdeal(g_pInputManager->getMouseCoordsInternal());
            g_pInputManager->dragMode = MBIND_RESIZE;

            g_pLayoutManager->getCurrentLayout()->onBeginDragWindow();
--- a/src/managers/KeybindManager.hpp
+++ b/src/managers/KeybindManager.hpp
@@ -38,6 +38,7 @@ public:
    bool                onKeyEvent(wlr_keyboard_key_event*, SKeyboard*);
    bool                onAxisEvent(wlr_pointer_axis_event*);
    bool                onMouseEvent(wlr_pointer_button_event*);
+    void                onSwitchEvent(const std::string&);

    void                addKeybind(SKeybind);
    void                removeKeybind(uint32_t, const std::string&);
--- a/src/managers/input/InputManager.cpp
+++ b/src/managers/input/InputManager.cpp
@@ -435,12 +435,17 @@ void CInputManager::processMouseDownKill(wlr_pointer_button_event* e) {
 }

 void CInputManager::onMouseWheel(wlr_pointer_axis_event* e) {
+    static auto *const PSCROLLFACTOR = &g_pConfigManager->getConfigValuePtr("input:touchpad:scroll_factor")->floatValue;
+
+    auto factor = (*PSCROLLFACTOR <= 0.f || e->source != WLR_AXIS_SOURCE_FINGER ? 1.f : *PSCROLLFACTOR);
+
    bool passEvent = g_pKeybindManager->onAxisEvent(e);

    wlr_idle_notify_activity(g_pCompositor->m_sWLRIdle, g_pCompositor->m_sSeat.seat);

    if (passEvent) {
-        wlr_seat_pointer_notify_axis(g_pCompositor->m_sSeat.seat, e->time_msec, e->orientation, e->delta, e->delta_discrete, e->source);
+        wlr_seat_pointer_notify_axis(g_pCompositor->m_sSeat.seat, e->time_msec, e->orientation, factor * e->delta,
+            std::round(factor * e->delta_discrete), e->source);
    }
 }

@@ -662,7 +667,7 @@ void CInputManager::newMouse(wlr_input_device* mouse, bool virt) {
        Debug::log(LOG, "New mouse has libinput sens %.2f (%.2f) with accel profile %i (%i)", libinput_device_config_accel_get_speed(LIBINPUTDEV), libinput_device_config_accel_get_default_speed(LIBINPUTDEV), libinput_device_config_accel_get_profile(LIBINPUTDEV), libinput_device_config_accel_get_default_profile(LIBINPUTDEV));
    }

-    setMouseConfigs();
+    setPointerConfigs();

    PMOUSE->hyprListener_destroyMouse.initCallback(&mouse->events.destroy, &Events::listener_destroyMouse, PMOUSE, "Mouse");

@@ -675,11 +680,11 @@ void CInputManager::newMouse(wlr_input_device* mouse, bool virt) {
    Debug::log(LOG, "New mouse created, pointer WLR: %x", mouse);
 }

-void CInputManager::setMouseConfigs() {
+void CInputManager::setPointerConfigs() {
    for (auto& m : m_lMice) {
-        const auto PMOUSE = &m;
+        const auto PPOINTER = &m;

-        auto devname = PMOUSE->name;
+        auto devname = PPOINTER->name;
        transform(devname.begin(), devname.end(), devname.begin(), ::tolower);

        const auto HASCONFIG = g_pConfigManager->deviceConfigExists(devname);
@@ -692,6 +697,11 @@ void CInputManager::setMouseConfigs() {
            else
                libinput_device_config_click_set_method(LIBINPUTDEV, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);

+            if ((HASCONFIG ? g_pConfigManager->getDeviceInt(devname, "left_handed") : g_pConfigManager->getInt("input:left_handed")) == 0)
+                libinput_device_config_left_handed_set(LIBINPUTDEV, 0);
+            else
+                libinput_device_config_left_handed_set(LIBINPUTDEV, 1);
+
            if (libinput_device_config_middle_emulation_is_available(LIBINPUTDEV)) {  // middleclick on r+l mouse button pressed
                if ((HASCONFIG ? g_pConfigManager->getDeviceInt(devname, "middle_button_emulation") : g_pConfigManager->getInt("input:touchpad:middle_button_emulation")) == 1)
                    libinput_device_config_middle_emulation_set_enabled(LIBINPUTDEV, LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
@@ -699,6 +709,21 @@ void CInputManager::setMouseConfigs() {
                    libinput_device_config_middle_emulation_set_enabled(LIBINPUTDEV, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
            }

+            const auto SCROLLMETHOD = HASCONFIG ? g_pConfigManager->getDeviceString(devname, "scroll_method") : g_pConfigManager->getString("input:scroll_method");
+            if (SCROLLMETHOD == "" || SCROLLMETHOD == STRVAL_EMPTY) {
+                libinput_device_config_scroll_set_method(LIBINPUTDEV, libinput_device_config_scroll_get_default_method(LIBINPUTDEV));
+            } else if (SCROLLMETHOD == "no_scroll") {
+                libinput_device_config_scroll_set_method(LIBINPUTDEV, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
+            } else if (SCROLLMETHOD == "2fg") {
+                libinput_device_config_scroll_set_method(LIBINPUTDEV, LIBINPUT_CONFIG_SCROLL_2FG);
+            } else if (SCROLLMETHOD == "edge") {
+                libinput_device_config_scroll_set_method(LIBINPUTDEV, LIBINPUT_CONFIG_SCROLL_EDGE);
+            } else if (SCROLLMETHOD == "on_button_down") {
+                libinput_device_config_scroll_set_method(LIBINPUTDEV, LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
+            } else {
+                Debug::log(WARN, "Scroll method unknown");
+            }
+
            if ((HASCONFIG ? g_pConfigManager->getDeviceInt(devname, "drag_lock") : g_pConfigManager->getInt("input:touchpad:drag_lock")) == 0)
                libinput_device_config_tap_set_drag_lock_enabled(LIBINPUTDEV, LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
            else
@@ -723,10 +748,20 @@ void CInputManager::setMouseConfigs() {
            }

            const auto LIBINPUTSENS = std::clamp((HASCONFIG ? g_pConfigManager->getDeviceFloat(devname, "sensitivity") : g_pConfigManager->getFloat("input:sensitivity")), -1.f, 1.f);
-
-            libinput_device_config_accel_set_profile(LIBINPUTDEV, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
            libinput_device_config_accel_set_speed(LIBINPUTDEV, LIBINPUTSENS);

+            const auto ACCELPROFILE = HASCONFIG ? g_pConfigManager->getDeviceString(devname, "accel_profile") : g_pConfigManager->getString("input:accel_profile");
+
+            if (ACCELPROFILE == "" || ACCELPROFILE == STRVAL_EMPTY) {
+                libinput_device_config_accel_set_profile(LIBINPUTDEV, libinput_device_config_accel_get_default_profile(LIBINPUTDEV));
+            } else if (ACCELPROFILE == "adaptive") {
+                libinput_device_config_accel_set_profile(LIBINPUTDEV, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
+            } else if (ACCELPROFILE == "flat") {
+                libinput_device_config_accel_set_profile(LIBINPUTDEV, LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
+            } else {
+                Debug::log(WARN, "Unknown acceleration profile, falling back to default");
+            } 
+
            Debug::log(LOG, "Applied config to mouse %s, sens %.2f", m.name.c_str(), LIBINPUTSENS);
        }
    }
@@ -1006,3 +1041,29 @@ void CInputManager::destroyTouchDevice(STouchDevice* pDevice) {

    m_lTouchDevices.remove(*pDevice);
 }
+
+void CInputManager::newSwitch(wlr_input_device* pDevice) {
+    const auto PNEWDEV = &m_lSwitches.emplace_back();
+    PNEWDEV->pWlrDevice = pDevice;
+
+    Debug::log(LOG, "New switch with name \"%s\" added", pDevice->name);
+
+    PNEWDEV->hyprListener_destroy.initCallback(&pDevice->events.destroy, [&](void* owner, void* data) {
+        destroySwitch((SSwitchDevice*)owner);
+    }, PNEWDEV, "SwitchDevice");
+
+    const auto PSWITCH = wlr_switch_from_input_device(pDevice);
+
+    PNEWDEV->hyprListener_toggle.initCallback(&PSWITCH->events.toggle, [&](void* owner, void* data) {
+        const auto PDEVICE = (SSwitchDevice*)owner;
+        const auto NAME = std::string(PDEVICE->pWlrDevice->name);
+
+        Debug::log(LOG, "Switch %s fired, triggering binds.", NAME.c_str());
+
+        g_pKeybindManager->onSwitchEvent(NAME);
+    }, PNEWDEV, "SwitchDevice");
+}
+
+void CInputManager::destroySwitch(SSwitchDevice* pDevice) {
+    m_lSwitches.remove(*pDevice);
+}
--- a/src/managers/input/InputManager.hpp
+++ b/src/managers/input/InputManager.hpp
@@ -37,9 +37,11 @@ public:
    void            newVirtualKeyboard(wlr_input_device*);
    void            newMouse(wlr_input_device*, bool virt = false);
    void            newTouchDevice(wlr_input_device*);
+    void            newSwitch(wlr_input_device*);
    void            destroyTouchDevice(STouchDevice*);
    void            destroyKeyboard(SKeyboard*);
    void            destroyMouse(wlr_input_device*);
+    void            destroySwitch(SSwitchDevice*);

    void            constrainMouse(SMouse*, wlr_pointer_constraint_v1*);
    void            recheckConstraint(SMouse*);
@@ -50,7 +52,7 @@ public:
    void            refocus();

    void            setKeyboardLayout();
-    void            setMouseConfigs();
+    void            setPointerConfigs();

    void            updateDragIcon();
    void            updateCapabilities(wlr_input_device*);
@@ -89,6 +91,9 @@ public:
    // Touch devices
    std::list<STouchDevice> m_lTouchDevices;

+    // Switches
+    std::list<SSwitchDevice> m_lSwitches;
+
    void            newTabletTool(wlr_input_device*);
    void            newTabletPad(wlr_input_device*);
    void            focusTablet(STablet*, wlr_tablet_tool*, bool motion = false);
--- a/src/managers/input/Swipe.cpp
+++ b/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);
    }
--- a/src/managers/input/Touch.cpp
+++ b/src/managers/input/Touch.cpp
@@ -2,7 +2,10 @@
 #include "../../Compositor.hpp"

 void CInputManager::onTouchDown(wlr_touch_down_event* e) {
-    wlr_cursor_warp(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, g_pCompositor->m_pLastMonitor->vecPosition.x + e->x * g_pCompositor->m_pLastMonitor->vecSize.x, g_pCompositor->m_pLastMonitor->vecPosition.y + e->y * g_pCompositor->m_pLastMonitor->vecSize.y);
+    auto PMONITOR = g_pCompositor->getMonitorFromName(e->touch->output_name ? e->touch->output_name : "");
+    PMONITOR = PMONITOR ? PMONITOR : g_pCompositor->m_pLastMonitor;
+
+    wlr_cursor_warp(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, PMONITOR->vecPosition.x + e->x * PMONITOR->vecSize.x, PMONITOR->vecPosition.y + e->y * PMONITOR->vecSize.y);

    refocus();

--- a/src/render/OpenGL.cpp
+++ b/src/render/OpenGL.cpp
@@ -1,3 +1,4 @@
+#include "Shaders.hpp"
 #include "OpenGL.hpp"
 #include "../Compositor.hpp"
 #include "../helpers/MiscFunctions.hpp"
@@ -150,9 +151,7 @@ void CHyprOpenGLImpl::initShaders() {
    m_RenderData.pCurrentMonData->m_shQUAD.proj = glGetUniformLocation(prog, "proj");
    m_RenderData.pCurrentMonData->m_shQUAD.color = glGetUniformLocation(prog, "color");
    m_RenderData.pCurrentMonData->m_shQUAD.posAttrib = glGetAttribLocation(prog, "pos");
-    m_RenderData.pCurrentMonData->m_shQUAD.texAttrib = glGetAttribLocation(prog, "texcoord");
    m_RenderData.pCurrentMonData->m_shQUAD.topLeft = glGetUniformLocation(prog, "topLeft");
-    m_RenderData.pCurrentMonData->m_shQUAD.bottomRight = glGetUniformLocation(prog, "bottomRight");
    m_RenderData.pCurrentMonData->m_shQUAD.fullSize = glGetUniformLocation(prog, "fullSize");
    m_RenderData.pCurrentMonData->m_shQUAD.radius = glGetUniformLocation(prog, "radius");
    m_RenderData.pCurrentMonData->m_shQUAD.primitiveMultisample = glGetUniformLocation(prog, "primitiveMultisample");
@@ -166,7 +165,6 @@ void CHyprOpenGLImpl::initShaders() {
    m_RenderData.pCurrentMonData->m_shRGBA.posAttrib = glGetAttribLocation(prog, "pos");
    m_RenderData.pCurrentMonData->m_shRGBA.discardOpaque = glGetUniformLocation(prog, "discardOpaque");
    m_RenderData.pCurrentMonData->m_shRGBA.topLeft = glGetUniformLocation(prog, "topLeft");
-    m_RenderData.pCurrentMonData->m_shRGBA.bottomRight = glGetUniformLocation(prog, "bottomRight");
    m_RenderData.pCurrentMonData->m_shRGBA.fullSize = glGetUniformLocation(prog, "fullSize");
    m_RenderData.pCurrentMonData->m_shRGBA.radius = glGetUniformLocation(prog, "radius");
    m_RenderData.pCurrentMonData->m_shRGBA.primitiveMultisample = glGetUniformLocation(prog, "primitiveMultisample");
@@ -182,7 +180,6 @@ void CHyprOpenGLImpl::initShaders() {
    m_RenderData.pCurrentMonData->m_shRGBX.posAttrib = glGetAttribLocation(prog, "pos");
    m_RenderData.pCurrentMonData->m_shRGBX.discardOpaque = glGetUniformLocation(prog, "discardOpaque");
    m_RenderData.pCurrentMonData->m_shRGBX.topLeft = glGetUniformLocation(prog, "topLeft");
-    m_RenderData.pCurrentMonData->m_shRGBX.bottomRight = glGetUniformLocation(prog, "bottomRight");
    m_RenderData.pCurrentMonData->m_shRGBX.fullSize = glGetUniformLocation(prog, "fullSize");
    m_RenderData.pCurrentMonData->m_shRGBX.radius = glGetUniformLocation(prog, "radius");
    m_RenderData.pCurrentMonData->m_shRGBX.primitiveMultisample = glGetUniformLocation(prog, "primitiveMultisample");
@@ -198,7 +195,6 @@ void CHyprOpenGLImpl::initShaders() {
    m_RenderData.pCurrentMonData->m_shEXT.texAttrib = glGetAttribLocation(prog, "texcoord");
    m_RenderData.pCurrentMonData->m_shEXT.discardOpaque = glGetUniformLocation(prog, "discardOpaque");
    m_RenderData.pCurrentMonData->m_shEXT.topLeft = glGetUniformLocation(prog, "topLeft");
-    m_RenderData.pCurrentMonData->m_shEXT.bottomRight = glGetUniformLocation(prog, "bottomRight");
    m_RenderData.pCurrentMonData->m_shEXT.fullSize = glGetUniformLocation(prog, "fullSize");
    m_RenderData.pCurrentMonData->m_shEXT.radius = glGetUniformLocation(prog, "radius");
    m_RenderData.pCurrentMonData->m_shEXT.primitiveMultisample = glGetUniformLocation(prog, "primitiveMultisample");
@@ -314,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) {
@@ -338,15 +335,17 @@ 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(round, round);
-    const auto BOTTOMRIGHT = Vector2D(box->width - round, box->height - round);
-    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;

    // Rounded corners
    glUniform2f(m_RenderData.pCurrentMonData->m_shQUAD.topLeft, (float)TOPLEFT.x, (float)TOPLEFT.y);
-    glUniform2f(m_RenderData.pCurrentMonData->m_shQUAD.bottomRight, (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
    glUniform2f(m_RenderData.pCurrentMonData->m_shQUAD.fullSize, (float)FULLSIZE.x, (float)FULLSIZE.y);
    glUniform1f(m_RenderData.pCurrentMonData->m_shQUAD.radius, round);
    glUniform1i(m_RenderData.pCurrentMonData->m_shQUAD.primitiveMultisample, (int)(*PMULTISAMPLEEDGES == 1 && round != 0));
@@ -357,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);
@@ -389,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
@@ -433,18 +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, (float)TOPLEFT.x, (float)TOPLEFT.y);
-    glUniform2f(shader->bottomRight, (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
-    glUniform2f(shader->fullSize, (float)FULLSIZE.x, (float)FULLSIZE.y);
+    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));

@@ -474,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);
@@ -649,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;
@@ -682,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);
@@ -742,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);
@@ -775,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;

@@ -839,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);
@@ -1040,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);
@@ -1081,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);
@@ -1225,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);
 }
--- a/src/render/OpenGL.hpp
+++ b/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 {
--- a/src/render/Renderer.cpp
+++ b/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);

--- a/src/render/decorations/CHyprDropShadowDecoration.cpp
+++ b/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

--- a/src/render/decorations/CHyprDropShadowDecoration.hpp
+++ b/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();

--- a/src/render/decorations/CHyprGroupBarDecoration.cpp
+++ b/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;
--- a/src/render/decorations/CHyprGroupBarDecoration.hpp
+++ b/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();

--- a/src/render/decorations/IHyprWindowDecoration.hpp
+++ b/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;

--- a/src/render/shaders/Textures.hpp
+++ b/src/render/shaders/Textures.hpp
@@ -3,140 +3,38 @@
 #include <string>

 inline static constexpr auto ROUNDED_SHADER_FUNC = [](const std::string colorVarName) -> std::string {
-    return R"#(
-		if (pixCoord[0] < topLeft[0]) {
-		// we're close left
-		if (pixCoord[1] < topLeft[1]) {
-			// top
+        return R"#(

-			if (ignoreCorners == 1) {
-				discard;
-				return;
-			}
+    // branchless baby!
+    highp vec2 pixCoord = vec2(gl_FragCoord);
+    pixCoord -= topLeft + fullSize * 0.5;
+    pixCoord *= vec2(lessThan(pixCoord, vec2(0.0))) * -2.0 + 1.0;
+    pixCoord -= fullSize * 0.5 - radius;

-			float topLeftDistance = distance(topLeft, pixCoord);
+    if (pixCoord.x + pixCoord.y > radius) {

-			if (topLeftDistance > radius - 1.0) {
-				if (primitiveMultisample == 0 && topLeftDistance > radius) {
-					discard;
-					return;
-				} else if (primitiveMultisample == 1) {
-					float distances = 0.0;
-					if (distance(topLeft, pixCoord + vec2(0.25, 0.25)) < radius) { distances = distances + 1.0; }
-					if (distance(topLeft, pixCoord + vec2(0.75, 0.25)) < radius) { distances = distances + 1.0; }
-					if (distance(topLeft, pixCoord + vec2(0.25, 0.75)) < radius) { distances = distances + 1.0; }
-					if (distance(topLeft, pixCoord + vec2(0.75, 0.75)) < radius) { distances = distances + 1.0; }
+	float dist = length(pixCoord);

-					if (distances == 0.0) {
-						discard;
-						return;
-					}
+	if (dist > radius)
+	    discard;

-					distances = distances / 4.0;
+	if (primitiveMultisample == 1 && dist > radius - 1.0) {
+	    float distances = 0.0;
+	    distances += float(length(pixCoord + vec2(0.25, 0.25)) < radius);
+	    distances += float(length(pixCoord + vec2(0.75, 0.25)) < radius);
+	    distances += float(length(pixCoord + vec2(0.25, 0.75)) < radius);
+	    distances += float(length(pixCoord + vec2(0.75, 0.75)) < radius);

-					)#" + colorVarName + R"#( = )#" + colorVarName + R"#( * distances;
-				}
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
+	    if (distances == 0.0)
+		discard;

-			if (ignoreCorners == 1) {
-				discard;
-				return;
-			}
+	    distances /= 4.0;

-			float topLeftDistance = distance(vec2(topLeft[0], bottomRight[1]), pixCoord);
+	    )#" + colorVarName + R"#( = )#" + colorVarName + R"#( * distances;
+        }

-			if (topLeftDistance > radius - 1.0) {
-				if (primitiveMultisample == 0 && topLeftDistance > radius) {
-					discard;
-					return;
-				} else if (primitiveMultisample == 1) {
-					float distances = 0.0;
-					if (distance(vec2(topLeft[0], bottomRight[1]), pixCoord + vec2(0.25, 0.25)) < radius) { distances = distances + 1.0; }
-					if (distance(vec2(topLeft[0], bottomRight[1]), pixCoord + vec2(0.75, 0.25)) < radius) { distances = distances + 1.0; }
-					if (distance(vec2(topLeft[0], bottomRight[1]), pixCoord + vec2(0.25, 0.75)) < radius) { distances = distances + 1.0; }
-					if (distance(vec2(topLeft[0], bottomRight[1]), pixCoord + vec2(0.75, 0.75)) < radius) { distances = distances + 1.0; }
-
-					if (distances == 0.0) {
-						discard;
-						return;
-					}
-
-					distances = distances / 4.0;
-
-					)#" + colorVarName + R"#( = )#" + colorVarName + R"#( * distances;
-				}
-			}
-		}
-	}
-	else if (pixCoord[0] > bottomRight[0]) {
-		// we're close right
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-
-			if (ignoreCorners == 1) {
-				discard;
-				return;
-			}
-
-			float topLeftDistance = distance(vec2(bottomRight[0], topLeft[1]), pixCoord);
-
-			if (topLeftDistance > radius - 1.0) {
-				if (primitiveMultisample == 0 && topLeftDistance > radius) {
-					discard;
-					return;
-				} else if (primitiveMultisample == 1) {
-					float distances = 0.0;
-					if (distance(vec2(bottomRight[0], topLeft[1]), pixCoord + vec2(0.25, 0.25)) < radius) { distances = distances + 1.0; }
-					if (distance(vec2(bottomRight[0], topLeft[1]), pixCoord + vec2(0.75, 0.25)) < radius) { distances = distances + 1.0; }
-					if (distance(vec2(bottomRight[0], topLeft[1]), pixCoord + vec2(0.25, 0.75)) < radius) { distances = distances + 1.0; }
-					if (distance(vec2(bottomRight[0], topLeft[1]), pixCoord + vec2(0.75, 0.75)) < radius) { distances = distances + 1.0; }
-
-					if (distances == 0.0) {
-						discard;
-						return;
-					}
-
-					distances = distances / 4.0;
-
-					)#" + colorVarName + R"#( = )#" + colorVarName + R"#( * distances;
-				}
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-
-			if (ignoreCorners == 1) {
-				discard;
-				return;
-			}
-
-			float topLeftDistance = distance(bottomRight, pixCoord);
-
-			if (topLeftDistance > radius - 1.0) {
-				if (primitiveMultisample == 0 && topLeftDistance > radius) {
-					discard;
-					return;
-				} else if (primitiveMultisample == 1) {
-					float distances = 0.0;
-					if (distance(bottomRight, pixCoord + vec2(0.25, 0.25)) < radius) { distances = distances + 1.0; }
-					if (distance(bottomRight, pixCoord + vec2(0.75, 0.25)) < radius) { distances = distances + 1.0; }
-					if (distance(bottomRight, pixCoord + vec2(0.25, 0.75)) < radius) { distances = distances + 1.0; }
-					if (distance(bottomRight, pixCoord + vec2(0.75, 0.75)) < radius) { distances = distances + 1.0; }
-
-					if (distances == 0.0) {
-						discard;
-						return;
-					}
-
-					distances = distances / 4.0;
-
-					)#" + colorVarName + R"#( = )#" + colorVarName + R"#( * distances;
-				}
-			}
-		}
-	}
-	)#";
+    }
+)#";
 };

 inline const std::string QUADVERTSRC = R"#(
@@ -156,29 +54,22 @@ void main() {
 inline const std::string QUADFRAGSRC = R"#(
 precision mediump float;
 varying vec4 v_color;
-varying vec2 v_texcoord;

 uniform vec2 topLeft;
-uniform vec2 bottomRight;
 uniform vec2 fullSize;
 uniform float radius;

 uniform int primitiveMultisample;
-uniform int ignoreCorners;

 void main() {
-	if (radius == 0.0) {
-		gl_FragColor = v_color;
-		return;
-	}

-	vec4 pixColor = v_color;
-
-    vec2 pixCoord = fullSize * v_texcoord;
+    vec4 pixColor = v_color;

+    if (radius > 0.0) {
 	)#" + ROUNDED_SHADER_FUNC("pixColor") + R"#(
+    }

-	gl_FragColor = pixColor;
+    gl_FragColor = pixColor;
 })#";

 inline const std::string TEXVERTSRC = R"#(
@@ -188,8 +79,8 @@ attribute vec2 texcoord;
 varying vec2 v_texcoord;

 void main() {
-	gl_Position = vec4(proj * vec3(pos, 1.0), 1.0);
-	v_texcoord = texcoord;
+    gl_Position = vec4(proj * vec3(pos, 1.0), 1.0);
+    v_texcoord = texcoord;
 })#";

 inline const std::string TEXFRAGSRCRGBA = R"#(
@@ -199,7 +90,6 @@ uniform sampler2D tex;
 uniform float alpha;

 uniform vec2 topLeft;
-uniform vec2 bottomRight;
 uniform vec2 fullSize;
 uniform float radius;

@@ -209,29 +99,24 @@ uniform int applyTint;
 uniform vec3 tint;

 uniform int primitiveMultisample;
-uniform int ignoreCorners;

 void main() {

-	vec4 pixColor = texture2D(tex, v_texcoord);
+    vec4 pixColor = texture2D(tex, v_texcoord);

-	if (discardOpaque == 1 && pixColor[3] * alpha == 1.0) {
-		discard;
-		return;
-	}
+    if (discardOpaque == 1 && pixColor[3] * alpha == 1.0)
+	discard;

-	if (applyTint == 1) {
-		pixColor[0] = pixColor[0] * tint[0];
-		pixColor[1] = pixColor[1] * tint[1];
-		pixColor[2] = pixColor[2] * tint[2];
-	}

-	vec2 pixCoord = fullSize * v_texcoord;
+    if (applyTint == 1) {
+	pixColor[0] = pixColor[0] * tint[0];
+	pixColor[1] = pixColor[1] * tint[1];
+	pixColor[2] = pixColor[2] * tint[2];
+    }

-	)#" + ROUNDED_SHADER_FUNC("pixColor") +
-                                          R"#(
+    )#" + ROUNDED_SHADER_FUNC("pixColor") + R"#(

-	gl_FragColor = pixColor * alpha;
+    gl_FragColor = pixColor * alpha;
 })#";

 inline const std::string TEXFRAGSRCRGBX = R"#(
@@ -241,7 +126,6 @@ uniform sampler2D tex;
 uniform float alpha;

 uniform vec2 topLeft;
-uniform vec2 bottomRight;
 uniform vec2 fullSize;
 uniform float radius;

@@ -251,29 +135,23 @@ uniform int applyTint;
 uniform vec3 tint;

 uniform int primitiveMultisample;
-uniform int ignoreCorners;

 void main() {

-	if (discardOpaque == 1 && alpha == 1.0) {
-		discard;
-		return;
-	}
+    if (discardOpaque == 1 && alpha == 1.0)
+	discard;

-	vec4 pixColor = vec4(texture2D(tex, v_texcoord).rgb, 1.0);
+    vec4 pixColor = vec4(texture2D(tex, v_texcoord).rgb, 1.0);

-	if (applyTint == 1) {
-		pixColor[0] = pixColor[0] * tint[0];
-		pixColor[1] = pixColor[1] * tint[1];
-		pixColor[2] = pixColor[2] * tint[2];
-	}
+    if (applyTint == 1) {
+	pixColor[0] = pixColor[0] * tint[0];
+	pixColor[1] = pixColor[1] * tint[1];
+	pixColor[2] = pixColor[2] * tint[2];
+    }

-	vec2 pixCoord = fullSize * v_texcoord;
+    )#" + ROUNDED_SHADER_FUNC("pixColor") + R"#(

-	)#" + ROUNDED_SHADER_FUNC("pixColor") +
-                                          R"#(
-
-	gl_FragColor = pixColor * alpha;
+    gl_FragColor = pixColor * alpha;
 })#";

 inline const std::string FRAGBLUR1 = R"#(
@@ -286,13 +164,14 @@ uniform float radius;
 uniform vec2 halfpixel;

 void main() {
-	vec2 uv = v_texcoord * 2.0;
+    vec2 uv = v_texcoord * 2.0;

    vec4 sum = texture2D(tex, uv) * 4.0;
    sum += texture2D(tex, uv - halfpixel.xy * radius);
    sum += texture2D(tex, uv + halfpixel.xy * radius);
    sum += texture2D(tex, uv + vec2(halfpixel.x, -halfpixel.y) * radius);
    sum += texture2D(tex, uv - vec2(halfpixel.x, -halfpixel.y) * radius);
+
    gl_FragColor = sum / 8.0;
 }
 )#";
@@ -307,7 +186,7 @@ uniform float radius;
 uniform vec2 halfpixel;

 void main() {
-	vec2 uv = v_texcoord / 2.0;
+    vec2 uv = v_texcoord / 2.0;

    vec4 sum = texture2D(tex, uv + vec2(-halfpixel.x * 2.0, 0.0) * radius);

@@ -332,7 +211,6 @@ uniform samplerExternalOES texture0;
 uniform float alpha;

 uniform vec2 topLeft;
-uniform vec2 bottomRight;
 uniform vec2 fullSize;
 uniform float radius;

@@ -342,27 +220,22 @@ uniform int applyTint;
 uniform vec3 tint;

 uniform int primitiveMultisample;
-uniform int ignoreCorners;

 void main() {

-	vec4 pixColor = texture2D(texture0, v_texcoord);
+    vec4 pixColor = texture2D(texture0, v_texcoord);

-	if (discardOpaque == 1 && pixColor[3] * alpha == 1.0) {
-		discard;
-		return;
-	}
+    if (discardOpaque == 1 && pixColor[3] * alpha == 1.0)
+	discard;

-	if (applyTint == 1) {
-		pixColor[0] = pixColor[0] * tint[0];
-		pixColor[1] = pixColor[1] * tint[1];
-		pixColor[2] = pixColor[2] * tint[2];
-	}
+    if (applyTint == 1) {
+	pixColor[0] = pixColor[0] * tint[0];
+	pixColor[1] = pixColor[1] * tint[1];
+	pixColor[2] = pixColor[2] * tint[2];
+    }

-	vec2 pixCoord = fullSize * v_texcoord;
+    )#" + ROUNDED_SHADER_FUNC("pixColor") + R"#(

-	)#" + ROUNDED_SHADER_FUNC("pixColor") +
-                                         R"#(
-
-	gl_FragColor = pixColor * alpha;
-})#";
+    gl_FragColor = pixColor * alpha;
+}
+)#";
--- a/subprojects/wlroots
+++ b/subprojects/wlroots
Author	SHA1	Message	Date
vaxerski	cb687c208c	[gha] bump flake inputs	2022-10-09 20:30:56 +00:00
vaxerski	945b4d7139	update wlroots dep	2022-10-09 21:29:54 +01:00
vaxerski	881f828250	better subsurface handling on unmaps	2022-10-09 17:40:30 +01:00
vaxerski	0743dab3f0	use popup base surface instead of subsurface for addPopupGlobalCoords	2022-10-09 17:10:20 +01:00
vaxerski	496e37d044	ensure texture safety in clearWithTex()	2022-10-09 17:02:39 +01:00
Vaxry	1263bd5dcb	Merge pull request #817 from Dickby/transform_box_in_renderRectWithDamage inverse_transform the box in renderRectWithDamage.	2022-10-09 09:46:22 +01:00
Felix Dick	9ee78b1a92	inverse_transform the box in renderRectWithDamage.	2022-10-09 01:58:00 +02:00
vaxerski	90f2259f5e	[gha] bump flake inputs	2022-10-08 17:01:31 +00:00
vaxerski	948f4978e7	update wlroots dep	2022-10-08 18:00:20 +01:00
Vaxry	fe4a97f245	Merge pull request #794 from Dickby/pixman_early_outs Check earlier if pixman_region is empty in some places.	2022-10-08 12:00:17 +01:00
Felix Dick	2f3528c076	Check earlier if pixman regions are empty.	2022-10-08 11:20:04 +02:00
vaxerski	1964bcb13f	add open/close layer events	2022-10-07 22:25:00 +01:00
Vaxry	4b779ac142	Merge pull request #811 from Dickby/add_missing_pixman_region32_fini Add missing pixman_region32_fini.	2022-10-07 22:20:35 +01:00
vaxerski	abc2d442dd	fix a VRAM leak in destroyMonitorResources	2022-10-07 22:19:23 +01:00
Felix Dick	b64f1fc5c4	Add missing pixman_region32_fini.	2022-10-07 23:11:20 +02:00
vaxerski	33d264eaa7	release all fbs in destroyMonitorResources	2022-10-07 21:13:28 +01:00
Vaxry	5e3b8c3233	Merge pull request #807 from Dickby/fix_monitor_transforms Transform the box data send to texture shaders.	2022-10-07 20:12:28 +01:00
Felix Dick	bbdfb7853d	Transform the box data send to texture shaders.	2022-10-07 20:55:41 +02:00
vaxerski	a19b152e4a	make swipe respect slidevert	2022-10-07 16:52:53 +01:00
vaxerski	1468001d3b	offset floating windows out of bounds on ws anims	2022-10-07 12:34:54 +01:00
vaxerski	7faa3c367d	Added clipping support, clip windows on slide anim	2022-10-07 10:43:51 +01:00
vaxerski	fd379db846	swallow improvements	2022-10-07 09:46:01 +01:00
vaxerski	28a6e0ce31	[gha] bump flake inputs	2022-10-06 21:09:10 +00:00
vaxerski	af7d60b3f8	revert wlroots ver to fix critical gpu issue	2022-10-06 22:08:08 +01:00
Vaxry	c4487534d2	Merge pull request #801 from fufexan/scrollfactor Add input:touchpad:scroll_factor	2022-10-06 21:26:11 +01:00
Mihai Fufezan	e4820d1c71	Add input:touchpad:scroll_factor	2022-10-06 22:47:05 +03:00
vaxerski	b4a8efc1a7	fix naming when workspace back and forth	2022-10-06 20:40:58 +01:00
vaxerski	9480c0fb90	fix workspace previous with multi-mon ws moves	2022-10-06 20:18:49 +01:00
vaxerski	f901c60da5	return true on vt switch keysyms to avoid printing stuff	2022-10-06 19:31:32 +01:00
vaxerski	922e978f56	reset sigmask on fork	2022-10-06 19:02:03 +01:00
vaxerski	0508c7d384	more monitor checks for shutdown:	2022-10-06 18:43:50 +01:00
vaxerski	ee3b770cfd	more checks in pid gathering	2022-10-06 17:58:38 +01:00
Vaxry	a29af89545	Merge pull request #793 from Dickby/fix_compiler_warnings Fix compiler warnings.	2022-10-06 12:54:04 +01:00
Felix Dick	552c4b7361	Fix compiler warnings.	2022-10-06 13:42:52 +02:00
vaxerski	d7ef19e2e7	map touch to the correct output	2022-10-06 09:26:05 +01:00
vaxerski	190ddb5697	added a noanim rule	2022-10-06 09:16:40 +01:00
vaxerski	095688712d	add minsize rule	2022-10-06 09:09:58 +01:00
vaxerski	d264fbd36a	fix string corruption in hyprctl monitors -j	2022-10-06 09:04:46 +01:00
vaxerski	e4527c6b60	use goalv in clientsRequest	2022-10-06 08:54:09 +01:00
Vaxry	32e8eda40a	Merge pull request #787 from fufexan/libinput Add accel profile and scroll method	2022-10-05 21:58:40 +01:00
Mihai Fufezan	477ad2dd82	Add accel profile and scroll method	2022-10-05 23:51:08 +03:00
vaxerski	e90c5c6347	fix tty switch freeze	2022-10-05 21:41:27 +01:00
vaxerski	11ce468996	add dpms status info in hyprctl	2022-10-05 18:14:11 +01:00
vaxerski	9c5023ab1a	monitor desc improvements	2022-10-05 17:38:36 +01:00
vaxerski	0e4a894edb	add dpms per output	2022-10-05 10:31:47 +01:00
vaxerski	71e2562a41	add desc: to monitor rules	2022-10-05 10:22:33 +01:00
Vaxry	9153a81090	Merge pull request #781 from Dickby/fix_left_handed Fix getDeviceInt string arg "input:left_handed"	2022-10-05 08:06:38 +01:00
Felix Dick	0d7f6eac9e	Merge branch 'make_TTY_unsigned' into fix_left_handed	2022-10-05 04:51:48 +02:00
Felix Dick	6d46ed4011	Fix getDeviceInt string arg "input:left_handed"	2022-10-05 04:25:26 +02:00
Felix Dick	f825b87c2a	Fix compiler warnig comparing signed and unsigned integers.	2022-10-05 02:42:51 +02:00
vaxerski	44da575ea8	[gha] bump flake inputs	2022-10-04 22:25:26 +00:00
vaxerski	a587909fd5	update wlroots dep	2022-10-04 23:24:31 +01:00
vaxerski	fd81ba5a4f	[gha] bump flake inputs	2022-10-04 22:22:12 +00:00
Vaxry	934f81c93d	Merge pull request #777 from Dickby/fix_shader_error Remove texcoord from QUADFRAGSRC.	2022-10-04 23:20:52 +01:00
Felix Dick	e8be1507ef	Remove texcoord from QUADFRAGSRC. texcoord is unused in the rounding part of the textureshaders. QUADFRAGSRC isn't using that variable inside the non rounding code. Because of that opengl optimizes that variable out, and is complaining if glGetAttribLocation is called on it.	2022-10-05 00:04:32 +02:00
vaxerski	60c414ccad	add left_handed config for input	2022-10-04 21:46:41 +01:00
vaxerski	0d702b556d	Add switch device handling and binds	2022-10-04 20:07:21 +01:00
vaxerski	9bbae5b8e2	ignore VT switches to current vt	2022-10-04 16:53:09 +01:00
vaxerski	719a5b4f0b	use vectorToWindowIdeal in mouse binds	2022-10-04 16:08:55 +01:00
Vaxry	7bdfdaa28a	Merge pull request #742 from Dickby/rework_rounding_shader Rework rounding shader	2022-10-04 14:17:16 +01:00
vaxerski	a80e0cecfe	fixes to window swallowing with same pid	2022-10-04 11:16:49 +01:00
vaxerski	3e3f6aef5e	additional logic for identical pid swallowing	2022-10-04 10:17:10 +01:00
Vaxry	996938b7e7	Merge pull request #773 from lylac-1/main focusedmon event check change	2022-10-04 10:04:10 +01:00
lylac	f9325b1655	focusedmon event check change Compare PLASTWINDOW & PWINDOWTOCHANGETO m_iMonitorID's instead of PWINDOWTOCHANGETO->m_iMonitorID & g_pCompositor->m_pLastMonitor->ID	2022-10-04 18:19:14 +13:00
vaxerski	63dfe305dd	log GPU info for debugging	2022-10-03 23:10:15 +01:00
Mihai Fufezan	ec0c6fa22a	Nix & meson: 0.14.0 -> 0.15.0	2022-10-04 00:51:49 +03:00
Felix Dick	c6333ba796	Remove unused ignoreCorners variable from texture shaders.	2022-10-01 03:30:58 +02:00
Felix Dick	6fe103cf06	Cut the number of pixels that call length() in half.	2022-10-01 03:14:13 +02:00
Felix Dick	71733f68ef	Merge branch 'fix_rounding_in_size_changing_windows' into rework_rounding_shader	2022-10-01 01:35:13 +02:00
Felix Dick	d867d42366	Merge branch 'main' into fix_rounding_in_size_changing_windows	2022-09-30 01:38:50 +02:00
Felix Dick	6eb7d00386	Send absolute screen coordinates to texture shaders.	2022-09-29 23:19:56 +02:00
Felix Dick	09268d756f	Merge branch 'main' into rework_rounding_shader	2022-09-29 21:15:08 +02:00
Felix Dick	e5dced8b3f	Merge branch 'main' into fix_rounding_in_size_changing_windows	2022-09-29 21:13:48 +02:00
Felix Dick	b38e7b596f	Don't pass bottomRight to textureShaders compute it within.	2022-09-29 21:10:05 +02:00
Felix Dick	1424539e4d	Merge branch 'main' into rework_rounding_shader	2022-09-29 20:41:39 +02:00
Felix Dick	425b07d1e5	Merge branch 'main' into rework_rounding_shader	2022-09-29 14:24:59 +02:00
Felix Dick	65fb526d5c	Even less branching (taken more or less from the border shader).	2022-09-29 06:56:17 +02:00
Felix Dick	0549aa193f	fixing your shit.	2022-09-28 23:33:18 +02:00
Felix Dick	168a326609	Merge branch 'main' into rework_rounding_shader	2022-09-28 23:11:11 +02:00
Felix Dick	7edbaea23d	Make the rounding texture shaders smaller and more efficient.	2022-09-28 18:40:04 +02:00
Felix Dick	5ff44467d7	Avoid 38 files to compile every time a shader is modified.	2022-09-28 14:48:05 +02:00