9f2cb0ae1b
Effects are given the interval between two consecutive frames. The main
flaw of this approach is that if the Compositor transitions from the idle
state to "active" state, i.e. when there is something to repaint,
effects may see a very large interval between the last painted frame and
the current. In order to address this issue, the Scene invalidates the
timer that is used to measure time between consecutive frames before the
Compositor is about to become idle.
While this works perfectly fine with Xinerama-style rendering, with per
screen rendering, determining whether the compositor is about to idle is
rather a tedious task mostly because a single output can't be used for
the test.
Furthermore, since the Compositor schedules pointless repaints just to
ensure that it's idle, it might take several attempts to figure out
whether the scene timer must be invalidated if you use (true) per screen
rendering.
Ideally, all effects should use a timeline helper that is aware of the
underlying render loop and its timings. However, this option is off the
table because it will involve a lot of work to implement it.
Alternative and much simpler option is to pass the expected presentation
time to effects rather than time between consecutive frames. This means
that effects are responsible for determining how much animation timelines
have to be advanced. Typically, an effect would have to store the
presentation timestamp provided in either prePaint{Screen,Window} and
use it in the subsequent prePaint{Screen,Window} call to estimate the
amount of time passed between the next and the last frames.
Unfortunately, this is an API incompatible change. However, it shouldn't
take a lot of work to port third-party binary effects, which don't use the
AnimationEffect class, to the new API. On the bright side, we no longer
need to be concerned about the Compositor getting idle.
We do still try to determine whether the Compositor is about to idle,
primarily, because the OpenGL render backend swaps buffers on present,
but that will change with the ongoing compositing timing rework.
408 lines
16 KiB
C++
408 lines
16 KiB
C++
/*
|
|
KWin - the KDE window manager
|
|
This file is part of the KDE project.
|
|
|
|
SPDX-FileCopyrightText: 2011 Thomas Lübking <thomas.luebking@web.de>
|
|
SPDX-FileCopyrightText: 2018 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
|
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
*/
|
|
|
|
#ifndef ANIMATION_EFFECT_H
|
|
#define ANIMATION_EFFECT_H
|
|
|
|
#include <QEasingCurve>
|
|
#include <QElapsedTimer>
|
|
#include <QtMath>
|
|
#include <kwineffects.h>
|
|
#include <kwineffects_export.h>
|
|
|
|
namespace KWin
|
|
{
|
|
|
|
class KWINEFFECTS_EXPORT FPx2 {
|
|
public:
|
|
FPx2() { f[0] = f[1] = 0.0; valid = false; }
|
|
explicit FPx2(float v) { f[0] = f[1] = v; valid = true; }
|
|
FPx2(float v1, float v2) { f[0] = v1; f[1] = v2; valid = true; }
|
|
FPx2(const FPx2 &other) { f[0] = other.f[0]; f[1] = other.f[1]; valid = other.valid; }
|
|
explicit FPx2(const QPoint &other) { f[0] = other.x(); f[1] = other.y(); valid = true; }
|
|
explicit FPx2(const QPointF &other) { f[0] = other.x(); f[1] = other.y(); valid = true; }
|
|
explicit FPx2(const QSize &other) { f[0] = other.width(); f[1] = other.height(); valid = true; }
|
|
explicit FPx2(const QSizeF &other) { f[0] = other.width(); f[1] = other.height(); valid = true; }
|
|
inline void invalidate() { valid = false; }
|
|
inline bool isValid() const { return valid; }
|
|
inline float operator[](int n) const { return f[n]; }
|
|
inline QString toString() const {
|
|
QString ret;
|
|
if (valid)
|
|
ret = QString::number(f[0]) + QLatin1Char(',') + QString::number(f[1]);
|
|
else
|
|
ret = QString();
|
|
return ret;
|
|
}
|
|
|
|
inline FPx2 &operator=(const FPx2 &other)
|
|
{ f[0] = other.f[0]; f[1] = other.f[1]; valid = other.valid; return *this; }
|
|
inline FPx2 &operator+=(const FPx2 &other)
|
|
{ f[0] += other[0]; f[1] += other[1]; return *this; }
|
|
inline FPx2 &operator-=(const FPx2 &other)
|
|
{ f[0] -= other[0]; f[1] -= other[1]; return *this; }
|
|
inline FPx2 &operator*=(float fl)
|
|
{ f[0] *= fl; f[1] *= fl; return *this; }
|
|
inline FPx2 &operator/=(float fl)
|
|
{ f[0] /= fl; f[1] /= fl; return *this; }
|
|
|
|
friend inline bool operator==(const FPx2 &f1, const FPx2 &f2)
|
|
{ return f1[0] == f2[0] && f1[1] == f2[1]; }
|
|
friend inline bool operator!=(const FPx2 &f1, const FPx2 &f2)
|
|
{ return f1[0] != f2[0] || f1[1] != f2[1]; }
|
|
friend inline const FPx2 operator+(const FPx2 &f1, const FPx2 &f2)
|
|
{ return FPx2( f1[0] + f2[0], f1[1] + f2[1] ); }
|
|
friend inline const FPx2 operator-(const FPx2 &f1, const FPx2 &f2)
|
|
{ return FPx2( f1[0] - f2[0], f1[1] - f2[1] ); }
|
|
friend inline const FPx2 operator*(const FPx2 &f, float fl)
|
|
{ return FPx2( f[0] * fl, f[1] * fl ); }
|
|
friend inline const FPx2 operator*(float fl, const FPx2 &f)
|
|
{ return FPx2( f[0] * fl, f[1] *fl ); }
|
|
friend inline const FPx2 operator-(const FPx2 &f)
|
|
{ return FPx2( -f[0], -f[1] ); }
|
|
friend inline const FPx2 operator/(const FPx2 &f, float fl)
|
|
{ return FPx2( f[0] / fl, f[1] / fl ); }
|
|
|
|
inline void set(float v) { f[0] = v; valid = true; }
|
|
inline void set(float v1, float v2) { f[0] = v1; f[1] = v2; valid = true; }
|
|
|
|
private:
|
|
float f[2];
|
|
bool valid;
|
|
};
|
|
|
|
class AniData;
|
|
class AnimationEffectPrivate;
|
|
|
|
/**
|
|
* Base class for animation effects.
|
|
*
|
|
* AnimationEffect serves as a base class for animation effects. It makes easier
|
|
* implementing animated transitions, without having to worry about low-level
|
|
* specific stuff, e.g. referencing and unreferencing deleted windows, scheduling
|
|
* repaints for the next frame, etc.
|
|
*
|
|
* Each animation animates one specific attribute, e.g. size, position, scale, etc.
|
|
* You can provide your own implementation of the Generic attribute if none of the
|
|
* standard attributes(e.g. size, position, etc) satisfy your requirements.
|
|
*
|
|
* @since 4.8
|
|
*/
|
|
class KWINEFFECTS_EXPORT AnimationEffect : public Effect
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
enum Anchor { Left = 1<<0, Top = 1<<1, Right = 1<<2, Bottom = 1<<3,
|
|
Horizontal = Left|Right, Vertical = Top|Bottom, Mouse = 1<<4 };
|
|
Q_ENUM(Anchor)
|
|
|
|
enum Attribute {
|
|
Opacity = 0, Brightness, Saturation, Scale, Rotation,
|
|
Position, Size, Translation, Clip, Generic, CrossFadePrevious,
|
|
NonFloatBase = Position
|
|
};
|
|
Q_ENUM(Attribute)
|
|
|
|
enum MetaType { SourceAnchor, TargetAnchor,
|
|
RelativeSourceX, RelativeSourceY, RelativeTargetX, RelativeTargetY, Axis };
|
|
Q_ENUM(MetaType)
|
|
|
|
/**
|
|
* This enum type is used to specify the direction of the animation.
|
|
*
|
|
* @since 5.15
|
|
*/
|
|
enum Direction {
|
|
Forward, ///< The animation goes from source to target.
|
|
Backward ///< The animation goes from target to source.
|
|
};
|
|
Q_ENUM(Direction)
|
|
|
|
/**
|
|
* This enum type is used to specify when the animation should be terminated.
|
|
*
|
|
* @since 5.15
|
|
*/
|
|
enum TerminationFlag {
|
|
/**
|
|
* Don't terminate the animation when it reaches source or target position.
|
|
*/
|
|
DontTerminate = 0x00,
|
|
/**
|
|
* Terminate the animation when it reaches the source position. An animation
|
|
* can reach the source position if its direction was changed to go backward
|
|
* (from target to source).
|
|
*/
|
|
TerminateAtSource = 0x01,
|
|
/**
|
|
* Terminate the animation when it reaches the target position. If this flag
|
|
* is not set, then the animation will be persistent.
|
|
*/
|
|
TerminateAtTarget = 0x02
|
|
};
|
|
Q_FLAGS(TerminationFlag)
|
|
Q_DECLARE_FLAGS(TerminationFlags, TerminationFlag)
|
|
|
|
/**
|
|
* Constructs AnimationEffect.
|
|
*
|
|
* Whenever you intend to connect to the EffectsHandler::windowClosed() signal,
|
|
* do so when reimplementing the constructor. Do not add private slots named
|
|
* _windowClosed or _windowDeleted! The AnimationEffect connects them right after
|
|
* the construction.
|
|
*
|
|
* If you shadow the _windowDeleted slot (it doesn't matter that it's a private
|
|
* slot), this will lead to segfaults.
|
|
*
|
|
* If you shadow _windowClosed or connect your slot to EffectsHandler::windowClosed()
|
|
* after _windowClosed was connected, animations for closing windows will fail.
|
|
*/
|
|
AnimationEffect();
|
|
~AnimationEffect() override;
|
|
|
|
bool isActive() const override;
|
|
|
|
/**
|
|
* Gets stored metadata.
|
|
*
|
|
* Metadata can be used to store some extra information, for example rotation axis,
|
|
* etc. The first 24 bits are reserved for the AnimationEffect class, you can use
|
|
* the last 8 bits for custom hints. In case when you transform a Generic attribute,
|
|
* all 32 bits are yours and you can use them as you want and read them in your
|
|
* genericAnimation() implementation.
|
|
*
|
|
* @param type The type of the metadata.
|
|
* @param meta Where the metadata is stored.
|
|
* @returns Stored metadata.
|
|
* @since 4.8
|
|
*/
|
|
static int metaData(MetaType type, uint meta );
|
|
|
|
/**
|
|
* Sets metadata.
|
|
*
|
|
* @param type The type of the metadata.
|
|
* @param value The data to be stored.
|
|
* @param meta Where the metadata will be stored.
|
|
* @since 4.8
|
|
*/
|
|
static void setMetaData(MetaType type, uint value, uint &meta );
|
|
|
|
// Reimplemented from KWin::Effect.
|
|
QString debug(const QString ¶meter) const override;
|
|
void prePaintScreen( ScreenPrePaintData& data, std::chrono::milliseconds presentTime ) override;
|
|
void prePaintWindow( EffectWindow* w, WindowPrePaintData& data, std::chrono::milliseconds presentTime ) override;
|
|
void paintWindow( EffectWindow* w, int mask, QRegion region, WindowPaintData& data ) override;
|
|
void postPaintScreen() override;
|
|
|
|
/**
|
|
* Gaussian (bumper) animation curve for QEasingCurve.
|
|
*
|
|
* @since 4.8
|
|
*/
|
|
static qreal qecGaussian(qreal progress)
|
|
{
|
|
progress = 2*progress - 1;
|
|
progress *= -5*progress;
|
|
return qExp(progress);
|
|
}
|
|
|
|
/**
|
|
* @since 4.8
|
|
*/
|
|
static inline qint64 clock() {
|
|
return s_clock.elapsed();
|
|
}
|
|
|
|
protected:
|
|
/**
|
|
* Starts an animated transition of any supported attribute.
|
|
*
|
|
* @param w The animated window.
|
|
* @param a The animated attribute.
|
|
* @param meta Basically a wildcard to carry various extra information, e.g.
|
|
* the anchor, relativity or rotation axis. You will probably use it when
|
|
* performing Generic animations.
|
|
* @param ms How long the transition will last.
|
|
* @param to The target value. FPx2 is an agnostic two component float type
|
|
* (like QPointF or QSizeF, but without requiring to be either and supporting
|
|
* an invalid state).
|
|
* @param curve How the animation progresses, e.g. Linear progresses constantly
|
|
* while Exponential start slow and becomes very fast in the end.
|
|
* @param delay When the animation will start compared to "now" (the window will
|
|
* remain at the "from" position until then).
|
|
* @param from The starting value, the default is invalid, ie. the attribute for
|
|
* the window is not transformed in the beginning.
|
|
* @param fullScreen Sets this effect as the active full screen effect for the
|
|
* duration of the animation.
|
|
* @param keepAlive Whether closed windows should be kept alive during animation.
|
|
* @returns An ID that you can use to cancel a running animation.
|
|
* @since 4.8
|
|
*/
|
|
quint64 animate( EffectWindow *w, Attribute a, uint meta, int ms, const FPx2 &to, const QEasingCurve &curve = QEasingCurve(), int delay = 0, const FPx2 &from = FPx2(), bool fullScreen = false, bool keepAlive = true)
|
|
{ return p_animate(w, a, meta, ms, to, curve, delay, from, false, fullScreen, keepAlive); }
|
|
|
|
/**
|
|
* Starts a persistent animated transition of any supported attribute.
|
|
*
|
|
* This method is equal to animate() with one important difference:
|
|
* the target value for the attribute is kept until you call cancel().
|
|
*
|
|
* @param w The animated window.
|
|
* @param a The animated attribute.
|
|
* @param meta Basically a wildcard to carry various extra information, e.g.
|
|
* the anchor, relativity or rotation axis. You will probably use it when
|
|
* performing Generic animations.
|
|
* @param ms How long the transition will last.
|
|
* @param to The target value. FPx2 is an agnostic two component float type
|
|
* (like QPointF or QSizeF, but without requiring to be either and supporting
|
|
* an invalid state).
|
|
* @param curve How the animation progresses, e.g. Linear progresses constantly
|
|
* while Exponential start slow and becomes very fast in the end.
|
|
* @param delay When the animation will start compared to "now" (the window will
|
|
* remain at the "from" position until then).
|
|
* @param from The starting value, the default is invalid, ie. the attribute for
|
|
* the window is not transformed in the beginning.
|
|
* @param fullScreen Sets this effect as the active full screen effect for the
|
|
* duration of the animation.
|
|
* @param keepAlive Whether closed windows should be kept alive during animation.
|
|
* @returns An ID that you need to use to cancel this manipulation.
|
|
* @since 4.11
|
|
*/
|
|
quint64 set( EffectWindow *w, Attribute a, uint meta, int ms, const FPx2 &to, const QEasingCurve &curve = QEasingCurve(), int delay = 0, const FPx2 &from = FPx2(), bool fullScreen = false, bool keepAlive = true)
|
|
{ return p_animate(w, a, meta, ms, to, curve, delay, from, true, fullScreen, keepAlive); }
|
|
|
|
/**
|
|
* Changes the target (but not type or curve) of a running animation.
|
|
*
|
|
* Please use cancel() to cancel an animation rather than altering it.
|
|
*
|
|
* @param animationId The id of the animation to be retargetted.
|
|
* @param newTarget The new target.
|
|
* @param newRemainingTime The new duration of the transition. By default (-1),
|
|
* the remaining time remains unchanged.
|
|
* @returns @c true if the animation was retargetted successfully, @c false otherwise.
|
|
* @note You can NOT retarget an animation that just has just ended!
|
|
* @since 5.6
|
|
*/
|
|
bool retarget(quint64 animationId, FPx2 newTarget, int newRemainingTime = -1);
|
|
|
|
/**
|
|
* Changes the direction of the animation.
|
|
*
|
|
* @param animationId The id of the animation.
|
|
* @param direction The new direction of the animation.
|
|
* @param terminationFlags Whether the animation should be terminated when it
|
|
* reaches the source position after its direction was changed to go backward.
|
|
* Currently, TerminationFlag::TerminateAtTarget has no effect.
|
|
* @returns @c true if the direction of the animation was changed successfully,
|
|
* otherwise @c false.
|
|
* @since 5.15
|
|
*/
|
|
bool redirect(quint64 animationId,
|
|
Direction direction,
|
|
TerminationFlags terminationFlags = TerminateAtSource);
|
|
|
|
/**
|
|
* Fast-forwards the animation to the target position.
|
|
*
|
|
* @param animationId The id of the animation.
|
|
* @returns @c true if the animation was fast-forwarded successfully, otherwise
|
|
* @c false.
|
|
* @since 5.15
|
|
*/
|
|
bool complete(quint64 animationId);
|
|
|
|
/**
|
|
* Called whenever an animation ends.
|
|
*
|
|
* You can reimplement this method to keep a constant transformation for the window
|
|
* (i.e. keep it at some opacity or position) or to start another animation.
|
|
*
|
|
* @param w The animated window.
|
|
* @param a The animated attribute.
|
|
* @param meta Originally supplied metadata to animate() or set().
|
|
* @since 4.8
|
|
*/
|
|
virtual void animationEnded(EffectWindow *w, Attribute a, uint meta)
|
|
{Q_UNUSED(w); Q_UNUSED(a); Q_UNUSED(meta);}
|
|
|
|
/**
|
|
* Cancels a running animation.
|
|
*
|
|
* @param animationId The id of the animation.
|
|
* @returns @c true if the animation was found (and canceled), @c false otherwise.
|
|
* @note There is NO animated reset of the original value. You'll have to provide
|
|
* that with a second animation.
|
|
* @note This will eventually release a Deleted window as well.
|
|
* @note If you intend to run another animation on the (Deleted) window, you have
|
|
* to do that before cancelling the old animation (to keep the window around).
|
|
* @since 4.11
|
|
*/
|
|
bool cancel(quint64 animationId);
|
|
|
|
/**
|
|
* Called whenever animation that transforms Generic attribute needs to be painted.
|
|
*
|
|
* You should reimplement this method if you transform Generic attribute. @p meta
|
|
* can be used to support more than one additional animations.
|
|
*
|
|
* @param w The animated window.
|
|
* @param data The paint data.
|
|
* @param progress Current progress value.
|
|
* @param meta The metadata.
|
|
* @since 4.8
|
|
*/
|
|
virtual void genericAnimation( EffectWindow *w, WindowPaintData &data, float progress, uint meta )
|
|
{Q_UNUSED(w); Q_UNUSED(data); Q_UNUSED(progress); Q_UNUSED(meta);}
|
|
|
|
/**
|
|
* @internal
|
|
*/
|
|
typedef QMap<EffectWindow *, QPair<QList<AniData>, QRect> > AniMap;
|
|
|
|
/**
|
|
* @internal
|
|
*/
|
|
AniMap state() const;
|
|
|
|
private:
|
|
quint64 p_animate(EffectWindow *w, Attribute a, uint meta, int ms, FPx2 to, const QEasingCurve &curve, int delay, FPx2 from, bool keepAtTarget, bool fullScreenEffect, bool keepAlive);
|
|
QRect clipRect(const QRect &windowRect, const AniData&) const;
|
|
void clipWindow(const EffectWindow *, const AniData &, WindowQuadList &) const;
|
|
float interpolated( const AniData&, int i = 0 ) const;
|
|
float progress( const AniData& ) const;
|
|
void disconnectGeometryChanges();
|
|
void updateLayerRepaints();
|
|
void validate(Attribute a, uint &meta, FPx2 *from, FPx2 *to, const EffectWindow *w) const;
|
|
|
|
private Q_SLOTS:
|
|
void init();
|
|
void triggerRepaint();
|
|
void _windowClosed( KWin::EffectWindow* w );
|
|
void _windowDeleted( KWin::EffectWindow* w );
|
|
void _expandedGeometryChanged(KWin::EffectWindow *w, const QRect &old);
|
|
|
|
private:
|
|
static QElapsedTimer s_clock;
|
|
AnimationEffectPrivate * const d_ptr;
|
|
Q_DECLARE_PRIVATE(AnimationEffect)
|
|
Q_DISABLE_COPY(AnimationEffect)
|
|
};
|
|
|
|
} // namespace
|
|
|
|
QDebug operator<<(QDebug dbg, const KWin::FPx2 &fpx2);
|
|
|
|
Q_DECLARE_METATYPE(KWin::FPx2)
|
|
Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::AnimationEffect::TerminationFlags)
|
|
|
|
#endif // ANIMATION_EFFECT_H
|