core: move parts of the animation system to hyprutils (#8868)

* core: change animation manager to use Hyprutils::Animation

* config: move animation config to hyprutils animation tree

* use g_pAnimationManager->createAnimation and the new PHLANIMVAR template

* core: use CGenericAnimatedVariabled::{enabled,setConfig,getStyle} and adapt callbacks

* core: adapt animated variable usage (dereference the shared pointer)

* misc: bump CMakeLists to hyprutils 0.3.3

8 files changed, 363 insertions, 464 deletions

diff --git a/src/managers/AnimationManager.cpp b/src/managers/AnimationManager.cpp
index cff438b1..6bfeed83 100644
--- a/src/managers/AnimationManager.cpp
+++ b/src/managers/AnimationManager.cpp
@@ -1,6 +1,9 @@
 #include "AnimationManager.hpp"
 #include "../Compositor.hpp"
 #include "HookSystemManager.hpp"
+#include "config/ConfigManager.hpp"
+#include "desktop/DesktopTypes.hpp"
+#include "helpers/AnimatedVariable.hpp"
 #include "macros.hpp"
 #include "../config/ConfigValue.hpp"
 #include "../desktop/Window.hpp"
@@ -9,6 +12,8 @@
 #include "../helpers/varlist/VarList.hpp"
 
 #include <hyprgraphics/color/Color.hpp>
+#include <hyprutils/animation/AnimatedVariable.hpp>
+#include <hyprutils/animation/AnimationManager.hpp>
 
 static int wlTick(SP<CEventLoopTimer> self, void* data) {
     if (g_pAnimationManager)
@@ -26,324 +31,245 @@ static int wlTick(SP<CEventLoopTimer> self, void* data) {
     return 0;
 }
 
-CAnimationManager::CAnimationManager() {
-    std::vector<Vector2D> points = {Vector2D(0.0, 0.75), Vector2D(0.15, 1.0)};
-    m_mBezierCurves["default"].setup(&points);
-
-    points = {Vector2D(0.0, 0.0), Vector2D(1.0, 1.0)};
-    m_mBezierCurves["linear"].setup(&points);
-
+CHyprAnimationManager::CHyprAnimationManager() {
     m_pAnimationTimer = SP<CEventLoopTimer>(new CEventLoopTimer(std::chrono::microseconds(500), wlTick, nullptr));
     g_pEventLoopManager->addTimer(m_pAnimationTimer);
-}
-
-void CAnimationManager::removeAllBeziers() {
-    m_mBezierCurves.clear();
 
-    // add the default one
-    std::vector<Vector2D> points = {Vector2D(0.0, 0.75), Vector2D(0.15, 1.0)};
-    m_mBezierCurves["default"].setup(&points);
-
-    points = {Vector2D(0.0, 0.0), Vector2D(1.0, 1.0)};
-    m_mBezierCurves["linear"].setup(&points);
+    addBezierWithName("linear", Vector2D(0.0, 0.0), Vector2D(1.0, 1.0));
 }
 
-void CAnimationManager::addBezierWithName(std::string name, const Vector2D& p1, const Vector2D& p2) {
-    std::vector points = {p1, p2};
-    m_mBezierCurves[name].setup(&points);
-}
+template <Animable VarType>
+void updateVariable(CAnimatedVariable<VarType>& av, const float POINTY, bool warp = false) {
+    if (POINTY >= 1.f || warp || av.value() == av.goal()) {
+        av.warp();
+        return;
+    }
 
-void CAnimationManager::onTicked() {
-    m_bTickScheduled = false;
+    const auto DELTA = av.goal() - av.begun();
+    av.value()       = av.begun() + DELTA * POINTY;
 }
 
-void CAnimationManager::tick() {
-    static std::chrono::time_point lastTick = std::chrono::high_resolution_clock::now();
-    m_fLastTickTime                         = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - lastTick).count() / 1000.0;
-    lastTick                                = std::chrono::high_resolution_clock::now();
-
-    if (m_vActiveAnimatedVariables.empty())
+void updateColorVariable(CAnimatedVariable<CHyprColor>& av, const float POINTY, bool warp) {
+    if (POINTY >= 1.f || warp || av.value() == av.goal()) {
+        av.warp();
         return;
+    }
 
-    bool        animGlobalDisabled = false;
-
-    static auto PANIMENABLED = CConfigValue<Hyprlang::INT>("animations:enabled");
-
-    if (!*PANIMENABLED)
-        animGlobalDisabled = true;
+    // convert both to OkLab, then lerp that, and convert back.
+    // This is not as fast as just lerping rgb, but it's WAY more precise...
+    // Use the CHyprColor cache for OkLab
 
-    static auto* const                  PSHADOWSENABLED = (Hyprlang::INT* const*)g_pConfigManager->getConfigValuePtr("decoration:shadow:enabled");
+    const auto&                L1 = av.begun().asOkLab();
+    const auto&                L2 = av.goal().asOkLab();
 
-    const auto                          DEFAULTBEZIER = m_mBezierCurves.find("default");
+    static const auto          lerp = [](const float one, const float two, const float progress) -> float { return one + (two - one) * progress; };
 
-    std::vector<CBaseAnimatedVariable*> animationEndedVars;
+    const Hyprgraphics::CColor lerped = Hyprgraphics::CColor::SOkLab{
+        .l = lerp(L1.l, L2.l, POINTY),
+        .a = lerp(L1.a, L2.a, POINTY),
+        .b = lerp(L1.b, L2.b, POINTY),
+    };
 
-    for (auto const& av : m_vActiveAnimatedVariables) {
+    av.value() = {lerped, lerp(av.begun().a, av.goal().a, POINTY)};
+}
 
-        if (av->m_eDamagePolicy == AVARDAMAGE_SHADOW && !*PSHADOWSENABLED) {
-            av->warp(false);
-            animationEndedVars.push_back(av);
-            continue;
+template <Animable VarType>
+static void handleUpdate(CAnimatedVariable<VarType>& av, bool warp) {
+    PHLWINDOW    PWINDOW            = av.m_Context.pWindow.lock();
+    PHLWORKSPACE PWORKSPACE         = av.m_Context.pWorkspace.lock();
+    PHLLS        PLAYER             = av.m_Context.pLayer.lock();
+    PHLMONITOR   PMONITOR           = nullptr;
+    bool         animationsDisabled = warp;
+
+    if (PWINDOW) {
+        if (av.m_Context.eDamagePolicy == AVARDAMAGE_ENTIRE)
+            g_pHyprRenderer->damageWindow(PWINDOW);
+        else if (av.m_Context.eDamagePolicy == AVARDAMAGE_BORDER) {
+            const auto PDECO = PWINDOW->getDecorationByType(DECORATION_BORDER);
+            PDECO->damageEntire();
+        } else if (av.m_Context.eDamagePolicy == AVARDAMAGE_SHADOW) {
+            const auto PDECO = PWINDOW->getDecorationByType(DECORATION_SHADOW);
+            PDECO->damageEntire();
         }
 
-        // get the spent % (0 - 1)
-        const float SPENT = av->getPercent();
+        PMONITOR = PWINDOW->m_pMonitor.lock();
+        if (!PMONITOR)
+            return;
 
-        // window stuff
-        PHLWINDOW    PWINDOW            = av->m_pWindow.lock();
-        PHLWORKSPACE PWORKSPACE         = av->m_pWorkspace.lock();
-        PHLLS        PLAYER             = av->m_pLayer.lock();
-        PHLMONITOR   PMONITOR           = nullptr;
-        bool         animationsDisabled = animGlobalDisabled;
+        animationsDisabled = PWINDOW->m_sWindowData.noAnim.valueOr(animationsDisabled);
+    } else if (PWORKSPACE) {
+        PMONITOR = PWORKSPACE->m_pMonitor.lock();
+        if (!PMONITOR)
+            return;
 
-        if (PWINDOW) {
-            if (av->m_eDamagePolicy == AVARDAMAGE_ENTIRE) {
-                g_pHyprRenderer->damageWindow(PWINDOW);
-            } else if (av->m_eDamagePolicy == AVARDAMAGE_BORDER) {
-                const auto PDECO = PWINDOW->getDecorationByType(DECORATION_BORDER);
-                PDECO->damageEntire();
-            } else if (av->m_eDamagePolicy == AVARDAMAGE_SHADOW) {
-                const auto PDECO = PWINDOW->getDecorationByType(DECORATION_SHADOW);
-                PDECO->damageEntire();
-            }
+        // dont damage the whole monitor on workspace change, unless it's a special workspace, because dim/blur etc
+        if (PWORKSPACE->m_bIsSpecialWorkspace)
+            g_pHyprRenderer->damageMonitor(PMONITOR);
 
-            PMONITOR = PWINDOW->m_pMonitor.lock();
-            if (!PMONITOR)
-                continue;
-            animationsDisabled = PWINDOW->m_sWindowData.noAnim.valueOr(animationsDisabled);
-        } else if (PWORKSPACE) {
-            PMONITOR = PWORKSPACE->m_pMonitor.lock();
-            if (!PMONITOR)
+        // TODO: just make this into a damn callback already vax...
+        for (auto const& w : g_pCompositor->m_vWindows) {
+            if (!w->m_bIsMapped || w->isHidden() || w->m_pWorkspace != PWORKSPACE)
                 continue;
 
-            // dont damage the whole monitor on workspace change, unless it's a special workspace, because dim/blur etc
-            if (PWORKSPACE->m_bIsSpecialWorkspace)
-                g_pHyprRenderer->damageMonitor(PMONITOR);
-
-            // TODO: just make this into a damn callback already vax...
-            for (auto const& w : g_pCompositor->m_vWindows) {
-                if (!w->m_bIsMapped || w->isHidden() || w->m_pWorkspace != PWORKSPACE)
-                    continue;
-
-                if (w->m_bIsFloating && !w->m_bPinned) {
-                    // still doing the full damage hack for floating because sometimes when the window
-                    // goes through multiple monitors the last rendered frame is missing damage somehow??
-                    const CBox windowBoxNoOffset = w->getFullWindowBoundingBox();
-                    const CBox monitorBox        = {PMONITOR->vecPosition, PMONITOR->vecSize};
-                    if (windowBoxNoOffset.intersection(monitorBox) != windowBoxNoOffset) // on edges between multiple monitors
-                        g_pHyprRenderer->damageWindow(w, true);
-                }
-
-                if (PWORKSPACE->m_bIsSpecialWorkspace)
-                    g_pHyprRenderer->damageWindow(w, true); // hack for special too because it can cross multiple monitors
+            if (w->m_bIsFloating && !w->m_bPinned) {
+                // still doing the full damage hack for floating because sometimes when the window
+                // goes through multiple monitors the last rendered frame is missing damage somehow??
+                const CBox windowBoxNoOffset = w->getFullWindowBoundingBox();
+                const CBox monitorBox        = {PMONITOR->vecPosition, PMONITOR->vecSize};
+                if (windowBoxNoOffset.intersection(monitorBox) != windowBoxNoOffset) // on edges between multiple monitors
+                    g_pHyprRenderer->damageWindow(w, true);
             }
 
-            // damage any workspace window that is on any monitor
-            for (auto const& w : g_pCompositor->m_vWindows) {
-                if (!validMapped(w) || w->m_pWorkspace != PWORKSPACE || w->m_bPinned)
-                    continue;
-
-                g_pHyprRenderer->damageWindow(w);
-            }
-        } else if (PLAYER) {
-            // "some fucking layers miss 1 pixel???" -- vaxry
-            CBox expandBox = CBox{PLAYER->realPosition.value(), PLAYER->realSize.value()};
-            expandBox.expand(5);
-            g_pHyprRenderer->damageBox(&expandBox);
-
-            PMONITOR = g_pCompositor->getMonitorFromVector(PLAYER->realPosition.goal() + PLAYER->realSize.goal() / 2.F);
-            if (!PMONITOR)
-                continue;
-            animationsDisabled = animationsDisabled || PLAYER->noAnimations;
+            if (PWORKSPACE->m_bIsSpecialWorkspace)
+                g_pHyprRenderer->damageWindow(w, true); // hack for special too because it can cross multiple monitors
         }
 
-        const bool VISIBLE = PWINDOW && PWINDOW->m_pWorkspace ? PWINDOW->m_pWorkspace->isVisible() : true;
+        // damage any workspace window that is on any monitor
+        for (auto const& w : g_pCompositor->m_vWindows) {
+            if (!validMapped(w) || w->m_pWorkspace != PWORKSPACE || w->m_bPinned)
+                continue;
 
-        // beziers are with a switch unforto
-        // TODO: maybe do something cleaner
+            g_pHyprRenderer->damageWindow(w);
+        }
+    } else if (PLAYER) {
+        // "some fucking layers miss 1 pixel???" -- vaxry
+        CBox expandBox = CBox{PLAYER->realPosition->value(), PLAYER->realSize->value()};
+        expandBox.expand(5);
+        g_pHyprRenderer->damageBox(&expandBox);
+
+        PMONITOR = g_pCompositor->getMonitorFromVector(PLAYER->realPosition->goal() + PLAYER->realSize->goal() / 2.F);
+        if (!PMONITOR)
+            return;
+        animationsDisabled = animationsDisabled || PLAYER->noAnimations;
+    }
 
-        static const auto updateVariable = [this]<Animable T>(CAnimatedVariable<T>& av, const float SPENT, const CBezierCurve& DEFAULTBEZIER, const bool DISABLED) {
-            // for disabled anims just warp
-            if (av.m_pConfig->pValues->internalEnabled == 0 || DISABLED) {
-                av.warp(false);
-                return;
-            }
+    const auto SPENT   = av.getPercent();
+    const auto PBEZIER = g_pAnimationManager->getBezier(av.getBezierName());
+    const auto POINTY  = PBEZIER->getYForPoint(SPENT);
 
-            if (SPENT >= 1.f || av.m_Begun == av.m_Goal) {
-                av.warp(false);
-                return;
-            }
+    if constexpr (std::same_as<VarType, CHyprColor>) {
+        updateColorVariable(av, POINTY, animationsDisabled);
+    } else {
+        updateVariable<VarType>(av, POINTY, animationsDisabled);
+    }
 
-            const auto BEZIER = m_mBezierCurves.find(av.m_pConfig->pValues->internalBezier);
-            const auto POINTY = BEZIER != m_mBezierCurves.end() ? BEZIER->second.getYForPoint(SPENT) : DEFAULTBEZIER.getYForPoint(SPENT);
+    av.onUpdate();
 
-            const auto DELTA = av.m_Goal - av.m_Begun;
+    switch (av.m_Context.eDamagePolicy) {
+        case AVARDAMAGE_ENTIRE: {
+            if (PWINDOW) {
+                PWINDOW->updateWindowDecos();
+                g_pHyprRenderer->damageWindow(PWINDOW);
+            } else if (PWORKSPACE) {
+                for (auto const& w : g_pCompositor->m_vWindows) {
+                    if (!validMapped(w) || w->m_pWorkspace != PWORKSPACE)
+                        continue;
 
-            if (BEZIER != m_mBezierCurves.end())
-                av.m_Value = av.m_Begun + DELTA * POINTY;
-            else
-                av.m_Value = av.m_Begun + DELTA * POINTY;
-        };
+                    w->updateWindowDecos();
 
-        static const auto updateColorVariable = [this](CAnimatedVariable<CHyprColor>& av, const float SPENT, const CBezierCurve& DEFAULTBEZIER, const bool DISABLED) {
-            // for disabled anims just warp
-            if (av.m_pConfig->pValues->internalEnabled == 0 || DISABLED) {
-                av.warp(false);
-                return;
+                    // damage any workspace window that is on any monitor
+                    if (!w->m_bPinned)
+                        g_pHyprRenderer->damageWindow(w);
+                }
+            } else if (PLAYER) {
+                if (PLAYER->layer <= 1)
+                    g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR);
+
+                // some fucking layers miss 1 pixel???
+                CBox expandBox = CBox{PLAYER->realPosition->value(), PLAYER->realSize->value()};
+                expandBox.expand(5);
+                g_pHyprRenderer->damageBox(&expandBox);
             }
+            break;
+        }
+        case AVARDAMAGE_BORDER: {
+            RASSERT(PWINDOW, "Tried to AVARDAMAGE_BORDER a non-window AVAR!");
 
-            if (SPENT >= 1.f || av.m_Begun == av.m_Goal) {
-                av.warp(false);
-                return;
-            }
+            const auto PDECO = PWINDOW->getDecorationByType(DECORATION_BORDER);
+            PDECO->damageEntire();
 
-            const auto BEZIER = m_mBezierCurves.find(av.m_pConfig->pValues->internalBezier);
-            const auto POINTY = BEZIER != m_mBezierCurves.end() ? BEZIER->second.getYForPoint(SPENT) : DEFAULTBEZIER.getYForPoint(SPENT);
+            break;
+        }
+        case AVARDAMAGE_SHADOW: {
+            RASSERT(PWINDOW, "Tried to AVARDAMAGE_SHADOW a non-window AVAR!");
 
-            // convert both to OkLab, then lerp that, and convert back.
-            // This is not as fast as just lerping rgb, but it's WAY more precise...
-            // Use the CHyprColor cache for OkLab
+            const auto PDECO = PWINDOW->getDecorationByType(DECORATION_SHADOW);
 
-            const auto&                L1 = av.m_Begun.asOkLab();
-            const auto&                L2 = av.m_Goal.asOkLab();
+            PDECO->damageEntire();
 
-            static const auto          lerp = [](const float one, const float two, const float progress) -> float { return one + (two - one) * progress; };
+            break;
+        }
+        default: {
+            break;
+        }
+    }
 
-            const Hyprgraphics::CColor lerped = Hyprgraphics::CColor::SOkLab{
-                .l = lerp(L1.l, L2.l, POINTY),
-                .a = lerp(L1.a, L2.a, POINTY),
-                .b = lerp(L1.b, L2.b, POINTY),
-            };
+    // manually schedule a frame
+    if (PMONITOR)
+        g_pCompositor->scheduleFrameForMonitor(PMONITOR, Aquamarine::IOutput::AQ_SCHEDULE_ANIMATION);
+}
+
+void CHyprAnimationManager::tick() {
+    static std::chrono::time_point lastTick = std::chrono::high_resolution_clock::now();
+    m_fLastTickTime                         = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - lastTick).count() / 1000.0;
+    lastTick                                = std::chrono::high_resolution_clock::now();
 
-            av.m_Value = {lerped, lerp(av.m_Begun.a, av.m_Goal.a, POINTY)};
+    static auto PANIMENABLED = CConfigValue<Hyprlang::INT>("animations:enabled");
+    for (auto const& pav : m_vActiveAnimatedVariables) {
+        const auto PAV = pav.lock();
+        if (!PAV)
+            continue;
 
-            return;
-        };
+        // for disabled anims just warp
+        bool warp = !*PANIMENABLED || !PAV->enabled();
 
-        switch (av->m_Type) {
+        switch (PAV->m_Type) {
             case AVARTYPE_FLOAT: {
-                auto typedAv = dynamic_cast<CAnimatedVariable<float>*>(av);
-                updateVariable(*typedAv, SPENT, DEFAULTBEZIER->second, animationsDisabled);
-                break;
-            }
+                auto pTypedAV = dynamic_cast<CAnimatedVariable<float>*>(PAV.get());
+                RASSERT(pTypedAV, "Failed to upcast animated float");
+                handleUpdate(*pTypedAV, warp);
+            } break;
             case AVARTYPE_VECTOR: {
-                auto typedAv = dynamic_cast<CAnimatedVariable<Vector2D>*>(av);
-                updateVariable(*typedAv, SPENT, DEFAULTBEZIER->second, animationsDisabled);
-                break;
-            }
+                auto pTypedAV = dynamic_cast<CAnimatedVariable<Vector2D>*>(PAV.get());
+                RASSERT(pTypedAV, "Failed to upcast animated Vector2D");
+                handleUpdate(*pTypedAV, warp);
+            } break;
             case AVARTYPE_COLOR: {
-                auto typedAv = dynamic_cast<CAnimatedVariable<CHyprColor>*>(av);
-                updateColorVariable(*typedAv, SPENT, DEFAULTBEZIER->second, animationsDisabled);
-                break;
-            }
+                auto pTypedAV = dynamic_cast<CAnimatedVariable<CHyprColor>*>(PAV.get());
+                RASSERT(pTypedAV, "Failed to upcast animated CHyprColor");
+                handleUpdate(*pTypedAV, warp);
+            } break;
             default: UNREACHABLE();
         }
-        // set size and pos if valid, but only if damage policy entire (dont if border for example)
-        if (validMapped(PWINDOW) && av->m_eDamagePolicy == AVARDAMAGE_ENTIRE && !PWINDOW->isX11OverrideRedirect())
-            g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goal());
-
-        // check if we did not finish animating. If so, trigger onAnimationEnd.
-        if (!av->isBeingAnimated())
-            animationEndedVars.push_back(av);
-
-        // lastly, handle damage, but only if whatever we are animating is visible.
-        if (!VISIBLE)
-            continue;
-
-        if (av->m_fUpdateCallback)
-            av->m_fUpdateCallback(av);
-
-        switch (av->m_eDamagePolicy) {
-            case AVARDAMAGE_ENTIRE: {
-                if (PWINDOW) {
-                    PWINDOW->updateWindowDecos();
-                    g_pHyprRenderer->damageWindow(PWINDOW);
-                } else if (PWORKSPACE) {
-                    for (auto const& w : g_pCompositor->m_vWindows) {
-                        if (!validMapped(w) || w->m_pWorkspace != PWORKSPACE)
-                            continue;
-
-                        w->updateWindowDecos();
-
-                        // damage any workspace window that is on any monitor
-                        if (!w->m_bPinned)
-                            g_pHyprRenderer->damageWindow(w);
-                    }
-                } else if (PLAYER) {
-                    if (PLAYER->layer <= 1)
-                        g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR);
-
-                    // some fucking layers miss 1 pixel???
-                    CBox expandBox = CBox{PLAYER->realPosition.value(), PLAYER->realSize.value()};
-                    expandBox.expand(5);
-                    g_pHyprRenderer->damageBox(&expandBox);
-                }
-                break;
-            }
-            case AVARDAMAGE_BORDER: {
-                RASSERT(PWINDOW, "Tried to AVARDAMAGE_BORDER a non-window AVAR!");
-
-                const auto PDECO = PWINDOW->getDecorationByType(DECORATION_BORDER);
-                PDECO->damageEntire();
-
-                break;
-            }
-            case AVARDAMAGE_SHADOW: {
-                RASSERT(PWINDOW, "Tried to AVARDAMAGE_SHADOW a non-window AVAR!");
+    }
 
-                const auto PDECO = PWINDOW->getDecorationByType(DECORATION_SHADOW);
+    tickDone();
+}
 
-                PDECO->damageEntire();
+void CHyprAnimationManager::scheduleTick() {
+    if (m_bTickScheduled)
+        return;
 
-                break;
-            }
-            default: {
-                break;
-            }
-        }
+    m_bTickScheduled = true;
 
-        // manually schedule a frame
-        if (PMONITOR)
-            g_pCompositor->scheduleFrameForMonitor(PMONITOR, Aquamarine::IOutput::AQ_SCHEDULE_ANIMATION);
-    }
+    const auto PMOSTHZ = g_pHyprRenderer->m_pMostHzMonitor;
 
-    // do it here, because if this alters the animation vars vec we would be in trouble above.
-    for (auto const& ave : animationEndedVars) {
-        ave->onAnimationEnd();
+    if (!PMOSTHZ) {
+        m_pAnimationTimer->updateTimeout(std::chrono::milliseconds(16));
+        return;
     }
-}
-
-bool CAnimationManager::deltaSmallToFlip(const Vector2D& a, const Vector2D& b) {
-    return std::abs(a.x - b.x) < 0.5f && std::abs(a.y - b.y) < 0.5f;
-}
-
-bool CAnimationManager::deltaSmallToFlip(const CHyprColor& a, const CHyprColor& b) {
-    return std::abs(a.r - b.r) < 0.5f && std::abs(a.g - b.g) < 0.5f && std::abs(a.b - b.b) < 0.5f && std::abs(a.a - b.a) < 0.5f;
-}
 
-bool CAnimationManager::deltaSmallToFlip(const float& a, const float& b) {
-    return std::abs(a - b) < 0.5f;
-}
+    float       refreshDelayMs = std::floor(1000.f / PMOSTHZ->refreshRate);
 
-bool CAnimationManager::deltazero(const Vector2D& a, const Vector2D& b) {
-    return a.x == b.x && a.y == b.y;
-}
+    const float SINCEPRES = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - PMOSTHZ->lastPresentationTimer.chrono()).count() / 1000.f;
 
-bool CAnimationManager::deltazero(const float& a, const float& b) {
-    return a == b;
-}
+    const auto  TOPRES = std::clamp(refreshDelayMs - SINCEPRES, 1.1f, 1000.f); // we can't send 0, that will disarm it
 
-bool CAnimationManager::deltazero(const CHyprColor& a, const CHyprColor& b) {
-    return a.r == b.r && a.g == b.g && a.b == b.b && a.a == b.a;
+    m_pAnimationTimer->updateTimeout(std::chrono::milliseconds((int)std::floor(TOPRES)));
 }
 
-bool CAnimationManager::bezierExists(const std::string& bezier) {
-    for (auto const& [bc, bz] : m_mBezierCurves) {
-        if (bc == bezier)
-            return true;
-    }
-
-    return false;
+void CHyprAnimationManager::onTicked() {
+    m_bTickScheduled = false;
 }
 
 //
@@ -351,24 +277,24 @@ bool CAnimationManager::bezierExists(const std::string& bezier) {
 //
 //
 
-void CAnimationManager::animationPopin(PHLWINDOW pWindow, bool close, float minPerc) {
-    const auto GOALPOS  = pWindow->m_vRealPosition.goal();
-    const auto GOALSIZE = pWindow->m_vRealSize.goal();
+void CHyprAnimationManager::animationPopin(PHLWINDOW pWindow, bool close, float minPerc) {
+    const auto GOALPOS  = pWindow->m_vRealPosition->goal();
+    const auto GOALSIZE = pWindow->m_vRealSize->goal();
 
     if (!close) {
-        pWindow->m_vRealSize.setValue((GOALSIZE * minPerc).clamp({5, 5}, {GOALSIZE.x, GOALSIZE.y}));
-        pWindow->m_vRealPosition.setValue(GOALPOS + GOALSIZE / 2.f - pWindow->m_vRealSize.m_Value / 2.f);
+        pWindow->m_vRealSize->setValue((GOALSIZE * minPerc).clamp({5, 5}, {GOALSIZE.x, GOALSIZE.y}));
+        pWindow->m_vRealPosition->setValue(GOALPOS + GOALSIZE / 2.f - pWindow->m_vRealSize->value() / 2.f);
     } else {
-        pWindow->m_vRealSize     = (GOALSIZE * minPerc).clamp({5, 5}, {GOALSIZE.x, GOALSIZE.y});
-        pWindow->m_vRealPosition = GOALPOS + GOALSIZE / 2.f - pWindow->m_vRealSize.m_Goal / 2.f;
+        *pWindow->m_vRealSize     = (GOALSIZE * minPerc).clamp({5, 5}, {GOALSIZE.x, GOALSIZE.y});
+        *pWindow->m_vRealPosition = GOALPOS + GOALSIZE / 2.f - pWindow->m_vRealSize->goal() / 2.f;
     }
 }
 
-void CAnimationManager::animationSlide(PHLWINDOW pWindow, std::string force, bool close) {
-    pWindow->m_vRealSize.warp(false); // size we preserve in slide
+void CHyprAnimationManager::animationSlide(PHLWINDOW pWindow, std::string force, bool close) {
+    pWindow->m_vRealSize->warp(false); // size we preserve in slide
 
-    const auto GOALPOS  = pWindow->m_vRealPosition.goal();
-    const auto GOALSIZE = pWindow->m_vRealSize.goal();
+    const auto GOALPOS  = pWindow->m_vRealPosition->goal();
+    const auto GOALSIZE = pWindow->m_vRealSize->goal();
 
     const auto PMONITOR = pWindow->m_pMonitor.lock();
 
@@ -388,9 +314,9 @@ void CAnimationManager::animationSlide(PHLWINDOW pWindow, std::string force, boo
             posOffset = Vector2D(GOALPOS.x, PMONITOR->vecPosition.y - GOALSIZE.y);
 
         if (!close)
-            pWindow->m_vRealPosition.setValue(posOffset);
+            pWindow->m_vRealPosition->setValue(posOffset);
         else
-            pWindow->m_vRealPosition = posOffset;
+            *pWindow->m_vRealPosition = posOffset;
 
         return;
     }
@@ -423,33 +349,33 @@ void CAnimationManager::animationSlide(PHLWINDOW pWindow, std::string force, boo
     }
 
     if (!close)
-        pWindow->m_vRealPosition.setValue(posOffset);
+        pWindow->m_vRealPosition->setValue(posOffset);
     else
-        pWindow->m_vRealPosition = posOffset;
+        *pWindow->m_vRealPosition = posOffset;
 }
 
-void CAnimationManager::onWindowPostCreateClose(PHLWINDOW pWindow, bool close) {
+void CHyprAnimationManager::onWindowPostCreateClose(PHLWINDOW pWindow, bool close) {
     if (!close) {
-        pWindow->m_vRealPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("windowsIn");
-        pWindow->m_vRealSize.m_pConfig     = g_pConfigManager->getAnimationPropertyConfig("windowsIn");
-        pWindow->m_fAlpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig("fadeIn");
+        pWindow->m_vRealPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("windowsIn"));
+        pWindow->m_vRealSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("windowsIn"));
+        pWindow->m_fAlpha->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeIn"));
     } else {
-        pWindow->m_vRealPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("windowsOut");
-        pWindow->m_vRealSize.m_pConfig     = g_pConfigManager->getAnimationPropertyConfig("windowsOut");
-        pWindow->m_fAlpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig("fadeOut");
+        pWindow->m_vRealPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("windowsOut"));
+        pWindow->m_vRealSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("windowsOut"));
+        pWindow->m_fAlpha->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeOut"));
     }
 
-    auto ANIMSTYLE = pWindow->m_vRealPosition.m_pConfig->pValues->internalStyle;
+    std::string ANIMSTYLE = pWindow->m_vRealPosition->getStyle();
     transform(ANIMSTYLE.begin(), ANIMSTYLE.end(), ANIMSTYLE.begin(), ::tolower);
 
     CVarList animList(ANIMSTYLE, 0, 's');
 
     // if the window is not being animated, that means the layout set a fixed size for it, don't animate.
-    if (!pWindow->m_vRealPosition.isBeingAnimated() && !pWindow->m_vRealSize.isBeingAnimated())
+    if (!pWindow->m_vRealPosition->isBeingAnimated() && !pWindow->m_vRealSize->isBeingAnimated())
         return;
 
     // if the animation is disabled and we are leaving, ignore the anim to prevent the snapshot being fucked
-    if (!pWindow->m_vRealPosition.m_pConfig->pValues->internalEnabled)
+    if (!pWindow->m_vRealPosition->enabled())
         return;
 
     if (pWindow->m_sWindowData.animationStyle.hasValue()) {
@@ -494,7 +420,7 @@ void CAnimationManager::onWindowPostCreateClose(PHLWINDOW pWindow, bool close) {
     }
 }
 
-std::string CAnimationManager::styleValidInConfigVar(const std::string& config, const std::string& style) {
+std::string CHyprAnimationManager::styleValidInConfigVar(const std::string& config, const std::string& style) {
     if (config.starts_with("window")) {
         if (style.starts_with("slide"))
             return "";
@@ -568,39 +494,3 @@ std::string CAnimationManager::styleValidInConfigVar(const std::string& config,
 
     return "";
 }
-
-CBezierCurve* CAnimationManager::getBezier(const std::string& name) {
-    const auto BEZIER = std::find_if(m_mBezierCurves.begin(), m_mBezierCurves.end(), [&](const auto& other) { return other.first == name; });
-
-    return BEZIER == m_mBezierCurves.end() ? &m_mBezierCurves["default"] : &BEZIER->second;
-}
-
-std::unordered_map<std::string, CBezierCurve> CAnimationManager::getAllBeziers() {
-    return m_mBezierCurves;
-}
-
-bool CAnimationManager::shouldTickForNext() {
-    return !m_vActiveAnimatedVariables.empty();
-}
-
-void CAnimationManager::scheduleTick() {
-    if (m_bTickScheduled)
-        return;
-
-    m_bTickScheduled = true;
-
-    const auto PMOSTHZ = g_pHyprRenderer->m_pMostHzMonitor;
-
-    if (!PMOSTHZ) {
-        m_pAnimationTimer->updateTimeout(std::chrono::milliseconds(16));
-        return;
-    }
-
-    float       refreshDelayMs = std::floor(1000.f / PMOSTHZ->refreshRate);
-
-    const float SINCEPRES = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - PMOSTHZ->lastPresentationTimer.chrono()).count() / 1000.f;
-
-    const auto  TOPRES = std::clamp(refreshDelayMs - SINCEPRES, 1.1f, 1000.f); // we can't send 0, that will disarm it
-
-    m_pAnimationTimer->updateTimeout(std::chrono::milliseconds((int)std::floor(TOPRES)));
-}
diff --git a/src/managers/AnimationManager.hpp b/src/managers/AnimationManager.hpp
index 3960f261..7bf73f97 100644
--- a/src/managers/AnimationManager.hpp
+++ b/src/managers/AnimationManager.hpp
@@ -1,57 +1,64 @@
 #pragma once
 
+#include <hyprutils/animation/AnimationManager.hpp>
+#include <hyprutils/animation/AnimatedVariable.hpp>
+
 #include "../defines.hpp"
-#include <list>
-#include <unordered_map>
 #include "../helpers/AnimatedVariable.hpp"
-#include "../helpers/BezierCurve.hpp"
-#include "../helpers/Timer.hpp"
+#include "desktop/DesktopTypes.hpp"
 #include "eventLoop/EventLoopTimer.hpp"
 
-class CWindow;
-
-class CAnimationManager {
+class CHyprAnimationManager : public Hyprutils::Animation::CAnimationManager {
   public:
-    CAnimationManager();
+    CHyprAnimationManager();
 
-    void                                          tick();
-    bool                                          shouldTickForNext();
-    void                                          onTicked();
-    void                                          scheduleTick();
-    void                                          addBezierWithName(std::string, const Vector2D&, const Vector2D&);
-    void                                          removeAllBeziers();
+    void         tick();
+    virtual void scheduleTick();
+    virtual void onTicked();
 
-    void                                          onWindowPostCreateClose(PHLWINDOW, bool close = false);
+    using SAnimationPropertyConfig = Hyprutils::Animation::SAnimationPropertyConfig;
+    template <Animable VarType>
+    void createAnimation(const VarType& v, PHLANIMVAR<VarType>& pav, SP<SAnimationPropertyConfig> pConfig, eAVarDamagePolicy policy) {
+        constexpr const eAnimatedVarType EAVTYPE = typeToeAnimatedVarType<VarType>;
+        const auto                       PAV     = makeShared<CAnimatedVariable<VarType>>();
 
-    bool                                          bezierExists(const std::string&);
-    CBezierCurve*                                 getBezier(const std::string&);
+        PAV->create(EAVTYPE, static_cast<Hyprutils::Animation::CAnimationManager*>(this), PAV, v);
+        PAV->setConfig(pConfig);
+        PAV->m_Context.eDamagePolicy = policy;
 
-    std::string                                   styleValidInConfigVar(const std::string&, const std::string&);
+        pav = std::move(PAV);
+    }
 
-    std::unordered_map<std::string, CBezierCurve> getAllBeziers();
+    template <Animable VarType>
+    void createAnimation(const VarType& v, PHLANIMVAR<VarType>& pav, SP<SAnimationPropertyConfig> pConfig, PHLWINDOW pWindow, eAVarDamagePolicy policy) {
+        createAnimation(v, pav, pConfig, policy);
+        pav->m_Context.pWindow = pWindow;
+    }
+    template <Animable VarType>
+    void createAnimation(const VarType& v, PHLANIMVAR<VarType>& pav, SP<SAnimationPropertyConfig> pConfig, PHLWORKSPACE pWorkspace, eAVarDamagePolicy policy) {
+        createAnimation(v, pav, pConfig, policy);
+        pav->m_Context.pWorkspace = pWorkspace;
+    }
+    template <Animable VarType>
+    void createAnimation(const VarType& v, PHLANIMVAR<VarType>& pav, SP<SAnimationPropertyConfig> pConfig, PHLLS pLayer, eAVarDamagePolicy policy) {
+        createAnimation(v, pav, pConfig, policy);
+        pav->m_Context.pLayer = pLayer;
+    }
 
-    std::vector<CBaseAnimatedVariable*>           m_vAnimatedVariables;
-    std::vector<CBaseAnimatedVariable*>           m_vActiveAnimatedVariables;
+    void                onWindowPostCreateClose(PHLWINDOW, bool close = false);
 
-    SP<CEventLoopTimer>                           m_pAnimationTimer;
+    std::string         styleValidInConfigVar(const std::string&, const std::string&);
 
-    float                                         m_fLastTickTime; // in ms
+    SP<CEventLoopTimer> m_pAnimationTimer;
 
-  private:
-    bool                                          deltaSmallToFlip(const Vector2D& a, const Vector2D& b);
-    bool                                          deltaSmallToFlip(const CHyprColor& a, const CHyprColor& b);
-    bool                                          deltaSmallToFlip(const float& a, const float& b);
-    bool                                          deltazero(const Vector2D& a, const Vector2D& b);
-    bool                                          deltazero(const CHyprColor& a, const CHyprColor& b);
-    bool                                          deltazero(const float& a, const float& b);
+    float               m_fLastTickTime; // in ms
 
-    std::unordered_map<std::string, CBezierCurve> m_mBezierCurves;
-
-    bool                                          m_bTickScheduled = false;
+  private:
+    bool m_bTickScheduled = false;
 
     // Anim stuff
     void animationPopin(PHLWINDOW, bool close = false, float minPerc = 0.f);
     void animationSlide(PHLWINDOW, std::string force = "", bool close = false);
 };
 
-inline std::unique_ptr<CAnimationManager> g_pAnimationManager;
+inline std::unique_ptr<CHyprAnimationManager> g_pAnimationManager;
diff --git a/src/managers/KeybindManager.cpp b/src/managers/KeybindManager.cpp
index d368d14c..fd4992eb 100644
--- a/src/managers/KeybindManager.cpp
+++ b/src/managers/KeybindManager.cpp
@@ -377,8 +377,8 @@ void CKeybindManager::switchToWindow(PHLWINDOW PWINDOWTOCHANGETO) {
             g_pCompositor->setWindowFullscreenInternal(PWINDOWTOCHANGETO, MODE);
 
         // warp the position + size animation, otherwise it looks weird.
-        PWINDOWTOCHANGETO->m_vRealPosition.warp();
-        PWINDOWTOCHANGETO->m_vRealSize.warp();
+        PWINDOWTOCHANGETO->m_vRealPosition->warp();
+        PWINDOWTOCHANGETO->m_vRealSize->warp();
     } else {
         updateRelativeCursorCoords();
         g_pCompositor->focusWindow(PWINDOWTOCHANGETO);
@@ -1070,8 +1070,8 @@ SDispatchResult CKeybindManager::centerWindow(std::string args) {
     if (args == "1")
         RESERVEDOFFSET = (PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight) / 2.f;
 
-    PWINDOW->m_vRealPosition = PMONITOR->middle() - PWINDOW->m_vRealSize.goal() / 2.f + RESERVEDOFFSET;
-    PWINDOW->m_vPosition     = PWINDOW->m_vRealPosition.goal();
+    *PWINDOW->m_vRealPosition = PMONITOR->middle() - PWINDOW->m_vRealSize->goal() / 2.f + RESERVEDOFFSET;
+    PWINDOW->m_vPosition      = PWINDOW->m_vRealPosition->goal();
 
     return {};
 }
@@ -1557,14 +1557,14 @@ SDispatchResult CKeybindManager::moveActiveTo(std::string args) {
 
         switch (arg) {
             case 'l': vPosx = PMONITOR->vecReservedTopLeft.x + BORDERSIZE + PMONITOR->vecPosition.x; break;
-            case 'r': vPosx = PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PLASTWINDOW->m_vRealSize.goal().x - BORDERSIZE + PMONITOR->vecPosition.x; break;
+            case 'r': vPosx = PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PLASTWINDOW->m_vRealSize->goal().x - BORDERSIZE + PMONITOR->vecPosition.x; break;
             case 't':
             case 'u': vPosy = PMONITOR->vecReservedTopLeft.y + BORDERSIZE + PMONITOR->vecPosition.y; break;
             case 'b':
-            case 'd': vPosy = PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PLASTWINDOW->m_vRealSize.goal().y - BORDERSIZE + PMONITOR->vecPosition.y; break;
+            case 'd': vPosy = PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PLASTWINDOW->m_vRealSize->goal().y - BORDERSIZE + PMONITOR->vecPosition.y; break;
         }
 
-        PLASTWINDOW->m_vRealPosition = Vector2D(vPosx.value_or(PLASTWINDOW->m_vRealPosition.goal().x), vPosy.value_or(PLASTWINDOW->m_vRealPosition.goal().y));
+        *PLASTWINDOW->m_vRealPosition = Vector2D(vPosx.value_or(PLASTWINDOW->m_vRealPosition->goal().x), vPosy.value_or(PLASTWINDOW->m_vRealPosition->goal().y));
 
         return {};
     }
@@ -1735,20 +1735,20 @@ SDispatchResult CKeybindManager::moveCursorToCorner(std::string arg) {
     switch (CORNER) {
         case 0:
             // bottom left
-            g_pCompositor->warpCursorTo({PWINDOW->m_vRealPosition.value().x, PWINDOW->m_vRealPosition.value().y + PWINDOW->m_vRealSize.value().y}, true);
+            g_pCompositor->warpCursorTo({PWINDOW->m_vRealPosition->value().x, PWINDOW->m_vRealPosition->value().y + PWINDOW->m_vRealSize->value().y}, true);
             break;
         case 1:
             // bottom right
-            g_pCompositor->warpCursorTo({PWINDOW->m_vRealPosition.value().x + PWINDOW->m_vRealSize.value().x, PWINDOW->m_vRealPosition.value().y + PWINDOW->m_vRealSize.value().y},
-                                        true);
+            g_pCompositor->warpCursorTo(
+                {PWINDOW->m_vRealPosition->value().x + PWINDOW->m_vRealSize->value().x, PWINDOW->m_vRealPosition->value().y + PWINDOW->m_vRealSize->value().y}, true);
             break;
         case 2:
             // top right
-            g_pCompositor->warpCursorTo({PWINDOW->m_vRealPosition.value().x + PWINDOW->m_vRealSize.value().x, PWINDOW->m_vRealPosition.value().y}, true);
+            g_pCompositor->warpCursorTo({PWINDOW->m_vRealPosition->value().x + PWINDOW->m_vRealSize->value().x, PWINDOW->m_vRealPosition->value().y}, true);
             break;
         case 3:
             // top left
-            g_pCompositor->warpCursorTo({PWINDOW->m_vRealPosition.value().x, PWINDOW->m_vRealPosition.value().y}, true);
+            g_pCompositor->warpCursorTo({PWINDOW->m_vRealPosition->value().x, PWINDOW->m_vRealPosition->value().y}, true);
             break;
     }
 
@@ -1817,18 +1817,18 @@ SDispatchResult CKeybindManager::workspaceOpt(std::string args) {
                 continue;
 
             if (!w->m_bRequestsFloat && w->m_bIsFloating != PWORKSPACE->m_bDefaultFloating) {
-                const auto SAVEDPOS  = w->m_vRealPosition.value();
-                const auto SAVEDSIZE = w->m_vRealSize.value();
+                const auto SAVEDPOS  = w->m_vRealPosition->value();
+                const auto SAVEDSIZE = w->m_vRealSize->value();
 
                 w->m_bIsFloating = PWORKSPACE->m_bDefaultFloating;
                 g_pLayoutManager->getCurrentLayout()->changeWindowFloatingMode(w);
 
                 if (PWORKSPACE->m_bDefaultFloating) {
-                    w->m_vRealPosition.setValueAndWarp(SAVEDPOS);
-                    w->m_vRealSize.setValueAndWarp(SAVEDSIZE);
+                    w->m_vRealPosition->setValueAndWarp(SAVEDPOS);
+                    w->m_vRealSize->setValueAndWarp(SAVEDSIZE);
                     g_pXWaylandManager->setWindowSize(w, SAVEDSIZE);
-                    w->m_vRealSize     = w->m_vRealSize.value() + Vector2D(4, 4);
-                    w->m_vRealPosition = w->m_vRealPosition.value() - Vector2D(2, 2);
+                    *w->m_vRealSize     = w->m_vRealSize->value() + Vector2D(4, 4);
+                    *w->m_vRealPosition = w->m_vRealPosition->value() - Vector2D(2, 2);
                 }
             }
         }
@@ -2043,14 +2043,14 @@ SDispatchResult CKeybindManager::resizeActive(std::string args) {
     if (!PLASTWINDOW || PLASTWINDOW->isFullscreen())
         return {};
 
-    const auto SIZ = g_pCompositor->parseWindowVectorArgsRelative(args, PLASTWINDOW->m_vRealSize.goal());
+    const auto SIZ = g_pCompositor->parseWindowVectorArgsRelative(args, PLASTWINDOW->m_vRealSize->goal());
 
     if (SIZ.x < 1 || SIZ.y < 1)
         return {};
 
-    g_pLayoutManager->getCurrentLayout()->resizeActiveWindow(SIZ - PLASTWINDOW->m_vRealSize.goal());
+    g_pLayoutManager->getCurrentLayout()->resizeActiveWindow(SIZ - PLASTWINDOW->m_vRealSize->goal());
 
-    if (PLASTWINDOW->m_vRealSize.goal().x > 1 && PLASTWINDOW->m_vRealSize.goal().y > 1)
+    if (PLASTWINDOW->m_vRealSize->goal().x > 1 && PLASTWINDOW->m_vRealSize->goal().y > 1)
         PLASTWINDOW->setHidden(false);
 
     return {};
@@ -2062,9 +2062,9 @@ SDispatchResult CKeybindManager::moveActive(std::string args) {
     if (!PLASTWINDOW || PLASTWINDOW->isFullscreen())
         return {};
 
-    const auto POS = g_pCompositor->parseWindowVectorArgsRelative(args, PLASTWINDOW->m_vRealPosition.goal());
+    const auto POS = g_pCompositor->parseWindowVectorArgsRelative(args, PLASTWINDOW->m_vRealPosition->goal());
 
-    g_pLayoutManager->getCurrentLayout()->moveActiveWindow(POS - PLASTWINDOW->m_vRealPosition.goal());
+    g_pLayoutManager->getCurrentLayout()->moveActiveWindow(POS - PLASTWINDOW->m_vRealPosition->goal());
 
     return {};
 }
@@ -2084,9 +2084,9 @@ SDispatchResult CKeybindManager::moveWindow(std::string args) {
     if (PWINDOW->isFullscreen())
         return {};
 
-    const auto POS = g_pCompositor->parseWindowVectorArgsRelative(MOVECMD, PWINDOW->m_vRealPosition.goal());
+    const auto POS = g_pCompositor->parseWindowVectorArgsRelative(MOVECMD, PWINDOW->m_vRealPosition->goal());
 
-    g_pLayoutManager->getCurrentLayout()->moveActiveWindow(POS - PWINDOW->m_vRealPosition.goal(), PWINDOW);
+    g_pLayoutManager->getCurrentLayout()->moveActiveWindow(POS - PWINDOW->m_vRealPosition->goal(), PWINDOW);
 
     return {};
 }
@@ -2106,14 +2106,14 @@ SDispatchResult CKeybindManager::resizeWindow(std::string args) {
     if (PWINDOW->isFullscreen())
         return {};
 
-    const auto SIZ = g_pCompositor->parseWindowVectorArgsRelative(MOVECMD, PWINDOW->m_vRealSize.goal());
+    const auto SIZ = g_pCompositor->parseWindowVectorArgsRelative(MOVECMD, PWINDOW->m_vRealSize->goal());
 
     if (SIZ.x < 1 || SIZ.y < 1)
         return {};
 
-    g_pLayoutManager->getCurrentLayout()->resizeActiveWindow(SIZ - PWINDOW->m_vRealSize.goal(), CORNER_NONE, PWINDOW);
+    g_pLayoutManager->getCurrentLayout()->resizeActiveWindow(SIZ - PWINDOW->m_vRealSize->goal(), CORNER_NONE, PWINDOW);
 
-    if (PWINDOW->m_vRealSize.goal().x > 1 && PWINDOW->m_vRealSize.goal().y > 1)
+    if (PWINDOW->m_vRealSize->goal().x > 1 && PWINDOW->m_vRealSize->goal().y > 1)
         PWINDOW->setHidden(false);
 
     return {};
@@ -2192,8 +2192,8 @@ SDispatchResult CKeybindManager::focusWindow(std::string regexp) {
                 g_pCompositor->setWindowFullscreenClient(PWINDOW, FSMODE);
 
             // warp the position + size animation, otherwise it looks weird.
-            PWINDOW->m_vRealPosition.warp();
-            PWINDOW->m_vRealSize.warp();
+            PWINDOW->m_vRealPosition->warp();
+            PWINDOW->m_vRealSize->warp();
         }
     } else
         g_pCompositor->focusWindow(PWINDOW);
@@ -2311,7 +2311,7 @@ SDispatchResult CKeybindManager::pass(std::string regexp) {
         }
     }
 
-    const auto SL = PWINDOW->m_vRealPosition.goal() - g_pInputManager->getMouseCoordsInternal();
+    const auto SL = PWINDOW->m_vRealPosition->goal() - g_pInputManager->getMouseCoordsInternal();
 
     if (g_pKeybindManager->m_uLastCode != 0)
         g_pSeatManager->setKeyboardFocus(LASTKBSURF);
@@ -2466,7 +2466,7 @@ SDispatchResult CKeybindManager::sendshortcut(std::string args) {
         }
     }
 
-    const auto SL = PWINDOW->m_vRealPosition.goal() - g_pInputManager->getMouseCoordsInternal();
+    const auto SL = PWINDOW->m_vRealPosition->goal() - g_pInputManager->getMouseCoordsInternal();
 
     if (!isMouse)
         g_pSeatManager->setKeyboardFocus(LASTSURFACE);
diff --git a/src/managers/XWaylandManager.cpp b/src/managers/XWaylandManager.cpp
index ca31752d..bc988f39 100644
--- a/src/managers/XWaylandManager.cpp
+++ b/src/managers/XWaylandManager.cpp
@@ -55,7 +55,7 @@ void CHyprXWaylandManager::activateWindow(PHLWINDOW pWindow, bool activate) {
     if (pWindow->m_bIsX11) {
 
         if (activate) {
-            setWindowSize(pWindow, pWindow->m_vRealSize.value()); // update xwayland output pos
+            setWindowSize(pWindow, pWindow->m_vRealSize->value()); // update xwayland output pos
             pWindow->m_pXWaylandSurface->setMinimized(false);
 
             if (!pWindow->isX11OverrideRedirect())
@@ -123,7 +123,7 @@ void CHyprXWaylandManager::setWindowSize(PHLWINDOW pWindow, Vector2D size, bool
 
     // calculate pos
     // TODO: this should be decoupled from setWindowSize IMO
-    Vector2D windowPos = pWindow->m_vRealPosition.value();
+    Vector2D windowPos = pWindow->m_vRealPosition->value();
 
     if (pWindow->m_bIsX11 && PMONITOR) {
         windowPos -= PMONITOR->vecPosition; // normalize to monitor
@@ -273,4 +273,4 @@ Vector2D CHyprXWaylandManager::xwaylandToWaylandCoords(const Vector2D& coord) {
     result += pMonitor->vecPosition;
 
     return result;
-}
\ No newline at end of file
+}
diff --git a/src/managers/input/InputManager.cpp b/src/managers/input/InputManager.cpp
index cccaa43e..8a50a7bf 100644
--- a/src/managers/input/InputManager.cpp
+++ b/src/managers/input/InputManager.cpp
@@ -137,7 +137,7 @@ void CInputManager::sendMotionEventsToFocused() {
     timespec   now;
     clock_gettime(CLOCK_MONOTONIC, &now);
 
-    const auto LOCAL = getMouseCoordsInternal() - (PWINDOW ? PWINDOW->m_vRealPosition.goal() : (PLS ? Vector2D{PLS->geometry.x, PLS->geometry.y} : Vector2D{}));
+    const auto LOCAL = getMouseCoordsInternal() - (PWINDOW ? PWINDOW->m_vRealPosition->goal() : (PLS ? Vector2D{PLS->geometry.x, PLS->geometry.y} : Vector2D{}));
 
     m_bEmptyFocusCursorSet = false;
 
@@ -243,7 +243,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
 
     if (forcedFocus) {
         pFoundWindow = forcedFocus;
-        surfacePos   = pFoundWindow->m_vRealPosition.value();
+        surfacePos   = pFoundWindow->m_vRealPosition->value();
         foundSurface = pFoundWindow->m_pWLSurface->resource();
     }
 
@@ -320,7 +320,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
             surfacePos   = Vector2D(-1337, -1337);
         } else {
             foundSurface = pFoundWindow->m_pWLSurface->resource();
-            surfacePos   = pFoundWindow->m_vRealPosition.value();
+            surfacePos   = pFoundWindow->m_vRealPosition->value();
         }
     }
 
@@ -362,11 +362,11 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
                 foundSurface = g_pCompositor->vectorWindowToSurface(mouseCoords, pFoundWindow, surfaceCoords);
                 if (!foundSurface) {
                     foundSurface = pFoundWindow->m_pWLSurface->resource();
-                    surfacePos   = pFoundWindow->m_vRealPosition.value();
+                    surfacePos   = pFoundWindow->m_vRealPosition->value();
                 }
             } else {
                 foundSurface = pFoundWindow->m_pWLSurface->resource();
-                surfacePos   = pFoundWindow->m_vRealPosition.value();
+                surfacePos   = pFoundWindow->m_vRealPosition->value();
             }
         }
     }
@@ -689,7 +689,7 @@ void CInputManager::processMouseDownNormal(const IPointer::SButtonEvent& e) {
     // TODO detect click on LS properly
     if (*PRESIZEONBORDER && !m_bLastFocusOnLS && e.state == WL_POINTER_BUTTON_STATE_PRESSED && (!w || !w->isX11OverrideRedirect())) {
         if (w && !w->isFullscreen()) {
-            const CBox real = {w->m_vRealPosition.value().x, w->m_vRealPosition.value().y, w->m_vRealSize.value().x, w->m_vRealSize.value().y};
+            const CBox real = {w->m_vRealPosition->value().x, w->m_vRealPosition->value().y, w->m_vRealSize->value().x, w->m_vRealSize->value().y};
             const CBox grab = {real.x - BORDER_GRAB_AREA, real.y - BORDER_GRAB_AREA, real.width + 2 * BORDER_GRAB_AREA, real.height + 2 * BORDER_GRAB_AREA};
 
             if ((grab.containsPoint(mouseCoords) && (!real.containsPoint(mouseCoords) || w->isInCurvedCorner(mouseCoords.x, mouseCoords.y))) && !w->hasPopupAt(mouseCoords)) {
diff --git a/src/managers/input/Swipe.cpp b/src/managers/input/Swipe.cpp
index 6cfe5a24..3e03c4c7 100644
--- a/src/managers/input/Swipe.cpp
+++ b/src/managers/input/Swipe.cpp
@@ -38,7 +38,7 @@ void CInputManager::beginWorkspaceSwipe() {
 
     if (PWORKSPACE->m_bHasFullscreenWindow) {
         for (auto const& ls : g_pCompositor->m_pLastMonitor->m_aLayerSurfaceLayers[2]) {
-            ls->alpha = 1.f;
+            *ls->alpha = 1.f;
         }
     }
 }
@@ -58,8 +58,8 @@ void CInputManager::endWorkspaceSwipe() {
     static auto PSWIPENEW     = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_create_new");
     static auto PSWIPEUSER    = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_use_r");
     static auto PWORKSPACEGAP = CConfigValue<Hyprlang::INT>("general:gaps_workspaces");
-    const bool  VERTANIMS     = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.getConfig()->pValues->internalStyle == "slidevert" ||
-        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.getConfig()->pValues->internalStyle.starts_with("slidefadevert");
+    const auto  ANIMSTYLE     = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->getStyle();
+    const bool  VERTANIMS     = ANIMSTYLE == "slidevert" || ANIMSTYLE.starts_with("slidefadevert");
 
     // commit
     auto       workspaceIDLeft  = getWorkspaceIDNameFromString((*PSWIPEUSER ? "r-1" : "m-1")).id;
@@ -86,7 +86,7 @@ void CInputManager::endWorkspaceSwipe() {
     auto         PWORKSPACER = g_pCompositor->getWorkspaceByID(workspaceIDRight); // not guaranteed if PSWIPENEW || PSWIPENUMBER
     auto         PWORKSPACEL = g_pCompositor->getWorkspaceByID(workspaceIDLeft);  // not guaranteed if PSWIPENUMBER
 
-    const auto   RENDEROFFSETMIDDLE = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.value();
+    const auto   RENDEROFFSETMIDDLE = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->value();
     const auto   XDISTANCE          = m_sActiveSwipe.pMonitor->vecSize.x + *PWORKSPACEGAP;
     const auto   YDISTANCE          = m_sActiveSwipe.pMonitor->vecSize.y + *PWORKSPACEGAP;
 
@@ -97,35 +97,35 @@ void CInputManager::endWorkspaceSwipe() {
         // revert
         if (abs(m_sActiveSwipe.delta) < 2) {
             if (PWORKSPACEL)
-                PWORKSPACEL->m_vRenderOffset.setValueAndWarp(Vector2D(0, 0));
+                PWORKSPACEL->m_vRenderOffset->setValueAndWarp(Vector2D(0, 0));
             if (PWORKSPACER)
-                PWORKSPACER->m_vRenderOffset.setValueAndWarp(Vector2D(0, 0));
-            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(0, 0));
+                PWORKSPACER->m_vRenderOffset->setValueAndWarp(Vector2D(0, 0));
+            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(0, 0));
         } else {
             if (m_sActiveSwipe.delta < 0) {
                 // to left
 
                 if (PWORKSPACEL) {
                     if (VERTANIMS)
-                        PWORKSPACEL->m_vRenderOffset = Vector2D{0.0, -YDISTANCE};
+                        *PWORKSPACEL->m_vRenderOffset = Vector2D{0.0, -YDISTANCE};
                     else
-                        PWORKSPACEL->m_vRenderOffset = Vector2D{-XDISTANCE, 0.0};
+                        *PWORKSPACEL->m_vRenderOffset = Vector2D{-XDISTANCE, 0.0};
                 }
             } else if (PWORKSPACER) {
                 // to right
                 if (VERTANIMS)
-                    PWORKSPACER->m_vRenderOffset = Vector2D{0.0, YDISTANCE};
+                    *PWORKSPACER->m_vRenderOffset = Vector2D{0.0, YDISTANCE};
                 else
-                    PWORKSPACER->m_vRenderOffset = Vector2D{XDISTANCE, 0.0};
+                    *PWORKSPACER->m_vRenderOffset = Vector2D{XDISTANCE, 0.0};
             }
 
-            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D();
+            *m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D();
         }
 
         pSwitchedTo = m_sActiveSwipe.pWorkspaceBegin;
     } else if (m_sActiveSwipe.delta < 0) {
         // switch to left
-        const auto RENDEROFFSET = PWORKSPACEL ? PWORKSPACEL->m_vRenderOffset.value() : Vector2D();
+        const auto RENDEROFFSET = PWORKSPACEL ? PWORKSPACEL->m_vRenderOffset->value() : Vector2D();
 
         if (PWORKSPACEL)
             m_sActiveSwipe.pMonitor->changeWorkspace(workspaceIDLeft);
@@ -134,15 +134,15 @@ void CInputManager::endWorkspaceSwipe() {
             PWORKSPACEL = g_pCompositor->getWorkspaceByID(workspaceIDLeft);
         }
 
-        PWORKSPACEL->m_vRenderOffset.setValue(RENDEROFFSET);
-        PWORKSPACEL->m_fAlpha.setValueAndWarp(1.f);
+        PWORKSPACEL->m_vRenderOffset->setValue(RENDEROFFSET);
+        PWORKSPACEL->m_fAlpha->setValueAndWarp(1.f);
 
-        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValue(RENDEROFFSETMIDDLE);
+        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValue(RENDEROFFSETMIDDLE);
         if (VERTANIMS)
-            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(0.0, YDISTANCE);
+            *m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(0.0, YDISTANCE);
         else
-            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(XDISTANCE, 0.0);
-        m_sActiveSwipe.pWorkspaceBegin->m_fAlpha.setValueAndWarp(1.f);
+            *m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(XDISTANCE, 0.0);
+        m_sActiveSwipe.pWorkspaceBegin->m_fAlpha->setValueAndWarp(1.f);
 
         g_pInputManager->unconstrainMouse();
 
@@ -151,7 +151,7 @@ void CInputManager::endWorkspaceSwipe() {
         pSwitchedTo = PWORKSPACEL;
     } else {
         // switch to right
-        const auto RENDEROFFSET = PWORKSPACER ? PWORKSPACER->m_vRenderOffset.value() : Vector2D();
+        const auto RENDEROFFSET = PWORKSPACER ? PWORKSPACER->m_vRenderOffset->value() : Vector2D();
 
         if (PWORKSPACER)
             m_sActiveSwipe.pMonitor->changeWorkspace(workspaceIDRight);
@@ -160,15 +160,15 @@ void CInputManager::endWorkspaceSwipe() {
             PWORKSPACER = g_pCompositor->getWorkspaceByID(workspaceIDRight);
         }
 
-        PWORKSPACER->m_vRenderOffset.setValue(RENDEROFFSET);
-        PWORKSPACER->m_fAlpha.setValueAndWarp(1.f);
+        PWORKSPACER->m_vRenderOffset->setValue(RENDEROFFSET);
+        PWORKSPACER->m_fAlpha->setValueAndWarp(1.f);
 
-        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValue(RENDEROFFSETMIDDLE);
+        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValue(RENDEROFFSETMIDDLE);
         if (VERTANIMS)
-            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(0.0, -YDISTANCE);
+            *m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(0.0, -YDISTANCE);
         else
-            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(-XDISTANCE, 0.0);
-        m_sActiveSwipe.pWorkspaceBegin->m_fAlpha.setValueAndWarp(1.f);
+            *m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(-XDISTANCE, 0.0);
+        m_sActiveSwipe.pWorkspaceBegin->m_fAlpha->setValueAndWarp(1.f);
 
         g_pInputManager->unconstrainMouse();
 
@@ -193,7 +193,7 @@ void CInputManager::endWorkspaceSwipe() {
 
     // apply alpha
     for (auto const& ls : g_pCompositor->m_pLastMonitor->m_aLayerSurfaceLayers[2]) {
-        ls->alpha = pSwitchedTo->m_bHasFullscreenWindow && pSwitchedTo->m_efFullscreenMode == FSMODE_FULLSCREEN ? 0.f : 1.f;
+        *ls->alpha = pSwitchedTo->m_bHasFullscreenWindow && pSwitchedTo->m_efFullscreenMode == FSMODE_FULLSCREEN ? 0.f : 1.f;
     }
 }
 
@@ -202,30 +202,30 @@ void CInputManager::onSwipeUpdate(IPointer::SSwipeUpdateEvent e) {
 
     if (!m_sActiveSwipe.pWorkspaceBegin)
         return;
-    static auto PSWIPEINVR = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_invert");
-    const bool  VERTANIMS  = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.getConfig()->pValues->internalStyle == "slidevert" ||
-        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.getConfig()->pValues->internalStyle.starts_with("slidefadevert");
+    static auto  PSWIPEINVR = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_invert");
+    const auto   ANIMSTYLE  = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->getStyle();
+    const bool   VERTANIMS  = ANIMSTYLE == "slidevert" || ANIMSTYLE.starts_with("slidefadevert");
 
     const double delta = m_sActiveSwipe.delta + (VERTANIMS ? (*PSWIPEINVR ? -e.delta.y : e.delta.y) : (*PSWIPEINVR ? -e.delta.x : e.delta.x));
     updateWorkspaceSwipe(delta);
 }
 
 void CInputManager::updateWorkspaceSwipe(double delta) {
-    static auto PSWIPEDIST             = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_distance");
-    static auto PSWIPENEW              = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_create_new");
-    static auto PSWIPEDIRLOCK          = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_direction_lock");
-    static auto PSWIPEDIRLOCKTHRESHOLD = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_direction_lock_threshold");
-    static auto PSWIPEFOREVER          = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_forever");
-    static auto PSWIPEUSER             = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_use_r");
-    static auto PWORKSPACEGAP          = CConfigValue<Hyprlang::INT>("general:gaps_workspaces");
-
-    const auto  SWIPEDISTANCE = std::clamp(*PSWIPEDIST, (int64_t)1LL, (int64_t)UINT32_MAX);
-    const auto  XDISTANCE     = m_sActiveSwipe.pMonitor->vecSize.x + *PWORKSPACEGAP;
-    const auto  YDISTANCE     = m_sActiveSwipe.pMonitor->vecSize.y + *PWORKSPACEGAP;
-    const bool  VERTANIMS     = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.getConfig()->pValues->internalStyle == "slidevert" ||
-        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.getConfig()->pValues->internalStyle.starts_with("slidefadevert");
-    const double d       = m_sActiveSwipe.delta - delta;
-    m_sActiveSwipe.delta = delta;
+    static auto  PSWIPEDIST             = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_distance");
+    static auto  PSWIPENEW              = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_create_new");
+    static auto  PSWIPEDIRLOCK          = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_direction_lock");
+    static auto  PSWIPEDIRLOCKTHRESHOLD = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_direction_lock_threshold");
+    static auto  PSWIPEFOREVER          = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_forever");
+    static auto  PSWIPEUSER             = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_use_r");
+    static auto  PWORKSPACEGAP          = CConfigValue<Hyprlang::INT>("general:gaps_workspaces");
+
+    const auto   SWIPEDISTANCE = std::clamp(*PSWIPEDIST, (int64_t)1LL, (int64_t)UINT32_MAX);
+    const auto   XDISTANCE     = m_sActiveSwipe.pMonitor->vecSize.x + *PWORKSPACEGAP;
+    const auto   YDISTANCE     = m_sActiveSwipe.pMonitor->vecSize.y + *PWORKSPACEGAP;
+    const auto   ANIMSTYLE     = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->getStyle();
+    const bool   VERTANIMS     = ANIMSTYLE == "slidevert" || ANIMSTYLE.starts_with("slidefadevert");
+    const double d             = m_sActiveSwipe.delta - delta;
+    m_sActiveSwipe.delta       = delta;
 
     m_sActiveSwipe.avgSpeed = (m_sActiveSwipe.avgSpeed * m_sActiveSwipe.speedPoints + abs(d)) / (m_sActiveSwipe.speedPoints + 1);
     m_sActiveSwipe.speedPoints++;
@@ -265,9 +265,9 @@ void CInputManager::updateWorkspaceSwipe(double delta) {
                 g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor.lock());
 
                 if (VERTANIMS)
-                    m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE));
+                    m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE));
                 else
-                    m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE, 0.0));
+                    m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE, 0.0));
 
                 m_sActiveSwipe.pWorkspaceBegin->updateWindowDecos();
                 return;
@@ -277,23 +277,23 @@ void CInputManager::updateWorkspaceSwipe(double delta) {
         }
 
         PWORKSPACE->m_bForceRendering = true;
-        PWORKSPACE->m_fAlpha.setValueAndWarp(1.f);
+        PWORKSPACE->m_fAlpha->setValueAndWarp(1.f);
 
         if (workspaceIDLeft != workspaceIDRight && workspaceIDRight != m_sActiveSwipe.pWorkspaceBegin->m_iID) {
             const auto PWORKSPACER = g_pCompositor->getWorkspaceByID(workspaceIDRight);
 
             if (PWORKSPACER) {
                 PWORKSPACER->m_bForceRendering = false;
-                PWORKSPACER->m_fAlpha.setValueAndWarp(0.f);
+                PWORKSPACER->m_fAlpha->setValueAndWarp(0.f);
             }
         }
 
         if (VERTANIMS) {
-            PWORKSPACE->m_vRenderOffset.setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE - YDISTANCE));
-            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE));
+            PWORKSPACE->m_vRenderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE - YDISTANCE));
+            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE));
         } else {
-            PWORKSPACE->m_vRenderOffset.setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE - XDISTANCE, 0.0));
-            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE, 0.0));
+            PWORKSPACE->m_vRenderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE - XDISTANCE, 0.0));
+            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE, 0.0));
         }
 
         PWORKSPACE->updateWindowDecos();
