desktop/window: add alpha container for alpha calculations

9 files changed, 323 insertions, 76 deletions

diff --git a/src/Compositor.cpp b/src/Compositor.cpp
index f0261847..3b7ea815 100644
--- a/src/Compositor.cpp
+++ b/src/Compositor.cpp
@@ -99,6 +99,7 @@ using namespace Hyprutils::String;
 using namespace Aquamarine;
 using enum NContentType::eContentType;
 using namespace NColorManagement;
+using namespace Desktop::View;
 using namespace Render::GL;
 
 static int handleCritSignal(int signo, void* data) {
@@ -1368,7 +1369,7 @@ void CCompositor::cleanupFadingOut(const MONITORID& monid) {
         if (w->monitorID() != monid && w->m_monitor)
             continue;
 
-        if (!w->m_fadingOut || w->m_alpha->value() == 0.f) {
+        if (!w->m_fadingOut || w->alphaValue(WINDOW_ALPHA_FADE) == 0.f) {
 
             w->m_fadingOut = false;
 
@@ -2700,8 +2701,8 @@ void CCompositor::moveWindowToWorkspaceSafe(PHLWINDOW pWindow, PHLWORKSPACE pWor
     g_pCompositor->updateSuspendedStates();
 
     if (!WASVISIBLE && pWindow->m_workspace && pWindow->m_workspace->isVisible()) {
-        pWindow->m_movingFromWorkspaceAlpha->setValueAndWarp(0.F);
-        *pWindow->m_movingFromWorkspaceAlpha = 1.F;
+        pWindow->alpha(WINDOW_ALPHA_MOVE_FROM_WORKSPACE)->setValueAndWarp(0.F);
+        *pWindow->alpha(WINDOW_ALPHA_MOVE_FROM_WORKSPACE) = 1.F;
     }
 }
 
diff --git a/src/desktop/types/MultiAnimatedVariable.hpp b/src/desktop/types/MultiAnimatedVariable.hpp
new file mode 100644
index 00000000..564a2db3
--- /dev/null
+++ b/src/desktop/types/MultiAnimatedVariable.hpp
@@ -0,0 +1,184 @@
+#pragma once
+
+#include <array>
+#include <cstddef>
+
+#include "../../helpers/AnimatedVariable.hpp"
+
+namespace Desktop::Types {
+
+    template <typename T>
+    struct SAddOperation {
+        static constexpr T identity() {
+            return T{};
+        }
+
+        static T apply(const T& lhs, const T& rhs) {
+            return lhs + rhs;
+        }
+    };
+
+    template <typename T>
+    struct SMultiplyOperation {
+        static constexpr T identity() {
+            return T{1};
+        }
+
+        static T apply(const T& lhs, const T& rhs) {
+            return lhs * rhs;
+        }
+    };
+
+    template <Animable VarType, typename Key, size_t Count, typename Operation = SMultiplyOperation<VarType>>
+    class CMultiAnimatedVariableContainer {
+      public:
+        using value_type     = VarType;
+        using key_type       = Key;
+        using operation_type = Operation;
+
+        static constexpr size_t size() {
+            return Count;
+        }
+
+        PHLANIMVAR<VarType>& get(const Key key) {
+            return m_vars.at(index(key));
+        }
+
+        const PHLANIMVAR<VarType>& get(const Key key) const {
+            return m_vars.at(index(key));
+        }
+
+        PHLANIMVAR<VarType>& operator[](const Key key) {
+            return get(key);
+        }
+
+        const PHLANIMVAR<VarType>& operator[](const Key key) const {
+            return get(key);
+        }
+
+        PHLANIMVAR<VarType>& raw(const size_t i) {
+            return m_vars.at(i);
+        }
+
+        const PHLANIMVAR<VarType>& raw(const size_t i) const {
+            return m_vars.at(i);
+        }
+
+        std::array<PHLANIMVAR<VarType>, Count>& all() {
+            return m_vars;
+        }
+
+        const std::array<PHLANIMVAR<VarType>, Count>& all() const {
+            return m_vars;
+        }
+
+        template <typename Fn>
+        void forEach(Fn&& fn) {
+            for (size_t i = 0; i < Count; ++i)
+                fn(static_cast<Key>(i), m_vars.at(i));
+        }
+
+        template <typename Fn>
+        void forEach(Fn&& fn) const {
+            for (size_t i = 0; i < Count; ++i)
+                fn(static_cast<Key>(i), m_vars.at(i));
+        }
+
+        VarType getTotal() const {
+            return accumulate([](const auto& var) { return var->value(); });
+        }
+
+        VarType getTotalGoal() const {
+            return accumulate([](const auto& var) { return var->goal(); });
+        }
+
+        VarType getTotalBegun() const {
+            return accumulate([](const auto& var) { return var->begun(); });
+        }
+
+        VarType getTotalWithout(const Key key) const {
+            return accumulateExcept(key, [](const auto& var) { return var->value(); });
+        }
+
+        VarType getTotalGoalWithout(const Key key) const {
+            return accumulateExcept(key, [](const auto& var) { return var->goal(); });
+        }
+
+        VarType getTotalBegunWithout(const Key key) const {
+            return accumulateExcept(key, [](const auto& var) { return var->begun(); });
+        }
+
+        VarType value() const {
+            return getTotal();
+        }
+
+        VarType goal() const {
+            return getTotalGoal();
+        }
+
+        bool isBeingAnimated() const {
+            for (const auto& var : m_vars) {
+                if (var && var->isBeingAnimated())
+                    return true;
+            }
+
+            return false;
+        }
+
+        bool initialized() const {
+            for (const auto& var : m_vars) {
+                if (!var)
+                    return false;
+            }
+
+            return true;
+        }
+
+        void warp(const bool endCallback = true) {
+            for (auto& var : m_vars) {
+                if (var)
+                    var->warp(endCallback);
+            }
+        }
+
+      private:
+        static constexpr size_t index(const Key key) {
+            return static_cast<size_t>(key);
+        }
+
+        template <typename Getter>
+        VarType accumulate(Getter&& getter) const {
+            VarType result = Operation::identity();
+
+            for (const auto& var : m_vars) {
+                if (!var)
+                    continue;
+
+                result = Operation::apply(result, getter(var));
+            }
+
+            return result;
+        }
+
+        template <typename Getter>
+        VarType accumulateExcept(const Key key, Getter&& getter) const {
+            VarType      result = Operation::identity();
+            const size_t except = index(key);
+
+            for (size_t i = 0; i < Count; ++i) {
+                if (i == except || !m_vars.at(i))
+                    continue;
+
+                result = Operation::apply(result, getter(m_vars.at(i)));
+            }
+
+            return result;
+        }
+
+        std::array<PHLANIMVAR<VarType>, Count> m_vars;
+    };
+
+    template <Animable VarType, typename Key, size_t Count, typename Operation = SMultiplyOperation<VarType>>
+    using CMultiAVarContainer = CMultiAnimatedVariableContainer<VarType, Key, Count, Operation>;
+
+}
diff --git a/src/desktop/view/Window.cpp b/src/desktop/view/Window.cpp
index cbcdb599..ef854bd1 100644
--- a/src/desktop/view/Window.cpp
+++ b/src/desktop/view/Window.cpp
@@ -84,13 +84,17 @@ PHLWINDOW CWindow::create(SP<CXWaylandSurface> surface) {
     g_pAnimationManager->createAnimation(0.f, pWindow->m_borderFadeAnimationProgress, Config::animationTree()->getAnimationPropertyConfig("border"), pWindow, AVARDAMAGE_BORDER);
     g_pAnimationManager->createAnimation(0.f, pWindow->m_borderAngleAnimationProgress, Config::animationTree()->getAnimationPropertyConfig("borderangle"), pWindow,
                                          AVARDAMAGE_BORDER);
-    g_pAnimationManager->createAnimation(1.f, pWindow->m_alpha, Config::animationTree()->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
-    g_pAnimationManager->createAnimation(1.f, pWindow->m_activeInactiveAlpha, Config::animationTree()->getAnimationPropertyConfig("fadeSwitch"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, pWindow->alpha(WINDOW_ALPHA_FADE), Config::animationTree()->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, pWindow->alpha(WINDOW_ALPHA_ACTIVE), Config::animationTree()->getAnimationPropertyConfig("fadeSwitch"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, pWindow->alpha(WINDOW_ALPHA_FULLSCREEN), Config::animationTree()->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, pWindow->alpha(WINDOW_ALPHA_LAYOUT), Config::animationTree()->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
     g_pAnimationManager->createAnimation(CHyprColor(), pWindow->m_realShadowColor, Config::animationTree()->getAnimationPropertyConfig("fadeShadow"), pWindow, AVARDAMAGE_SHADOW);
     g_pAnimationManager->createAnimation(CHyprColor(), pWindow->m_realGlowColor, Config::animationTree()->getAnimationPropertyConfig("fadeGlow"), pWindow, AVARDAMAGE_ENTIRE);
     g_pAnimationManager->createAnimation(0.f, pWindow->m_dimPercent, Config::animationTree()->getAnimationPropertyConfig("fadeDim"), pWindow, AVARDAMAGE_ENTIRE);
-    g_pAnimationManager->createAnimation(0.f, pWindow->m_movingToWorkspaceAlpha, Config::animationTree()->getAnimationPropertyConfig("fadeOut"), pWindow, AVARDAMAGE_ENTIRE);
-    g_pAnimationManager->createAnimation(0.f, pWindow->m_movingFromWorkspaceAlpha, Config::animationTree()->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, pWindow->alpha(WINDOW_ALPHA_MOVE_TO_WORKSPACE), Config::animationTree()->getAnimationPropertyConfig("fadeOut"), pWindow,
+                                         AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, pWindow->alpha(WINDOW_ALPHA_MOVE_FROM_WORKSPACE), Config::animationTree()->getAnimationPropertyConfig("fadeIn"), pWindow,
+                                         AVARDAMAGE_ENTIRE);
     g_pAnimationManager->createAnimation(0.f, pWindow->m_notRespondingTint, Config::animationTree()->getAnimationPropertyConfig("fade"), pWindow, AVARDAMAGE_ENTIRE);
 
     pWindow->addWindowDeco(makeUnique<CHyprDropShadowDecoration>(pWindow));
@@ -114,13 +118,17 @@ PHLWINDOW CWindow::create(SP<CXDGSurfaceResource> resource) {
     g_pAnimationManager->createAnimation(0.f, pWindow->m_borderFadeAnimationProgress, Config::animationTree()->getAnimationPropertyConfig("border"), pWindow, AVARDAMAGE_BORDER);
     g_pAnimationManager->createAnimation(0.f, pWindow->m_borderAngleAnimationProgress, Config::animationTree()->getAnimationPropertyConfig("borderangle"), pWindow,
                                          AVARDAMAGE_BORDER);
-    g_pAnimationManager->createAnimation(1.f, pWindow->m_alpha, Config::animationTree()->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
-    g_pAnimationManager->createAnimation(1.f, pWindow->m_activeInactiveAlpha, Config::animationTree()->getAnimationPropertyConfig("fadeSwitch"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, pWindow->alpha(WINDOW_ALPHA_FADE), Config::animationTree()->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, pWindow->alpha(WINDOW_ALPHA_ACTIVE), Config::animationTree()->getAnimationPropertyConfig("fadeSwitch"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, pWindow->alpha(WINDOW_ALPHA_FULLSCREEN), Config::animationTree()->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, pWindow->alpha(WINDOW_ALPHA_LAYOUT), Config::animationTree()->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
     g_pAnimationManager->createAnimation(CHyprColor(), pWindow->m_realShadowColor, Config::animationTree()->getAnimationPropertyConfig("fadeShadow"), pWindow, AVARDAMAGE_SHADOW);
     g_pAnimationManager->createAnimation(CHyprColor(), pWindow->m_realGlowColor, Config::animationTree()->getAnimationPropertyConfig("fadeGlow"), pWindow, AVARDAMAGE_ENTIRE);
     g_pAnimationManager->createAnimation(0.f, pWindow->m_dimPercent, Config::animationTree()->getAnimationPropertyConfig("fadeDim"), pWindow, AVARDAMAGE_ENTIRE);
-    g_pAnimationManager->createAnimation(0.f, pWindow->m_movingToWorkspaceAlpha, Config::animationTree()->getAnimationPropertyConfig("fadeOut"), pWindow, AVARDAMAGE_ENTIRE);
-    g_pAnimationManager->createAnimation(0.f, pWindow->m_movingFromWorkspaceAlpha, Config::animationTree()->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, pWindow->alpha(WINDOW_ALPHA_MOVE_TO_WORKSPACE), Config::animationTree()->getAnimationPropertyConfig("fadeOut"), pWindow,
+                                         AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, pWindow->alpha(WINDOW_ALPHA_MOVE_FROM_WORKSPACE), Config::animationTree()->getAnimationPropertyConfig("fadeIn"), pWindow,
+                                         AVARDAMAGE_ENTIRE);
     g_pAnimationManager->createAnimation(0.f, pWindow->m_notRespondingTint, Config::animationTree()->getAnimationPropertyConfig("fade"), pWindow, AVARDAMAGE_ENTIRE);
 
     pWindow->addWindowDeco(makeUnique<CHyprDropShadowDecoration>(pWindow));
@@ -179,7 +187,7 @@ eViewType CWindow::type() const {
 }
 
 bool CWindow::visible() const {
-    return !m_hidden && ((m_isMapped && m_wlSurface && m_wlSurface->resource()) || (m_fadingOut && m_alpha->value() != 0.F));
+    return !m_hidden && ((m_isMapped && m_wlSurface && m_wlSurface->resource()) || (m_fadingOut && alphaValue(WINDOW_ALPHA_FADE) != 0.F));
 }
 
 std::optional<CBox> CWindow::logicalBox() const {
@@ -494,9 +502,12 @@ void CWindow::moveToWorkspace(PHLWORKSPACE pWorkspace) {
     const auto  OLDWORKSPACE = m_workspace;
 
     if (OLDWORKSPACE->isVisible()) {
-        m_movingToWorkspaceAlpha->setValueAndWarp(1.F);
-        *m_movingToWorkspaceAlpha = 0.F;
-        m_movingToWorkspaceAlpha->setCallbackOnEnd([this](auto) { m_monitorMovedFrom = -1; });
+        alpha(WINDOW_ALPHA_MOVE_TO_WORKSPACE)->setValueAndWarp(1.F);
+        *alpha(WINDOW_ALPHA_MOVE_TO_WORKSPACE) = 0.F;
+        alpha(WINDOW_ALPHA_MOVE_TO_WORKSPACE)->setCallbackOnEnd([this](auto) {
+            alpha(WINDOW_ALPHA_MOVE_TO_WORKSPACE)->setValueAndWarp(1.F);
+            m_monitorMovedFrom = -1;
+        });
         m_monitorMovedFrom = OLDWORKSPACE ? OLDWORKSPACE->monitorID() : -1;
     }
 
@@ -615,15 +626,18 @@ void CWindow::onMap() {
     m_realSize->resetAllCallbacks();
     m_borderFadeAnimationProgress->resetAllCallbacks();
     m_borderAngleAnimationProgress->resetAllCallbacks();
-    m_activeInactiveAlpha->resetAllCallbacks();
-    m_alpha->resetAllCallbacks();
+    alpha(WINDOW_ALPHA_ACTIVE)->resetAllCallbacks();
+    alpha(WINDOW_ALPHA_FADE)->resetAllCallbacks();
+    alpha(WINDOW_ALPHA_FULLSCREEN)->resetAllCallbacks();
+    alpha(WINDOW_ALPHA_LAYOUT)->resetAllCallbacks();
     m_realShadowColor->resetAllCallbacks();
     m_realGlowColor->resetAllCallbacks();
     m_dimPercent->resetAllCallbacks();
-    m_movingToWorkspaceAlpha->resetAllCallbacks();
-    m_movingFromWorkspaceAlpha->resetAllCallbacks();
+    alpha(WINDOW_ALPHA_MOVE_TO_WORKSPACE)->resetAllCallbacks();
+    alpha(WINDOW_ALPHA_MOVE_FROM_WORKSPACE)->resetAllCallbacks();
 
-    m_movingFromWorkspaceAlpha->setValueAndWarp(1.F);
+    alpha(WINDOW_ALPHA_MOVE_FROM_WORKSPACE)->setValueAndWarp(1.F);
+    alpha(WINDOW_ALPHA_MOVE_TO_WORKSPACE)->setValueAndWarp(1.F);
 
     if (m_borderAngleAnimationProgress->enabled()) {
         m_borderAngleAnimationProgress->setValueAndWarp(0.f);
@@ -666,7 +680,7 @@ void CWindow::onMap() {
         }
     });
 
-    m_movingFromWorkspaceAlpha->setValueAndWarp(1.F);
+    alpha(WINDOW_ALPHA_MOVE_FROM_WORKSPACE)->setValueAndWarp(1.F);
 
     m_reportedSize = m_pendingReportedSize;
     m_animatingIn  = true;
@@ -713,6 +727,30 @@ bool CWindow::isHidden() {
     return m_hidden;
 }
 
+PHLANIMVAR<float>& CWindow::alpha(eWindowAlpha type) {
+    return m_alpha.get(type);
+}
+
+const PHLANIMVAR<float>& CWindow::alpha(eWindowAlpha type) const {
+    return m_alpha.get(type);
+}
+
+float CWindow::alphaValue(eWindowAlpha type) const {
+    return alpha(type)->value();
+}
+
+float CWindow::alphaGoal(eWindowAlpha type) const {
+    return alpha(type)->goal();
+}
+
+float CWindow::alphaTotal() const {
+    return m_alpha.getTotal();
+}
+
+float CWindow::alphaTotalWithout(eWindowAlpha type) const {
+    return m_alpha.getTotalWithout(type);
+}
+
 // check if the point is "hidden" under a rounded corner of the window
 // it is assumed that the point is within the real window box (m_vRealPosition, m_vRealSize)
 // otherwise behaviour is undefined
@@ -762,7 +800,7 @@ Vector2D CWindow::middle() {
 }
 
 bool CWindow::opaque() {
-    if (m_alpha->value() != 1.f || m_activeInactiveAlpha->value() != 1.f)
+    if (alphaValue(WINDOW_ALPHA_FADE) != 1.f || alphaValue(WINDOW_ALPHA_FULLSCREEN) != 1.f || alphaValue(WINDOW_ALPHA_ACTIVE) != 1.f)
         return false;
 
     const auto PWORKSPACE = m_workspace;
@@ -1593,12 +1631,12 @@ void CWindow::updateDecorationValues() {
     // opacity
     const auto PWORKSPACE = m_workspace;
     if (isEffectiveInternalFSMode(FSMODE_FULLSCREEN)) {
-        *m_activeInactiveAlpha = m_ruleApplicator->alphaFullscreen().valueOrDefault().applyAlpha(*PFULLSCREENALPHA);
+        *alpha(WINDOW_ALPHA_ACTIVE) = m_ruleApplicator->alphaFullscreen().valueOrDefault().applyAlpha(*PFULLSCREENALPHA);
     } else {
         if (m_self == Desktop::focusState()->window())
-            *m_activeInactiveAlpha = m_ruleApplicator->alpha().valueOrDefault().applyAlpha(*PACTIVEALPHA);
+            *alpha(WINDOW_ALPHA_ACTIVE) = m_ruleApplicator->alpha().valueOrDefault().applyAlpha(*PACTIVEALPHA);
         else
-            *m_activeInactiveAlpha = m_ruleApplicator->alphaInactive().valueOrDefault().applyAlpha(*PINACTIVEALPHA);
+            *alpha(WINDOW_ALPHA_ACTIVE) = m_ruleApplicator->alphaInactive().valueOrDefault().applyAlpha(*PINACTIVEALPHA);
     }
 
     // dim
@@ -2056,10 +2094,10 @@ void CWindow::mapWindow() {
         } else
             Desktop::focusState()->fullWindowFocus(m_self.lock(), FOCUS_REASON_NEW_WINDOW);
 
-        m_activeInactiveAlpha->setValueAndWarp(*PACTIVEALPHA);
+        alpha(WINDOW_ALPHA_ACTIVE)->setValueAndWarp(*PACTIVEALPHA);
         m_dimPercent->setValueAndWarp(m_ruleApplicator->noDim().valueOrDefault() ? 0.f : *PDIMSTRENGTH);
     } else {
-        m_activeInactiveAlpha->setValueAndWarp(*PINACTIVEALPHA);
+        alpha(WINDOW_ALPHA_ACTIVE)->setValueAndWarp(*PINACTIVEALPHA);
         m_dimPercent->setValueAndWarp(0);
     }
 
@@ -2129,7 +2167,7 @@ void CWindow::mapWindow() {
     updateDecorationValues();
     // avoid this window being visible
     if (PWORKSPACE->m_hasFullscreenWindow && !isFullscreen() && !m_isFloating)
-        m_alpha->setValueAndWarp(0.f);
+        alpha(WINDOW_ALPHA_FULLSCREEN)->setValueAndWarp(0.f);
 
     g_pCompositor->setPreferredScaleForSurface(wlSurface()->resource(), PMONITOR->m_scale);
     g_pCompositor->setPreferredTransformForSurface(wlSurface()->resource(), PMONITOR->m_transform);
diff --git a/src/desktop/view/Window.hpp b/src/desktop/view/Window.hpp
index ff6fad96..0a468ee3 100644
--- a/src/desktop/view/Window.hpp
+++ b/src/desktop/view/Window.hpp
@@ -13,6 +13,7 @@
 #include "../../render/decorations/IHyprWindowDecoration.hpp"
 #include "../../render/Transformer.hpp"
 #include "../DesktopTypes.hpp"
+#include "../types/MultiAnimatedVariable.hpp"
 #include "Popup.hpp"
 #include "Subsurface.hpp"
 #include "WLSurface.hpp"
@@ -77,6 +78,17 @@ namespace Desktop::View {
         SUPPRESS_FULLSCREEN_OUTPUT  = 1 << 4,
     };
 
+    enum eWindowAlpha : uint8_t {
+        WINDOW_ALPHA_FADE = 0,
+        WINDOW_ALPHA_ACTIVE,
+        WINDOW_ALPHA_FULLSCREEN,
+        WINDOW_ALPHA_LAYOUT,
+        WINDOW_ALPHA_MOVE_TO_WORKSPACE,
+        WINDOW_ALPHA_MOVE_FROM_WORKSPACE,
+
+        WINDOW_ALPHA_LAST,
+    };
+
     struct SWindowActiveEvent {
         PHLWINDOW    window = nullptr;
         eFocusReason reason = sc<eFocusReason>(0) /* unknown */;
@@ -194,13 +206,13 @@ namespace Desktop::View {
         mutable bool m_borderSizeCacheDirty = true;
 
         // Fade in-out
-        PHLANIMVAR<float> m_alpha;
-        bool              m_fadingOut     = false;
-        bool              m_readyToDelete = false;
-        Vector2D          m_originalClosedPos;  // these will be used for calculations later on in
-        Vector2D          m_originalClosedSize; // drawing the closing animations
-        SBoxExtents       m_originalClosedExtents;
-        bool              m_animatingIn = false;
+        Desktop::Types::CMultiAVarContainer<float, eWindowAlpha, WINDOW_ALPHA_LAST> m_alpha;
+        bool                                                                        m_fadingOut     = false;
+        bool                                                                        m_readyToDelete = false;
+        Vector2D                                                                    m_originalClosedPos;  // these will be used for calculations later on in
+        Vector2D                                                                    m_originalClosedSize; // drawing the closing animations
+        SBoxExtents                                                                 m_originalClosedExtents;
+        bool                                                                        m_animatingIn = false;
 
         // For pinned (sticky) windows
         bool m_pinned = false;
@@ -225,10 +237,6 @@ namespace Desktop::View {
         // Transformers
         std::vector<UP<IWindowTransformer>> m_transformers;
 
-        // for alpha
-        PHLANIMVAR<float> m_activeInactiveAlpha;
-        PHLANIMVAR<float> m_movingFromWorkspaceAlpha;
-
         // animated shadow color
         PHLANIMVAR<CHyprColor> m_realShadowColor;
 
@@ -239,8 +247,7 @@ namespace Desktop::View {
         PHLANIMVAR<float> m_dimPercent;
 
         // animate moving to an invisible workspace
-        int               m_monitorMovedFrom = -1; // -1 means not moving
-        PHLANIMVAR<float> m_movingToWorkspaceAlpha;
+        int m_monitorMovedFrom = -1; // -1 means not moving
 
         // swallowing
         PHLWINDOWREF m_swallowed;
@@ -298,6 +305,12 @@ namespace Desktop::View {
         void                       onMap();
         void                       setHidden(bool hidden);
         bool                       isHidden();
+        PHLANIMVAR<float>&         alpha(eWindowAlpha type);
+        const PHLANIMVAR<float>&   alpha(eWindowAlpha type) const;
+        float                      alphaValue(eWindowAlpha type) const;
+        float                      alphaGoal(eWindowAlpha type) const;
+        float                      alphaTotal() const;
+        float                      alphaTotalWithout(eWindowAlpha type) const;
         void                       updateDecorationValues();
         SBoxExtents                getFullWindowReservedArea();
         Vector2D                   middle();
diff --git a/src/managers/animation/DesktopAnimationManager.cpp b/src/managers/animation/DesktopAnimationManager.cpp
index 186a3fa3..3ef9ff00 100644
--- a/src/managers/animation/DesktopAnimationManager.cpp
+++ b/src/managers/animation/DesktopAnimationManager.cpp
@@ -18,25 +18,26 @@
 #include <hyprutils/string/VarList.hpp>
 
 using namespace Hyprutils::String;
+using namespace Desktop::View;
 
 void CDesktopAnimationManager::startAnimation(PHLWINDOW pWindow, eAnimationType type, bool force) {
     const bool CLOSE = type == ANIMATION_TYPE_OUT;
 
     if (CLOSE)
-        *pWindow->m_alpha = 0.F;
+        *pWindow->alpha(WINDOW_ALPHA_FADE) = 0.F;
     else {
-        pWindow->m_alpha->setValueAndWarp(0.F);
-        *pWindow->m_alpha = 1.F;
+        pWindow->alpha(WINDOW_ALPHA_FADE)->setValueAndWarp(0.F);
+        *pWindow->alpha(WINDOW_ALPHA_FADE) = 1.F;
     }
 
     if (!CLOSE) {
         pWindow->m_realPosition->setConfig(Config::animationTree()->getAnimationPropertyConfig("windowsIn"));
         pWindow->m_realSize->setConfig(Config::animationTree()->getAnimationPropertyConfig("windowsIn"));
-        pWindow->m_alpha->setConfig(Config::animationTree()->getAnimationPropertyConfig("fadeIn"));
+        pWindow->alpha(WINDOW_ALPHA_FADE)->setConfig(Config::animationTree()->getAnimationPropertyConfig("fadeIn"));
     } else {
         pWindow->m_realPosition->setConfig(Config::animationTree()->getAnimationPropertyConfig("windowsOut"));
         pWindow->m_realSize->setConfig(Config::animationTree()->getAnimationPropertyConfig("windowsOut"));
-        pWindow->m_alpha->setConfig(Config::animationTree()->getAnimationPropertyConfig("fadeOut"));
+        pWindow->alpha(WINDOW_ALPHA_FADE)->setConfig(Config::animationTree()->getAnimationPropertyConfig("fadeOut"));
     }
 
     std::string ANIMSTYLE = pWindow->m_realPosition->getStyle();
@@ -475,11 +476,11 @@ void CDesktopAnimationManager::setFullscreenFadeAnimation(PHLWORKSPACE ws, eAnim
                 continue;
 
             if (!FULLSCREEN)
-                *w->m_alpha = 1.F;
+                *w->alpha(WINDOW_ALPHA_FULLSCREEN) = 1.F;
             else if (!w->isFullscreen()) {
-                const bool CREATED_OVER_FS   = w->m_createdOverFullscreen;
-                const bool IS_IN_GROUP_OF_FS = FSWINDOW && FSWINDOW->m_group && FSWINDOW->m_group->has(w);
-                *w->m_alpha                  = !CREATED_OVER_FS && !IS_IN_GROUP_OF_FS ? 0.f : 1.f;
+                const bool CREATED_OVER_FS         = w->m_createdOverFullscreen;
+                const bool IS_IN_GROUP_OF_FS       = FSWINDOW && FSWINDOW->m_group && FSWINDOW->m_group->has(w);
+                *w->alpha(WINDOW_ALPHA_FULLSCREEN) = !CREATED_OVER_FS && !IS_IN_GROUP_OF_FS ? 0.f : 1.f;
             }
         }
     }
@@ -498,7 +499,7 @@ void CDesktopAnimationManager::setFullscreenFloatingFade(PHLWINDOW pWindow, floa
     if (pWindow->m_fadingOut || !pWindow->m_isFloating)
         return;
 
-    *pWindow->m_alpha = fade;
+    *pWindow->alpha(WINDOW_ALPHA_FULLSCREEN) = fade;
 }
 
 void CDesktopAnimationManager::overrideFullscreenFadeAmount(PHLWORKSPACE ws, float fade, PHLWINDOW exclude) {
@@ -510,7 +511,7 @@ void CDesktopAnimationManager::overrideFullscreenFadeAmount(PHLWORKSPACE ws, flo
             if (w->m_fadingOut || w->m_pinned || w->isFullscreen())
                 continue;
 
-            *w->m_alpha = fade;
+            *w->alpha(WINDOW_ALPHA_FULLSCREEN) = fade;
         }
     }
 
diff --git a/src/managers/input/trackpad/gestures/CloseGesture.cpp b/src/managers/input/trackpad/gestures/CloseGesture.cpp
index 59ff2838..225f3132 100644
--- a/src/managers/input/trackpad/gestures/CloseGesture.cpp
+++ b/src/managers/input/trackpad/gestures/CloseGesture.cpp
@@ -9,6 +9,8 @@
 #include "../../../../desktop/state/FocusState.hpp"
 #include "../../../../layout/target/Target.hpp"
 
+using namespace Desktop::View;
+
 constexpr const float                   MAX_DISTANCE = 200.F;
 
 static std::vector<SP<CEventLoopTimer>> trackpadCloseTimers;
@@ -33,18 +35,18 @@ void CCloseTrackpadGesture::begin(const ITrackpadGesture::STrackpadGestureBegin&
     if (!m_window)
         return;
 
-    m_alphaFrom = m_window->m_alpha->goal();
+    m_alphaFrom = m_window->alphaGoal(WINDOW_ALPHA_FADE);
     m_posFrom   = m_window->m_realPosition->goal();
     m_sizeFrom  = m_window->m_realSize->goal();
 
     g_pDesktopAnimationManager->startAnimation(m_window.lock(), CDesktopAnimationManager::ANIMATION_TYPE_OUT, true);
-    *m_window->m_alpha = 0.f;
+    *m_window->alpha(WINDOW_ALPHA_FADE) = 0.f;
 
-    m_alphaTo = m_window->m_alpha->goal();
+    m_alphaTo = m_window->alphaGoal(WINDOW_ALPHA_FADE);
     m_posTo   = m_window->m_realPosition->goal();
     m_sizeTo  = m_window->m_realSize->goal();
 
-    m_window->m_alpha->setValueAndWarp(m_alphaFrom);
+    m_window->alpha(WINDOW_ALPHA_FADE)->setValueAndWarp(m_alphaFrom);
     m_window->m_realPosition->setValueAndWarp(m_posFrom);
     m_window->m_realSize->setValueAndWarp(m_sizeFrom);
 
@@ -61,7 +63,7 @@ void CCloseTrackpadGesture::update(const ITrackpadGesture::STrackpadGestureUpdat
 
     const auto FADEPERCENT = std::clamp(m_lastDelta / MAX_DISTANCE, 0.F, 1.F);
 
-    m_window->m_alpha->setValueAndWarp(lerpVal(m_alphaFrom, m_alphaTo, FADEPERCENT));
+    m_window->alpha(WINDOW_ALPHA_FADE)->setValueAndWarp(lerpVal(m_alphaFrom, m_alphaTo, FADEPERCENT));
     m_window->m_realPosition->setValueAndWarp(lerpVal(m_posFrom, m_posTo, FADEPERCENT));
     m_window->m_realSize->setValueAndWarp(lerpVal(m_sizeFrom, m_sizeTo, FADEPERCENT));
 
@@ -81,20 +83,20 @@ void CCloseTrackpadGesture::end(const ITrackpadGesture::STrackpadGestureEnd& e)
     if (COMPLETION < 0.2F) {
         // revert the animation
         g_pHyprRenderer->damageWindow(m_window.lock());
-        *m_window->m_alpha        = m_alphaFrom;
-        *m_window->m_realPosition = m_posFrom;
-        *m_window->m_realSize     = m_sizeFrom;
+        *m_window->alpha(WINDOW_ALPHA_FADE) = m_alphaFrom;
+        *m_window->m_realPosition           = m_posFrom;
+        *m_window->m_realSize               = m_sizeFrom;
         return;
     }
 
     // commence. Close the window and restore our current state to avoid a harsh anim
-    const auto CURRENT_ALPHA = m_window->m_alpha->value();
+    const auto CURRENT_ALPHA = m_window->alphaValue(WINDOW_ALPHA_FADE);
     const auto CURRENT_POS   = m_window->m_realPosition->value();
     const auto CURRENT_SIZE  = m_window->m_realSize->value();
 
     Desktop::focusState()->window()->sendClose();
 
-    m_window->m_alpha->setValueAndWarp(CURRENT_ALPHA);
+    m_window->alpha(WINDOW_ALPHA_FADE)->setValueAndWarp(CURRENT_ALPHA);
     m_window->m_realPosition->setValueAndWarp(CURRENT_POS);
     m_window->m_realSize->setValueAndWarp(CURRENT_SIZE);
 
@@ -136,7 +138,7 @@ void CCloseTrackpadGesture::end(const ITrackpadGesture::STrackpadGestureEnd& e)
             window->layoutTarget()->recalc();
             window->updateDecorationValues();
             window->sendWindowSize(true);
-            *window->m_alpha = 1.F;
+            *window->alpha(WINDOW_ALPHA_FADE) = 1.F;
         },
         nullptr);
     trackpadCloseTimers.emplace_back(timer);
diff --git a/src/managers/screenshare/ScreenshareFrame.cpp b/src/managers/screenshare/ScreenshareFrame.cpp
index 66d64999..7a596d0c 100644
--- a/src/managers/screenshare/ScreenshareFrame.cpp
+++ b/src/managers/screenshare/ScreenshareFrame.cpp
@@ -18,6 +18,7 @@
 
 using namespace Hyprgraphics::Egl;
 using namespace Screenshare;
+using namespace Desktop::View;
 
 CScreenshareFrame::CScreenshareFrame(WP<CScreenshareSession> session, bool overlayCursor, bool isFirst) :
     m_session(session), m_bufferSize(m_session->bufferSize()), m_overlayCursor(overlayCursor), m_isFirst(isFirst) {
@@ -259,7 +260,7 @@ void CScreenshareFrame::renderMonitor() {
 
         const auto PWORKSPACE = w->m_workspace;
 
-        if UNLIKELY (!PWORKSPACE && !w->m_fadingOut && w->m_alpha->value() != 0.f)
+        if UNLIKELY (!PWORKSPACE && !w->m_fadingOut && w->alphaValue(WINDOW_ALPHA_FADE) * w->alphaValue(WINDOW_ALPHA_FULLSCREEN) != 0.f)
             continue;
 
         const auto renderOffset     = PWORKSPACE && !w->m_pinned ? PWORKSPACE->m_renderOffset->value() : Vector2D{};
diff --git a/src/render/OpenGL.cpp b/src/render/OpenGL.cpp
index a87ec2ee..08c50de1 100644
--- a/src/render/OpenGL.cpp
+++ b/src/render/OpenGL.cpp
@@ -59,6 +59,7 @@
 
 using namespace Hyprutils::OS;
 using namespace NColorManagement;
+using namespace Desktop::View;
 using namespace Render;
 using namespace Render::GL;
 
@@ -1867,7 +1868,8 @@ void CHyprOpenGLImpl::preRender(PHLMONITOR pMonitor) {
         const auto  PSURFACE = pWindow->wlSurface()->resource();
 
         const auto  PWORKSPACE = pWindow->m_workspace;
-        const float A          = pWindow->m_alpha->value() * pWindow->m_activeInactiveAlpha->value() * PWORKSPACE->m_alpha->value();
+        const float A          = pWindow->alphaValue(WINDOW_ALPHA_FADE) * pWindow->alphaValue(WINDOW_ALPHA_FULLSCREEN) * pWindow->alphaValue(WINDOW_ALPHA_LAYOUT) *
+            pWindow->alphaValue(WINDOW_ALPHA_ACTIVE) * PWORKSPACE->m_alpha->value();
 
         if (A >= 1.f) {
             // if (PSURFACE->opaque)
diff --git a/src/render/Renderer.cpp b/src/render/Renderer.cpp
index fa1a8a06..81f7b723 100644
--- a/src/render/Renderer.cpp
+++ b/src/render/Renderer.cpp
@@ -68,6 +68,7 @@ using namespace Hyprutils::Utils;
 using namespace Hyprutils::OS;
 using enum NContentType::eContentType;
 using namespace NColorManagement;
+using namespace Desktop::View;
 using namespace Render;
 
 extern "C" {
@@ -234,8 +235,8 @@ bool IHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor) {
         return true;
 
     // if the window is being moved to a workspace that is not invisible, and the alpha is > 0.F, render it.
-    if (pWindow->m_monitorMovedFrom != -1 && pWindow->m_movingToWorkspaceAlpha->isBeingAnimated() && pWindow->m_movingToWorkspaceAlpha->value() > 0.F && pWindow->m_workspace &&
-        !pWindow->m_workspace->isVisible())
+    if (pWindow->m_monitorMovedFrom != -1 && pWindow->alpha(WINDOW_ALPHA_MOVE_TO_WORKSPACE)->isBeingAnimated() && pWindow->alphaValue(WINDOW_ALPHA_MOVE_TO_WORKSPACE) > 0.F &&
+        pWindow->m_workspace && !pWindow->m_workspace->isVisible())
         return true;
 
     const auto PWINDOWWORKSPACE = pWindow->m_workspace;
@@ -244,7 +245,8 @@ bool IHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor) {
             return true;
 
         // if hidden behind fullscreen
-        if (PWINDOWWORKSPACE->m_hasFullscreenWindow && !pWindow->isFullscreen() && (!pWindow->m_isFloating || !pWindow->m_createdOverFullscreen) && pWindow->m_alpha->value() == 0)
+        if (PWINDOWWORKSPACE->m_hasFullscreenWindow && !pWindow->isFullscreen() && (!pWindow->m_isFloating || !pWindow->m_createdOverFullscreen) &&
+            pWindow->alphaValue(WINDOW_ALPHA_FADE) * pWindow->alphaValue(WINDOW_ALPHA_FULLSCREEN) == 0)
             return false;
 
         if (!PWINDOWWORKSPACE->m_renderOffset->isBeingAnimated() && !PWINDOWWORKSPACE->m_alpha->isBeingAnimated() && !PWINDOWWORKSPACE->isVisible())
@@ -325,7 +327,7 @@ void IHyprRenderer::renderWorkspaceWindowsFullscreen(PHLMONITOR pMonitor, PHLWOR
         if (!shouldRenderWindow(w, pMonitor))
             continue;
 
-        if (w->m_alpha->value() == 0.f)
+        if (w->alphaValue(WINDOW_ALPHA_FADE) * w->alphaValue(WINDOW_ALPHA_FULLSCREEN) == 0.f)
             continue;
 
         if (w->isFullscreen())
@@ -569,9 +571,10 @@ void IHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
 
     renderdata.surface   = pWindow->wlSurface()->resource();
     renderdata.dontRound = pWindow->isEffectiveInternalFSMode(FSMODE_FULLSCREEN);
-    renderdata.fadeAlpha = pWindow->m_alpha->value() * (pWindow->m_pinned || USE_WORKSPACE_FADE_ALPHA ? 1.f : PWORKSPACE->m_alpha->value()) *
-        (USE_WORKSPACE_FADE_ALPHA ? pWindow->m_movingToWorkspaceAlpha->value() : 1.F) * pWindow->m_movingFromWorkspaceAlpha->value();
-    renderdata.alpha         = pWindow->m_activeInactiveAlpha->value();
+    renderdata.fadeAlpha = pWindow->alphaValue(WINDOW_ALPHA_FADE) * pWindow->alphaValue(WINDOW_ALPHA_FULLSCREEN) * pWindow->alphaValue(WINDOW_ALPHA_LAYOUT) *
+        (pWindow->m_pinned || USE_WORKSPACE_FADE_ALPHA ? 1.f : PWORKSPACE->m_alpha->value()) *
+        (USE_WORKSPACE_FADE_ALPHA ? pWindow->alphaValue(WINDOW_ALPHA_MOVE_TO_WORKSPACE) : 1.F) * pWindow->alphaValue(WINDOW_ALPHA_MOVE_FROM_WORKSPACE);
+    renderdata.alpha         = pWindow->alphaValue(WINDOW_ALPHA_ACTIVE);
     renderdata.decorate      = decorate && !pWindow->m_X11DoesntWantBorders && !pWindow->isEffectiveInternalFSMode(FSMODE_FULLSCREEN);
     renderdata.rounding      = standalone || renderdata.dontRound ? 0 : pWindow->rounding() * pMonitor->m_scale;
     renderdata.roundingPower = standalone || renderdata.dontRound ? 2.0f : pWindow->roundingPower();
@@ -3145,8 +3148,9 @@ void IHyprRenderer::renderSnapshot(PHLWINDOW pWindow) {
     if (*PDIMAROUND && pWindow->m_ruleApplicator->dimAround().valueOrDefault()) {
         CRectPassElement::SRectData data;
 
-        data.box   = {0, 0, m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y};
-        data.color = CHyprColor(0, 0, 0, *PDIMAROUND * pWindow->m_alpha->value());
+        data.box = {0, 0, m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y};
+        data.color =
+            CHyprColor(0, 0, 0, *PDIMAROUND * pWindow->alphaValue(WINDOW_ALPHA_FADE) * pWindow->alphaValue(WINDOW_ALPHA_FULLSCREEN) * pWindow->alphaValue(WINDOW_ALPHA_LAYOUT));
 
         m_renderPass.add(makeUnique<CRectPassElement>(data));
     }
@@ -3156,7 +3160,8 @@ void IHyprRenderer::renderSnapshot(PHLWINDOW pWindow) {
         data.box           = CBox{pWindow->m_realPosition->value(), pWindow->m_realSize->value()}.translate(-PMONITOR->m_position).scale(PMONITOR->m_scale).round();
         data.color         = CHyprColor{0, 0, 0, 0};
         data.blur          = true;
-        data.blurA         = sqrt(pWindow->m_alpha->value()); // sqrt makes the blur fadeout more realistic.
+        data.blurA         = sqrt(pWindow->alphaValue(WINDOW_ALPHA_FADE) * pWindow->alphaValue(WINDOW_ALPHA_FULLSCREEN) *
+                                  pWindow->alphaValue(WINDOW_ALPHA_LAYOUT)); // sqrt makes the blur fadeout more realistic.
         data.round         = pWindow->rounding();
         data.roundingPower = pWindow->roundingPower();
         data.xray          = pWindow->m_ruleApplicator->xray().valueOr(false);
@@ -3168,7 +3173,7 @@ void IHyprRenderer::renderSnapshot(PHLWINDOW pWindow) {
     data.flipEndFrame = true;
     data.tex          = FBDATA->getTexture();
     data.box          = windowBox;
-    data.a            = pWindow->m_alpha->value();
+    data.a            = pWindow->alphaValue(WINDOW_ALPHA_FADE) * pWindow->alphaValue(WINDOW_ALPHA_FULLSCREEN) * pWindow->alphaValue(WINDOW_ALPHA_LAYOUT);
     data.damage       = fakeDamage;
 
     m_renderPass.add(makeUnique<CTexPassElement>(std::move(data)));