Added blur_ignore_opacity

src/Compositor.cpp

@@ -192,6 +192,9 @@ void CCompositor::startCompositor() {
     Debug::log(LOG, "Creating the EventManager!");
     g_pEventManager = std::make_unique<CEventManager>();
     g_pEventManager->startThread();
+
+    Debug::log(LOG, "Creating the HyprDebugOverlay!");
+    g_pDebugOverlay = std::make_unique<CHyprDebugOverlay>();
     //
     //
 

src/Compositor.hpp

@@ -15,6 +15,7 @@
 #include "managers/KeybindManager.hpp"
 #include "managers/AnimationManager.hpp"
 #include "managers/EventManager.hpp"
+#include "debug/HyprDebugOverlay.hpp"
 #include "helpers/Monitor.hpp"
 #include "helpers/Workspace.hpp"
 #include "Window.hpp"

src/Window.hpp

@@ -11,6 +11,7 @@ struct SWindowSpecialRenderData {
 
 struct SWindowAdditionalConfigData {
     std::string animationStyle = "";
+    int rounding = -1; // -1 means no
 };
 
 class CWindow {
@@ -81,6 +82,8 @@ public:
     CAnimatedVariable m_fAlpha;
     bool            m_bFadingOut = false;
     bool            m_bReadyToDelete = false;
+    Vector2D        m_vOriginalClosedPos; // these will be used for calculations later on in
+    Vector2D        m_vOriginalClosedSize; // drawing the closing animations
 
     // For hidden windows and stuff
     bool            m_bHidden = false;

src/config/ConfigManager.cpp

@@ -35,11 +35,13 @@ void CConfigManager::setDefaultVars() {
 
     configValues["debug:int"].intValue = 0;
     configValues["debug:log_damage"].intValue = 0;
+    configValues["debug:overlay"].intValue = 0;
 
     configValues["decoration:rounding"].intValue = 1;
     configValues["decoration:blur"].intValue = 1;
     configValues["decoration:blur_size"].intValue = 8;
     configValues["decoration:blur_passes"].intValue = 1;
+    configValues["decoration:blur_ignore_opacity"].intValue = 0;
     configValues["decoration:active_opacity"].floatValue = 1;
     configValues["decoration:inactive_opacity"].floatValue = 1;
     configValues["decoration:fullscreen_opacity"].floatValue = 1;
@@ -411,6 +413,7 @@ void CConfigManager::handleWindowRule(const std::string& command, const std::str
         && RULE.find("monitor") != 0
         && RULE.find("nofocus") != 0
         && RULE.find("animation") != 0
+        && RULE.find("rounding") != 0
         && RULE.find("workspace") != 0) {
             Debug::log(ERR, "Invalid rule found: %s", RULE.c_str());
             parseError = "Invalid rule found: " + RULE;

src/debug/HyprDebugOverlay.cpp

@@ -0,0 +1,181 @@
+#include "HyprDebugOverlay.hpp"
+#include "../Compositor.hpp"
+
+void CHyprMonitorDebugOverlay::renderData(SMonitor* pMonitor, float µs) {
+    m_dLastRenderTimes.push_back(µs / 1000.f);
+
+    if (m_dLastRenderTimes.size() > (long unsigned int)pMonitor->refreshRate)
+        m_dLastRenderTimes.pop_front();
+
+    if (!m_pMonitor)
+        m_pMonitor = pMonitor;
+}
+
+void CHyprMonitorDebugOverlay::renderDataNoOverlay(SMonitor* pMonitor, float µs) {
+    m_dLastRenderTimesNoOverlay.push_back(µs / 1000.f);
+
+    if (m_dLastRenderTimesNoOverlay.size() > (long unsigned int)pMonitor->refreshRate)
+        m_dLastRenderTimesNoOverlay.pop_front();
+
+    if (!m_pMonitor)
+        m_pMonitor = pMonitor;
+}
+
+void CHyprMonitorDebugOverlay::frameData(SMonitor* pMonitor) {
+    m_dLastFrametimes.push_back(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - m_tpLastFrame).count() / 1000.f);
+
+    if (m_dLastFrametimes.size() > (long unsigned int)pMonitor->refreshRate)
+        m_dLastFrametimes.pop_front();
+
+    m_tpLastFrame = std::chrono::high_resolution_clock::now();
+
+    if (!m_pMonitor)
+        m_pMonitor = pMonitor;
+}
+
+int CHyprMonitorDebugOverlay::draw(int offset) {
+
+    if (!m_pMonitor)
+        return 0;
+
+    int yOffset = offset;
+    cairo_text_extents_t cairoExtents;
+    float maxX = 0;
+    std::string text = "";
+
+    // get avg fps
+    float avgFrametime = 0;
+    for (auto& ft : m_dLastFrametimes) {
+        avgFrametime += ft;
+    }
+    avgFrametime /= m_dLastFrametimes.size() == 0 ? 1 : m_dLastFrametimes.size();
+
+    float avgRenderTime = 0;
+    for (auto& rt : m_dLastRenderTimes) {
+        avgRenderTime += rt;
+    }
+    avgRenderTime /= m_dLastRenderTimes.size() == 0 ? 1 : m_dLastRenderTimes.size();
+
+    float avgRenderTimeNoOverlay = 0;
+    for (auto& rt : m_dLastRenderTimesNoOverlay) {
+        avgRenderTimeNoOverlay += rt;
+    }
+    avgRenderTimeNoOverlay /= m_dLastRenderTimes.size() == 0 ? 1 : m_dLastRenderTimes.size();
+
+    const float FPS = 1.f / (avgFrametime / 1000.f); // frametimes are in ms
+    const float idealFPS = m_dLastFrametimes.size();
+
+    cairo_select_font_face(g_pDebugOverlay->m_pCairo, "Noto Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+
+    cairo_set_font_size(g_pDebugOverlay->m_pCairo, 10);
+    cairo_set_source_rgba(g_pDebugOverlay->m_pCairo, 1.f, 1.f, 1.f, 1.f);
+
+    yOffset += 10;
+    cairo_move_to(g_pDebugOverlay->m_pCairo, 0, yOffset);
+    text = m_pMonitor->szName;
+    cairo_show_text(g_pDebugOverlay->m_pCairo, text.c_str());
+    cairo_text_extents(g_pDebugOverlay->m_pCairo, text.c_str(), &cairoExtents);
+    if (cairoExtents.width > maxX) maxX = cairoExtents.width;
+
+    cairo_set_font_size(g_pDebugOverlay->m_pCairo, 16);
+
+    if (FPS > idealFPS * 0.95f)
+        cairo_set_source_rgba(g_pDebugOverlay->m_pCairo, 0.2f, 1.f, 0.2f, 1.f);
+    else if (FPS > idealFPS * 0.8f)
+        cairo_set_source_rgba(g_pDebugOverlay->m_pCairo, 1.f, 1.f, 0.2f, 1.f);
+    else
+        cairo_set_source_rgba(g_pDebugOverlay->m_pCairo, 1.f, 0.2f, 0.2f, 1.f);
+
+    yOffset += 17;
+    cairo_move_to(g_pDebugOverlay->m_pCairo, 0, yOffset);
+    text = std::string(std::to_string((int)FPS) + " FPS");
+    cairo_show_text(g_pDebugOverlay->m_pCairo, text.c_str());
+    cairo_text_extents(g_pDebugOverlay->m_pCairo, text.c_str(), &cairoExtents);
+    if (cairoExtents.width > maxX) maxX = cairoExtents.width;
+
+    cairo_set_font_size(g_pDebugOverlay->m_pCairo, 10);
+    cairo_set_source_rgba(g_pDebugOverlay->m_pCairo, 1.f, 1.f, 1.f, 1.f);
+
+    yOffset += 11;
+    cairo_move_to(g_pDebugOverlay->m_pCairo, 0, yOffset);
+    text = std::string("Avg Frametime: " + std::to_string((int)avgFrametime) + "." + std::to_string((int)(avgFrametime * 10.f) % 10) + "ms");
+    cairo_show_text(g_pDebugOverlay->m_pCairo, text.c_str());
+    cairo_text_extents(g_pDebugOverlay->m_pCairo, text.c_str(), &cairoExtents);
+    if (cairoExtents.width > maxX) maxX = cairoExtents.width;
+
+    yOffset += 11;
+    cairo_move_to(g_pDebugOverlay->m_pCairo, 0, yOffset);
+    text = std::string("Avg Rendertime: " + std::to_string((int)avgRenderTime) + "." + std::to_string((int)(avgRenderTime * 10.f) % 10) + "ms");
+    cairo_show_text(g_pDebugOverlay->m_pCairo, text.c_str());
+    cairo_text_extents(g_pDebugOverlay->m_pCairo, text.c_str(), &cairoExtents);
+    if (cairoExtents.width > maxX) maxX = cairoExtents.width;
+
+    yOffset += 11;
+    cairo_move_to(g_pDebugOverlay->m_pCairo, 0, yOffset);
+    text = std::string("Avg Rendertime (no overlay): " + std::to_string((int)avgRenderTimeNoOverlay) + "." + std::to_string((int)(avgRenderTimeNoOverlay * 10.f) % 10) + "ms");
+    cairo_show_text(g_pDebugOverlay->m_pCairo, text.c_str());
+    cairo_text_extents(g_pDebugOverlay->m_pCairo, text.c_str(), &cairoExtents);
+    if (cairoExtents.width > maxX) maxX = cairoExtents.width;
+
+    yOffset += 11;
+
+    g_pHyprRenderer->damageBox(&m_wbLastDrawnBox);
+    m_wbLastDrawnBox = {(int)g_pCompositor->m_lMonitors.front().vecPosition.x, (int)g_pCompositor->m_lMonitors.front().vecPosition.y + offset - 1, (int)maxX + 2, yOffset - offset + 2};
+    g_pHyprRenderer->damageBox(&m_wbLastDrawnBox);
+
+    return yOffset - offset;
+}
+
+void CHyprDebugOverlay::renderData(SMonitor* pMonitor, float µs) {
+    m_mMonitorOverlays[pMonitor].renderData(pMonitor, µs);
+}
+
+void CHyprDebugOverlay::renderDataNoOverlay(SMonitor* pMonitor, float µs) {
+    m_mMonitorOverlays[pMonitor].renderDataNoOverlay(pMonitor, µs);
+}
+
+void CHyprDebugOverlay::frameData(SMonitor* pMonitor) {
+    m_mMonitorOverlays[pMonitor].frameData(pMonitor);
+}
+
+void CHyprDebugOverlay::draw() {
+
+    const auto PMONITOR = &g_pCompositor->m_lMonitors.front();
+
+    if (!m_pCairoSurface || !m_pCairo) {
+        m_pCairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->vecSize.x, PMONITOR->vecSize.y);
+        m_pCairo = cairo_create(m_pCairoSurface);
+    }
+
+    // clear the pixmap
+    cairo_save(m_pCairo);
+    cairo_set_operator(m_pCairo, CAIRO_OPERATOR_CLEAR);
+    cairo_paint(m_pCairo);
+    cairo_restore(m_pCairo);
+
+    // draw the things
+    int offsetY = 0;
+    for (auto& m : g_pCompositor->m_lMonitors) {
+        offsetY += m_mMonitorOverlays[&m].draw(offsetY);
+        offsetY += 5; // for padding between mons
+    }
+
+    cairo_surface_flush(m_pCairoSurface);
+
+    // copy the data to an OpenGL texture we have
+    const auto DATA = cairo_image_surface_get_data(m_pCairoSurface);
+    m_tTexture.allocate();
+    glBindTexture(GL_TEXTURE_2D, m_tTexture.m_iTexID);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+
+#ifndef GLES2
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
+#endif
+
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->vecSize.x, PMONITOR->vecSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
+
+    wlr_box pMonBox = {0,0,PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
+    g_pHyprOpenGL->renderTexture(m_tTexture, &pMonBox, 255.f);
+}

src/debug/HyprDebugOverlay.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "../defines.hpp"
+#include "../helpers/Monitor.hpp"
+#include "../render/Texture.hpp"
+#include <deque>
+#include <cairo/cairo.h>
+#include <unordered_map>
+
+class CHyprMonitorDebugOverlay {
+public:
+    int draw(int offset);
+
+    void renderData(SMonitor* pMonitor, float µs);
+    void renderDataNoOverlay(SMonitor* pMonitor, float µs);
+    void frameData(SMonitor* pMonitor);
+
+private:
+    std::deque<float> m_dLastFrametimes;
+    std::deque<float> m_dLastRenderTimes;
+    std::deque<float> m_dLastRenderTimesNoOverlay;
+    std::chrono::high_resolution_clock::time_point m_tpLastFrame;
+    SMonitor* m_pMonitor = nullptr;
+    wlr_box m_wbLastDrawnBox;
+};
+
+class CHyprDebugOverlay {
+public:
+
+    void draw();
+    void renderData(SMonitor*, float µs);
+    void renderDataNoOverlay(SMonitor*, float µs);
+    void frameData(SMonitor*);
+
+private:
+
+    std::unordered_map<SMonitor*, CHyprMonitorDebugOverlay> m_mMonitorOverlays;
+
+    cairo_surface_t* m_pCairoSurface = nullptr;
+    cairo_t* m_pCairo = nullptr;
+
+    CTexture m_tTexture;
+
+    friend class CHyprMonitorDebugOverlay;
+};
+
+inline std::unique_ptr<CHyprDebugOverlay> g_pDebugOverlay;

src/events/Monitors.cpp

@@ -131,6 +131,15 @@ void Events::listener_newOutput(wl_listener* listener, void* data) {
 void Events::listener_monitorFrame(void* owner, void* data) {
     SMonitor* const PMONITOR = (SMonitor*)owner;
 
+    static std::chrono::high_resolution_clock::time_point startRender = std::chrono::high_resolution_clock::now();
+    static std::chrono::high_resolution_clock::time_point startRenderOverlay = std::chrono::high_resolution_clock::now();
+    static std::chrono::high_resolution_clock::time_point endRenderOverlay = std::chrono::high_resolution_clock::now();
+
+    if (g_pConfigManager->getInt("debug:overlay") == 1) {
+        startRender = std::chrono::high_resolution_clock::now();
+        g_pDebugOverlay->frameData(PMONITOR);
+    }
+
     // Hack: only check when monitor with top hz refreshes, saves a bit of resources.
     // This is for stuff that should be run every frame
     if (PMONITOR->ID == pMostHzMonitor->ID) {
@@ -213,6 +222,17 @@ void Events::listener_monitorFrame(void* owner, void* data) {
 
     g_pHyprRenderer->renderAllClientsForMonitor(PMONITOR->ID, &now);
 
+    // if correct monitor draw hyprerror
+    if (PMONITOR->ID == 0)
+        g_pHyprError->draw();
+
+    // for drawing the debug overlay
+    if (PMONITOR->ID == 0 && g_pConfigManager->getInt("debug:overlay") == 1) {
+        startRenderOverlay = std::chrono::high_resolution_clock::now();
+        g_pDebugOverlay->draw();
+        endRenderOverlay = std::chrono::high_resolution_clock::now();
+    }
+
     wlr_renderer_begin(g_pCompositor->m_sWLRRenderer, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
 
     wlr_output_render_software_cursors(PMONITOR->output, NULL);
@@ -238,6 +258,17 @@ void Events::listener_monitorFrame(void* owner, void* data) {
     wlr_output_commit(PMONITOR->output);
 
     wlr_output_schedule_frame(PMONITOR->output);
+
+    if (g_pConfigManager->getInt("debug:overlay") == 1) {
+        const float µs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - startRender).count() / 1000.f;
+        g_pDebugOverlay->renderData(PMONITOR, µs);
+        if (PMONITOR->ID == 0) {
+            const float µsNoOverlay = µs - std::chrono::duration_cast<std::chrono::nanoseconds>(endRenderOverlay - startRenderOverlay).count() / 1000.f;
+            g_pDebugOverlay->renderDataNoOverlay(PMONITOR, µsNoOverlay);
+        } else {
+            g_pDebugOverlay->renderDataNoOverlay(PMONITOR, µs);
+        }
+    }
 }
 
 void Events::listener_monitorDestroy(void* owner, void* data) {

src/events/Windows.cpp

@@ -101,6 +101,12 @@ void Events::listener_mapWindow(void* owner, void* data) {
             PWINDOW->m_bIsPseudotiled = true;
         } else if (r.szRule.find("nofocus") == 0) {
             PWINDOW->m_bNoFocus = true;
+        } else if (r.szRule.find("rounding") == 0) {
+            try {
+                PWINDOW->m_sAdditionalConfigData.rounding = std::stoi(r.szRule.substr(r.szRule.find_first_of(' ') + 1));
+            } catch (std::exception& e) {
+                Debug::log(ERR, "Rounding rule \"%s\" failed with: %s", r.szRule.c_str(), e.what());
+            }
         } else if (r.szRule.find("opacity") == 0) {
             try {
                 PWINDOW->m_sSpecialRenderData.alpha = std::stof(r.szRule.substr(r.szRule.find_first_of(' ') + 1));
@@ -184,7 +190,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
     }
 
     // do the animation thing
-    g_pAnimationManager->onWindowPostCreate(PWINDOW);
+    g_pAnimationManager->onWindowPostCreateClose(PWINDOW, false);
 
     Debug::log(LOG, "Map request dispatched, monitor %s, xywh: %f %f %f %f", PMONITOR->szName.c_str(), PWINDOW->m_vRealPosition.goalv().x, PWINDOW->m_vRealPosition.goalv().y, PWINDOW->m_vRealSize.goalv().x, PWINDOW->m_vRealSize.goalv().y);
 }
@@ -244,6 +250,12 @@ void Events::listener_unmapWindow(void* owner, void* data) {
     g_pCompositor->m_lWindowsFadingOut.push_back(PWINDOW);
 
     g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID));
+
+    // do the animation thing
+    PWINDOW->m_vOriginalClosedPos = PWINDOW->m_vRealPosition.vec();
+    PWINDOW->m_vOriginalClosedSize = PWINDOW->m_vRealSize.vec();
+    PWINDOW->m_vRealPosition = PWINDOW->m_vRealPosition.vec() + Vector2D(0.01f, 0.01f);  // it has to be animated, otherwise onWindowPostCreateClose will ignore it
+    g_pAnimationManager->onWindowPostCreateClose(PWINDOW, true);
 }
 
 void Events::listener_commitWindow(void* owner, void* data) {

src/helpers/WLClasses.hpp

@@ -57,6 +57,9 @@ struct SRenderData {
 
     // for decorations (border)
     bool decorate = false;
+
+    // for custom round values
+    int rounding = -1; // -1 means not set
 };
 
 struct SKeyboard {

src/managers/AnimationManager.cpp

@@ -208,15 +208,20 @@ bool CAnimationManager::deltazero(const CColor& a, const CColor& b) {
 //
 //
 
-void CAnimationManager::animationPopin(CWindow* pWindow) {
+void CAnimationManager::animationPopin(CWindow* pWindow, bool close) {
     const auto GOALPOS = pWindow->m_vRealPosition.goalv();
     const auto GOALSIZE = pWindow->m_vRealSize.goalv();
 
-    pWindow->m_vRealPosition.setValue(GOALPOS + GOALSIZE / 2.f);
+    if (!close) {
-    pWindow->m_vRealSize.setValue(Vector2D(5, 5));
+        pWindow->m_vRealPosition.setValue(GOALPOS + GOALSIZE / 2.f);
+        pWindow->m_vRealSize.setValue(Vector2D(5, 5));
+    } else {
+        pWindow->m_vRealPosition = GOALPOS + GOALSIZE / 2.f;
+        pWindow->m_vRealSize = Vector2D(5, 5);
+    }
 }
 
-void CAnimationManager::animationSlide(CWindow* pWindow, std::string force) {
+void CAnimationManager::animationSlide(CWindow* pWindow, std::string force, bool close) {
     pWindow->m_vRealSize.warp();  // size we preserve in slide
 
     const auto GOALPOS = pWindow->m_vRealPosition.goalv();
@@ -224,11 +229,18 @@ void CAnimationManager::animationSlide(CWindow* pWindow, std::string force) {
 
     const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
 
+    Vector2D posOffset;
+
     if (force != "") {
-        if (force == "bottom") pWindow->m_vRealPosition.setValue(Vector2D(GOALPOS.x, PMONITOR->vecPosition.y + PMONITOR->vecSize.y));
+        if (force == "bottom") posOffset = Vector2D(GOALPOS.x, PMONITOR->vecPosition.y + PMONITOR->vecSize.y);
-        else if (force == "left") pWindow->m_vRealPosition.setValue(GOALPOS - Vector2D(GOALSIZE.x, 0));
+        else if (force == "left") posOffset = GOALPOS - Vector2D(GOALSIZE.x, 0);
-        else if (force == "right") pWindow->m_vRealPosition.setValue(GOALPOS + Vector2D(GOALSIZE.x, 0));
+        else if (force == "right") posOffset = GOALPOS + Vector2D(GOALSIZE.x, 0);
-        else pWindow->m_vRealPosition.setValue(Vector2D(GOALPOS.x, PMONITOR->vecPosition.y - GOALSIZE.y));
+        else posOffset = Vector2D(GOALPOS.x, PMONITOR->vecPosition.y - GOALSIZE.y);
+
+        if (!close)
+            pWindow->m_vRealPosition.setValue(posOffset);
+        else
+            pWindow->m_vRealPosition = posOffset;
 
         return;
     }
@@ -243,25 +255,30 @@ void CAnimationManager::animationSlide(CWindow* pWindow, std::string force) {
 
     if (DISPLAYBOTTOM && DISPLAYTOP) {
         if (DISPLAYLEFT && DISPLAYRIGHT) {
-            pWindow->m_vRealPosition.setValue(GOALPOS + Vector2D(0, GOALSIZE.y));
+            posOffset = GOALPOS + Vector2D(0, GOALSIZE.y);
         } else if (DISPLAYLEFT) {
-            pWindow->m_vRealPosition.setValue(GOALPOS - Vector2D(GOALSIZE.x, 0));
+            posOffset = GOALPOS - Vector2D(GOALSIZE.x, 0);
         } else {
-            pWindow->m_vRealPosition.setValue(GOALPOS + Vector2D(GOALSIZE.x, 0));
+            posOffset = GOALPOS + Vector2D(GOALSIZE.x, 0);
         }
     } else if (DISPLAYTOP) {
-        pWindow->m_vRealPosition.setValue(GOALPOS - Vector2D(0, GOALSIZE.y));
+        posOffset = GOALPOS - Vector2D(0, GOALSIZE.y);
     } else if (DISPLAYBOTTOM) {
-        pWindow->m_vRealPosition.setValue(GOALPOS + Vector2D(0, GOALSIZE.y));
+        posOffset = GOALPOS + Vector2D(0, GOALSIZE.y);
     } else {
         if (MIDPOINT.y > PMONITOR->vecPosition.y + PMONITOR->vecSize.y / 2.f)
-            pWindow->m_vRealPosition.setValue(Vector2D(GOALPOS.x, PMONITOR->vecPosition.y + PMONITOR->vecSize.y));
+            posOffset = Vector2D(GOALPOS.x, PMONITOR->vecPosition.y + PMONITOR->vecSize.y);
         else
-            pWindow->m_vRealPosition.setValue(Vector2D(GOALPOS.x, PMONITOR->vecPosition.y - GOALSIZE.y));
+            posOffset = Vector2D(GOALPOS.x, PMONITOR->vecPosition.y - GOALSIZE.y);
     }
+
+    if (!close)
+        pWindow->m_vRealPosition.setValue(posOffset);
+    else
+        pWindow->m_vRealPosition = posOffset;
 }
 
-void CAnimationManager::onWindowPostCreate(CWindow* pWindow) {
+void CAnimationManager::onWindowPostCreateClose(CWindow* pWindow, bool close) {
     auto ANIMSTYLE = g_pConfigManager->getString("animations:windows_style");
     transform(ANIMSTYLE.begin(), ANIMSTYLE.end(), ANIMSTYLE.begin(), ::tolower);
 
@@ -274,20 +291,20 @@ void CAnimationManager::onWindowPostCreate(CWindow* pWindow) {
         if (pWindow->m_sAdditionalConfigData.animationStyle.find("slide") == 0) {
             if (pWindow->m_sAdditionalConfigData.animationStyle.find(' ') != std::string::npos) {
                 // has a direction
-                animationSlide(pWindow, pWindow->m_sAdditionalConfigData.animationStyle.substr(pWindow->m_sAdditionalConfigData.animationStyle.find(' ') + 1));
+                animationSlide(pWindow, pWindow->m_sAdditionalConfigData.animationStyle.substr(pWindow->m_sAdditionalConfigData.animationStyle.find(' ') + 1), close);
             } else {
-                animationSlide(pWindow);
+                animationSlide(pWindow, "", close);
             }
         } else {
             // anim popin, fallback
-            animationPopin(pWindow);
+            animationPopin(pWindow, close);
         }
     } else {
         if (ANIMSTYLE == "slide") {
-            animationSlide(pWindow);
+            animationSlide(pWindow, "", close);
         } else {
             // anim popin, fallback
-            animationPopin(pWindow);
+            animationPopin(pWindow, close);
         }
     }
 }

src/managers/AnimationManager.hpp

@@ -16,7 +16,7 @@ public:
     void            addBezierWithName(std::string, const Vector2D&, const Vector2D&);
     void            removeAllBeziers();
 
-    void            onWindowPostCreate(CWindow*);
+    void            onWindowPostCreateClose(CWindow*, bool close = false);
 
     std::list<CAnimatedVariable*> m_lAnimatedVariables;
 
@@ -31,8 +31,8 @@ private:
     std::unordered_map<std::string, CBezierCurve> m_mBezierCurves;
 
     // Anim stuff
-    void            animationPopin(CWindow*);
+    void            animationPopin(CWindow*, bool close = false);
-    void            animationSlide(CWindow*, std::string force = "");
+    void            animationSlide(CWindow*, std::string force = "", bool close = false);
 };
 
 inline std::unique_ptr<CAnimationManager> g_pAnimationManager;

src/managers/KeybindManager.cpp

@@ -558,7 +558,12 @@ void CKeybindManager::focusMonitor(std::string arg) {
         if (isDirection(arg)) {
             const auto PMONITOR = g_pCompositor->getMonitorInDirection(arg[0]);
             if (PMONITOR) {
-                changeworkspace(std::to_string(PMONITOR->activeWorkspace));
+                if (PMONITOR->activeWorkspace < 0) {
+                    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
+                    changeworkspace("name:" + PWORKSPACE->m_szName);
+                }
+                else
+                    changeworkspace(std::to_string(PMONITOR->activeWorkspace));
                 return;
             }
         } else {

src/render/OpenGL.cpp

@@ -575,8 +575,8 @@ void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox,
     wlr_box MONITORBOX = {0, 0, m_RenderData.pMonitor->vecPixelSize.x, m_RenderData.pMonitor->vecPixelSize.y};
     if (pixman_region32_not_empty(&damage)) {
         // render our great blurred FB
-        renderTextureInternalWithDamage(POUTFB->m_cTex, &MONITORBOX, a, &damage);
+        renderTextureInternalWithDamage(POUTFB->m_cTex, &MONITORBOX, g_pConfigManager->getInt("decoration:blur_ignore_opacity") ? 255.f : a, &damage);
-        
+
         // render the window, but clear stencil
         glClearStencil(0);
         glClear(GL_STENCIL_BUFFER_BIT);
@@ -756,7 +756,14 @@ void CHyprOpenGLImpl::renderSnapshot(CWindow** pWindow) {
 
     const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
 
-    wlr_box windowBox = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
+    wlr_box windowBox;
+    // some mafs to figure out the correct box
+    Vector2D scaleXY = Vector2D((PWINDOW->m_vRealSize.vec().x / PWINDOW->m_vOriginalClosedSize.x), (PWINDOW->m_vRealSize.vec().y / PWINDOW->m_vOriginalClosedSize.y));
+
+    windowBox.width = PMONITOR->vecPixelSize.x * scaleXY.x;
+    windowBox.height = PMONITOR->vecPixelSize.y * scaleXY.y;
+    windowBox.x = (PWINDOW->m_vRealPosition.vec().x - PMONITOR->vecPosition.x) - ((PWINDOW->m_vOriginalClosedPos.x - PMONITOR->vecPosition.x) * scaleXY.x);
+    windowBox.y = (PWINDOW->m_vRealPosition.vec().y - PMONITOR->vecPosition.y) - ((PWINDOW->m_vOriginalClosedPos.y - PMONITOR->vecPosition.y) * scaleXY.y);
 
     pixman_region32_t fakeDamage;
     pixman_region32_init_rect(&fakeDamage, 0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);

src/render/Renderer.cpp

@@ -19,10 +19,12 @@ void renderSurface(struct wlr_surface* surface, int x, int y, void* data) {
     }
     scaleBox(&windowBox, RDATA->output->scale);
 
+    float rounding = RDATA->dontRound ? 0 : RDATA->rounding == -1 ? g_pConfigManager->getInt("decoration:rounding") : RDATA->rounding;
+
     if (RDATA->surface && surface == RDATA->surface)
-        g_pHyprOpenGL->renderTextureWithBlur(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, surface, RDATA->dontRound ? 0 : g_pConfigManager->getInt("decoration:rounding"), RDATA->decorate);
+        g_pHyprOpenGL->renderTextureWithBlur(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, surface, rounding, RDATA->decorate);
     else
-        g_pHyprOpenGL->renderTexture(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, RDATA->dontRound ? 0 : g_pConfigManager->getInt("decoration:rounding"), false, false);
+        g_pHyprOpenGL->renderTexture(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, rounding, false, false);
 
     wlr_surface_send_frame_done(surface, RDATA->when);
 
@@ -85,7 +87,8 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, SMonitor* pMonitor, timespec*
         return;
 
     if (pWindow->m_bFadingOut) {
-        g_pHyprOpenGL->renderSnapshot(&pWindow);
+        if (pMonitor->ID == pWindow->m_iMonitorID) // TODO: fix this
+            g_pHyprOpenGL->renderSnapshot(&pWindow);
         return;
     }
     
@@ -99,6 +102,7 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, SMonitor* pMonitor, timespec*
     renderdata.fadeAlpha = pWindow->m_fAlpha.fl() * (PWORKSPACE->m_fAlpha.fl() / 255.f);
     renderdata.alpha = pWindow->m_bIsFullscreen ? g_pConfigManager->getFloat("decoration:fullscreen_opacity") : pWindow == g_pCompositor->m_pLastWindow ? g_pConfigManager->getFloat("decoration:active_opacity") : g_pConfigManager->getFloat("decoration:inactive_opacity");
     renderdata.decorate = decorate && !pWindow->m_bX11DoesntWantBorders;
+    renderdata.rounding = pWindow->m_sAdditionalConfigData.rounding;
 
     // apply window special data
     renderdata.alpha *= pWindow->m_sSpecialRenderData.alpha;
@@ -194,10 +198,6 @@ void CHyprRenderer::renderAllClientsForMonitor(const int& ID, timespec* time) {
     }
 
     renderDragIcon(PMONITOR, time);
-
-    // if correct monitor draw hyprerror
-    if (PMONITOR == &g_pCompositor->m_lMonitors.front())
-        g_pHyprError->draw();
 }
 
 void CHyprRenderer::outputMgrApplyTest(wlr_output_configuration_v1* config, bool test) {