@@ -305,9 +305,9 @@ void CInputManager::updateWorkspaceSwipe(double delta) {
                 g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor.lock());
 
                 if (VERTANIMS)
-                    m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE));
+                    m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE));
                 else
-                    m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE, 0.0));
+                    m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE, 0.0));
 
                 m_sActiveSwipe.pWorkspaceBegin->updateWindowDecos();
                 return;
@@ -317,23 +317,23 @@ void CInputManager::updateWorkspaceSwipe(double delta) {
         }
 
         PWORKSPACE->m_bForceRendering = true;
-        PWORKSPACE->m_fAlpha.setValueAndWarp(1.f);
+        PWORKSPACE->m_fAlpha->setValueAndWarp(1.f);
 
         if (workspaceIDLeft != workspaceIDRight && workspaceIDLeft != m_sActiveSwipe.pWorkspaceBegin->m_iID) {
             const auto PWORKSPACEL = g_pCompositor->getWorkspaceByID(workspaceIDLeft);
 
             if (PWORKSPACEL) {
                 PWORKSPACEL->m_bForceRendering = false;
-                PWORKSPACEL->m_fAlpha.setValueAndWarp(0.f);
+                PWORKSPACEL->m_fAlpha->setValueAndWarp(0.f);
             }
         }
 
         if (VERTANIMS) {
-            PWORKSPACE->m_vRenderOffset.setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE + YDISTANCE));
-            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE));
+            PWORKSPACE->m_vRenderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE + YDISTANCE));
+            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE));
         } else {
-            PWORKSPACE->m_vRenderOffset.setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE + XDISTANCE, 0.0));
-            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE, 0.0));
+            PWORKSPACE->m_vRenderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE + XDISTANCE, 0.0));
+            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE, 0.0));
         }
 
         PWORKSPACE->updateWindowDecos();
