From a92dae5af7bad3af53f6d6b689d71ee900077569 Mon Sep 17 00:00:00 2001 From: Vaxry Date: Wed, 29 Apr 2026 16:37:48 +0100 Subject: desktop/window: add alpha container for alpha calculations --- src/Compositor.cpp | 7 +- src/desktop/types/MultiAnimatedVariable.hpp | 184 +++++++++++++++++++++ src/desktop/view/Window.cpp | 88 +++++++--- src/desktop/view/Window.hpp | 39 +++-- src/managers/animation/DesktopAnimationManager.cpp | 23 +-- .../input/trackpad/gestures/CloseGesture.cpp | 24 +-- src/managers/screenshare/ScreenshareFrame.cpp | 3 +- src/render/OpenGL.cpp | 4 +- src/render/Renderer.cpp | 27 +-- 9 files changed, 323 insertions(+), 76 deletions(-) create mode 100644 src/desktop/types/MultiAnimatedVariable.hpp (limited to 'src') 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 +#include + +#include "../../helpers/AnimatedVariable.hpp" + +namespace Desktop::Types { + + template + struct SAddOperation { + static constexpr T identity() { + return T{}; + } + + static T apply(const T& lhs, const T& rhs) { + return lhs + rhs; + } + }; + + template + struct SMultiplyOperation { + static constexpr T identity() { + return T{1}; + } + + static T apply(const T& lhs, const T& rhs) { + return lhs * rhs; + } + }; + + template > + class CMultiAnimatedVariableContainer { + public: + using value_type = VarType; + using key_type = Key; + using operation_type = Operation; + + static constexpr size_t size() { + return Count; + } + + PHLANIMVAR& get(const Key key) { + return m_vars.at(index(key)); + } + + const PHLANIMVAR& get(const Key key) const { + return m_vars.at(index(key)); + } + + PHLANIMVAR& operator[](const Key key) { + return get(key); + } + + const PHLANIMVAR& operator[](const Key key) const { + return get(key); + } + + PHLANIMVAR& raw(const size_t i) { + return m_vars.at(i); + } + + const PHLANIMVAR& raw(const size_t i) const { + return m_vars.at(i); + } + + std::array, Count>& all() { + return m_vars; + } + + const std::array, Count>& all() const { + return m_vars; + } + + template + void forEach(Fn&& fn) { + for (size_t i = 0; i < Count; ++i) + fn(static_cast(i), m_vars.at(i)); + } + + template + void forEach(Fn&& fn) const { + for (size_t i = 0; i < Count; ++i) + fn(static_cast(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(key); + } + + template + 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 + 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, Count> m_vars; + }; + + template > + using CMultiAVarContainer = CMultiAnimatedVariableContainer; + +} 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 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(pWindow)); @@ -114,13 +118,17 @@ PHLWINDOW CWindow::create(SP 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(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 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& CWindow::alpha(eWindowAlpha type) { + return m_alpha.get(type); +} + +const PHLANIMVAR& 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(0) /* unknown */; @@ -194,13 +206,13 @@ namespace Desktop::View { mutable bool m_borderSizeCacheDirty = true; // Fade in-out - PHLANIMVAR 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 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> m_transformers; - // for alpha - PHLANIMVAR m_activeInactiveAlpha; - PHLANIMVAR m_movingFromWorkspaceAlpha; - // animated shadow color PHLANIMVAR m_realShadowColor; @@ -239,8 +247,7 @@ namespace Desktop::View { PHLANIMVAR m_dimPercent; // animate moving to an invisible workspace - int m_monitorMovedFrom = -1; // -1 means not moving - PHLANIMVAR 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& alpha(eWindowAlpha type); + const PHLANIMVAR& 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 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> 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 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(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(std::move(data))); -- cgit v1.2.3