diff --git a/src/managers/input/Tablets.cpp b/src/managers/input/Tablets.cpp
index aba54387..d7ebfe87 100644
--- a/src/managers/input/Tablets.cpp
+++ b/src/managers/input/Tablets.cpp
@@ -69,7 +69,7 @@ static void refocusTablet(SP<CTablet> tab, SP<CTabletTool> tool, bool motion = f
 
         // yes, this technically ignores any regions set by the app. Too bad!
         if (LASTHLSURFACE->getWindow())
-            local = tool->absolutePos * LASTHLSURFACE->getWindow()->m_vRealSize.goal();
+            local = tool->absolutePos * LASTHLSURFACE->getWindow()->m_vRealSize->goal();
         else
             local = tool->absolutePos * BOX->size();
 
diff --git a/src/managers/input/Touch.cpp b/src/managers/input/Touch.cpp
index 4e3980aa..7212ba61 100644
--- a/src/managers/input/Touch.cpp
+++ b/src/managers/input/Touch.cpp
@@ -3,6 +3,7 @@
 #include "../../config/ConfigValue.hpp"
 #include "../../devices/ITouch.hpp"
 #include "../SeatManager.hpp"
+#include "managers/AnimationManager.hpp"
 
 void CInputManager::onTouchDown(ITouch::SDownEvent e) {
     m_bLastInputTouch = true;
@@ -36,9 +37,9 @@ void CInputManager::onTouchDown(ITouch::SDownEvent e) {
         return;
         // TODO: Don't swipe if you touched a floating window.
     } else if (*PSWIPETOUCH && (m_pFoundLSToFocus.expired() || m_pFoundLSToFocus->layer <= 1)) {
-        const auto PWORKSPACE = PMONITOR->activeWorkspace;
-        const bool VERTANIMS  = PWORKSPACE->m_vRenderOffset.getConfig()->pValues->internalStyle == "slidevert" ||
-            PWORKSPACE->m_vRenderOffset.getConfig()->pValues->internalStyle.starts_with("slidefadevert");
+        const auto   PWORKSPACE  = PMONITOR->activeWorkspace;
+        const auto   STYLE       = PWORKSPACE->m_vRenderOffset->getStyle();
+        const bool   VERTANIMS   = STYLE == "slidevert" || STYLE.starts_with("slidefadevert");
         const double TARGETLEFT  = ((VERTANIMS ? gapsOut.top : gapsOut.left) + *PBORDERSIZE) / (VERTANIMS ? PMONITOR->vecSize.y : PMONITOR->vecSize.x);
         const double TARGETRIGHT = 1 - (((VERTANIMS ? gapsOut.bottom : gapsOut.right) + *PBORDERSIZE) / (VERTANIMS ? PMONITOR->vecSize.y : PMONITOR->vecSize.x));
         const double POSITION    = (VERTANIMS ? e.pos.y : e.pos.x);
@@ -62,8 +63,8 @@ void CInputManager::onTouchDown(ITouch::SDownEvent e) {
 
     if (!m_sTouchData.touchFocusWindow.expired()) {
         if (m_sTouchData.touchFocusWindow->m_bIsX11) {
-            local = (g_pInputManager->getMouseCoordsInternal() - m_sTouchData.touchFocusWindow->m_vRealPosition.goal()) * m_sTouchData.touchFocusWindow->m_fX11SurfaceScaledBy;
-            m_sTouchData.touchSurfaceOrigin = m_sTouchData.touchFocusWindow->m_vRealPosition.goal();
+            local = (g_pInputManager->getMouseCoordsInternal() - m_sTouchData.touchFocusWindow->m_vRealPosition->goal()) * m_sTouchData.touchFocusWindow->m_fX11SurfaceScaledBy;
+            m_sTouchData.touchSurfaceOrigin = m_sTouchData.touchFocusWindow->m_vRealPosition->goal();
         } else {
             g_pCompositor->vectorWindowToSurface(g_pInputManager->getMouseCoordsInternal(), m_sTouchData.touchFocusWindow.lock(), local);
             m_sTouchData.touchSurfaceOrigin = g_pInputManager->getMouseCoordsInternal() - local;
@@ -101,8 +102,9 @@ void CInputManager::onTouchMove(ITouch::SMotionEvent e) {
         // Do nothing if this is using a different finger.
         if (e.touchID != m_sActiveSwipe.touch_id)
             return;
-        const bool VERTANIMS = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.getConfig()->pValues->internalStyle == "slidevert" ||
-            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.getConfig()->pValues->internalStyle.starts_with("slidefadevert");
+
+        const auto  ANIMSTYLE     = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->getStyle();
+        const bool  VERTANIMS     = ANIMSTYLE == "slidevert" || ANIMSTYLE.starts_with("slidefadevert");
         static auto PSWIPEINVR    = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_touch_invert");
         static auto PSWIPEDIST    = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_distance");
         const auto  SWIPEDISTANCE = std::clamp(*PSWIPEDIST, (int64_t)1LL, (int64_t)UINT32_MAX);