The KisScalarKeyframeChannel is a concrete KisKeyframeChannel subclass that stores and manages KisScalarKeyframes. More...

#include <kis_scalar_keyframe_channel.h>

Inheritance diagram for KisScalarKeyframeChannel:

Classes
struct	Private

Public Member Functions
void	addScalarKeyframe (int time, qreal value, KUndo2Command *parentUndoCmd=nullptr)

virtual KisTimeSpan	affectedFrames (int time) const override
	Get the set of frames affected by any changes to the value or content of the active keyframe at the given time.

qreal	currentValue ()

virtual KisTimeSpan	identicalFrames (int time) const override
	Get a span of times for which the channel gives identical results compared to frame at a given time. NOTE: This set may be different than the set of affected frames due to interpolation.

virtual void	insertKeyframe (int time, KisKeyframeSP keyframe, KUndo2Command *parentUndoCmd=nullptr) override
	Insert an existing keyframe into the channel at the specified time.

bool	isCurrentTimeAffectedBy (int keyTime)

	KisScalarKeyframeChannel (const KisScalarKeyframeChannel &rhs)

	KisScalarKeyframeChannel (const KoID &id, KisDefaultBoundsBaseSP bounds)

QSharedPointer< ScalarKeyframeLimits >	limits () const

virtual void	removeKeyframe (int time, KUndo2Command *parentUndoCmd=nullptr) override
	Remove a keyframe from the channel at the specified time.

void	removeLimits ()

void	setDefaultInterpolationMode (KisScalarKeyframe::InterpolationMode mode)

void	setDefaultValue (qreal value)

void	setLimits (qreal low, qreal high)

qreal	valueAt (int time) const
	Quickly get the interpolated value at the given time.

	~KisScalarKeyframeChannel () override

Public Member Functions inherited from KisKeyframeChannel
KisKeyframeSP	activeKeyframeAt (int time) const

template<class KeyframeType >
QSharedPointer< KeyframeType >	activeKeyframeAt (int time) const

int	activeKeyframeTime () const

int	activeKeyframeTime (int time) const
	Get the time of the active keyframe. Useful for snapping any time to that of the most recent keyframe.

void	addKeyframe (int time, KUndo2Command *parentUndoCmd=nullptr)
	Add a new keyframe to the channel at the specified time.

QSet< int >	allKeyframeTimes () const
	Get a set of all integer times that map to a keyframe.

int	channelHash () const
	Calculates a pseudo-unique hash based on the relevant internal state of the channel.

void	copyKeyframe (int sourceTime, int targetTime, KUndo2Command *parentUndoCmd=nullptr)

int	firstKeyframeTime () const

QString	id () const

KisKeyframeSP	keyframeAt (int time) const
	Get a keyframe at specified time. Used primarily when the value of a given keyframe is needed.

template<class KeyframeType >
QSharedPointer< KeyframeType >	keyframeAt (int time) const

int	keyframeCount () const

	KisKeyframeChannel (const KisKeyframeChannel &rhs)

	KisKeyframeChannel (const KoID &id, KisDefaultBoundsBaseSP bounds)

int	lastKeyframeTime () const

virtual void	loadXML (const QDomElement &channelNode)

int	lookupKeyframeTime (KisKeyframeSP toLookup)
	Search for the time for a given keyframe. (Reverse map lookup, so use sparingly.)

void	moveKeyframe (int sourceTime, int targetTime, KUndo2Command *parentUndoCmd=nullptr)

QString	name () const

int	nextKeyframeTime (const int time) const

KisNodeWSP	node () const

int	previousKeyframeTime (const int time) const

void	setDefaultBounds (KisDefaultBoundsBaseSP bounds)

void	setNode (KisNodeWSP node)

void	swapKeyframes (int timeA, int timeB, KUndo2Command *parentUndoCmd=nullptr)

virtual QDomElement	toXML (QDomDocument doc, const QString &layerFilename)

	~KisKeyframeChannel () override

Static Public Member Functions
static QPointF	interpolate (QPointF point1, QPointF rightTangent, QPointF leftTangent, QPointF point2, qreal t)

Static Public Member Functions inherited from KisKeyframeChannel
static KoID	channelIdToKoId (const QString &id)

static void	copyKeyframe (const KisKeyframeChannel sourceChannel, int sourceTime, KisKeyframeChannel targetChannel, int targetTime, KUndo2Command *parentUndoCmd=nullptr)
	Copy a keyframe across channel(s) at the specified times.

static void	moveKeyframe (KisKeyframeChannel sourceChannel, int sourceTime, KisKeyframeChannel targetChannel, int targetTime, KUndo2Command *parentUndoCmd=nullptr)
	Move a keyframe across channel(s) at the specified times.

static void	swapKeyframes (KisKeyframeChannel channelA, int timeA, KisKeyframeChannel channelB, int timeB, KUndo2Command *parentUndoCmd=nullptr)
	Swap two keyframes across channel(s) at the specified times.

Private Member Functions
virtual QRect	affectedRect (int time) const override

virtual KisKeyframeSP	createKeyframe () override
	Virtual keyframe creation function. Derived classes implement this function based on the needs of their specific KisKeyframe subclasses.

virtual QPair< int, KisKeyframeSP >	loadKeyframe (const QDomElement &keyframeNode) override

virtual void	saveKeyframe (KisKeyframeSP keyframe, QDomElement keyframeElement, const QString &layerFilename) override

Static Private Member Functions
static qreal	cubicBezier (qreal p0, qreal delta1, qreal delta2, qreal p3, qreal t)

static qreal	findCubicCurveParameter (int time0, qreal delta0, qreal delta1, int time1, int time)

static void	normalizeTangents (const QPointF point1, QPointF &rightTangent, QPointF &leftTangent, const QPointF point2)

Private Attributes
QScopedPointer< Private >	m_d

Additional Inherited Members
Signals inherited from KisKeyframeChannel
void	sigAddedKeyframe (const KisKeyframeChannel *channel, int time)
	This signal is emitted just AFTER a keyframe was added to the channel.

void	sigAnyKeyframeChange ()

void	sigKeyframeAboutToBeRemoved (const KisKeyframeChannel *channel, int time)
	This signal is emitted just BEFORE a keyframe is removed from the channel.

void	sigKeyframeChanged (const KisKeyframeChannel *channel, int time)
	This signal is emitted just AFTER a non-raster keyframe was changed its value.

void	sigKeyframeHasBeenRemoved (const KisKeyframeChannel *channel, int time)
	This signal is emitted just AFTER a keyframe is removed from the channel.

Static Public Attributes inherited from KisKeyframeChannel
static const KoID	Opacity = KoID("opacity", ki18n("Opacity"))

static const KoID	PositionX = KoID("transform_pos_x", ki18n("Position (X)"))

static const KoID	PositionY = KoID("transform_pos_y", ki18n("Position (Y)"))

static const KoID	Raster = KoID("content", ki18n("Content"))

static const KoID	RotationX = KoID("transform_rotation_x", ki18n("Rotation (X)"))

static const KoID	RotationY = KoID("transform_rotation_y", ki18n("Rotation (Y)"))

static const KoID	RotationZ = KoID("transform_rotation_z", ki18n("Rotation (Z)"))

static const KoID	ScaleX = KoID("transform_scale_x", ki18n("Scale (X)"))

static const KoID	ScaleY = KoID("transform_scale_y", ki18n("Scale (Y)"))

static const KoID	ShearX = KoID("transform_shear_x", ki18n("Shear (X)"))

static const KoID	ShearY = KoID("transform_shear_y", ki18n("Shear (Y)"))

static const KoID	TransformArguments

Protected Types inherited from KisKeyframeChannel
typedef QMap< int, KisKeyframeSP >	TimeKeyframeMap

Protected Member Functions inherited from KisKeyframeChannel
const TimeKeyframeMap &	constKeys () const

int	currentTime () const

TimeKeyframeMap &	keys ()

virtual void	removeKeyframeImpl (int time, KUndo2Command *parentUndoCmd)

Q_DECL_DEPRECATED void	workaroundBrokenFrameTimeBug (int *time)
	Between Krita 4.1 and 4.4 Krita had a bug which resulted in creating frames with negative time stamp. The bug has been fixed, but there might be some files still in the wild.

Detailed Description

The KisScalarKeyframeChannel is a concrete KisKeyframeChannel subclass that stores and manages KisScalarKeyframes.

This class maps units of time (in frames) to points along a curve for the animation of various interpolated scalar parameters within Krita. Each scalar channel can be provided with default values and interpolation modes, as well as an optional ScalarKeyframeLimits object that can be used to limit the range of possible values.

Generally, each scalar channel will be represented as an individual curve within Krita's KisAnimationCurvesDocker.

Definition at line 119 of file kis_scalar_keyframe_channel.h.

Constructor & Destructor Documentation

◆ KisScalarKeyframeChannel() [1/2]

KisScalarKeyframeChannel::KisScalarKeyframeChannel	(	const KoID &	id,
		KisDefaultBoundsBaseSP	bounds )

Definition at line 167 of file kis_scalar_keyframe_channel.cpp.

    : KisKeyframeChannel(id, bounds)
    , m_d(new Private)
{
}

◆ KisScalarKeyframeChannel() [2/2]

KisScalarKeyframeChannel::KisScalarKeyframeChannel ( const KisScalarKeyframeChannel & rhs )

Definition at line 173 of file kis_scalar_keyframe_channel.cpp.

    : KisKeyframeChannel(rhs)
{
    m_d.reset(new Private(*rhs.m_d));
 
    Q_FOREACH (int time, rhs.constKeys().keys()) {
        KisKeyframeChannel::copyKeyframe(&rhs, time, this, time);
    }
}

References KisKeyframeChannel::constKeys(), KisKeyframeChannel::copyKeyframe(), and m_d.

◆ ~KisScalarKeyframeChannel()

KisScalarKeyframeChannel::~KisScalarKeyframeChannel ( )

override

Definition at line 183 of file kis_scalar_keyframe_channel.cpp.

184{

185}

Member Function Documentation

◆ addScalarKeyframe()

void KisScalarKeyframeChannel::addScalarKeyframe	(	int	time,
		qreal	value,
		KUndo2Command *	parentUndoCmd = nullptr )

Utility for adding keyframe with non-default value.

Definition at line 187 of file kis_scalar_keyframe_channel.cpp.

                                                                                                    {
    KisScalarKeyframeSP scalarKey = keyframeAt<KisScalarKeyframe>(time);
    if (!scalarKey) {
        addKeyframe(time, parentUndoCmd);
        scalarKey = keyframeAt<KisScalarKeyframe>(time);
    }
 
    if (scalarKey) {
        scalarKey->setValue(value, parentUndoCmd);
    }
}

References KisKeyframeChannel::addKeyframe(), and value().

◆ affectedFrames()

KisTimeSpan KisScalarKeyframeChannel::affectedFrames ( int time ) const

overridevirtual

Get the set of frames affected by any changes to the value or content of the active keyframe at the given time.

Reimplemented from KisKeyframeChannel.

Definition at line 336 of file kis_scalar_keyframe_channel.cpp.

{
    KisTimeSpan normalSpan = KisKeyframeChannel::affectedFrames(time);
 
    const int activeKeyTime = activeKeyframeTime(time);
    const int previousKeyTime = previousKeyframeTime(activeKeyTime);
    const KisScalarKeyframeSP prevScalarKey = keyframeAt<KisScalarKeyframe>(previousKeyTime);
 
    if(prevScalarKey) {
        // In the case that a previous keyframe is present with a non-constant interpolation mode,
        // the affected frames must include all the frames just after the previous keyframe.
        if (prevScalarKey->interpolationMode() == KisScalarKeyframe::Constant) {
            return normalSpan;
        } else {
            return normalSpan | KisTimeSpan::fromTimeToTime(previousKeyTime + 1, activeKeyTime);
        }
    } else {
        const KisScalarKeyframeSP firstScalarKey = keyframeAt<KisScalarKeyframe>(firstKeyframeTime());
        if (!firstScalarKey) {
            return KisTimeSpan::infinite(0);
        }
        return normalSpan | KisTimeSpan::fromTimeToTime(0, activeKeyTime);
    }
}

References KisKeyframeChannel::activeKeyframeTime(), KisKeyframeChannel::affectedFrames(), KisScalarKeyframe::Constant, KisKeyframeChannel::firstKeyframeTime(), KisTimeSpan::fromTimeToTime(), KisTimeSpan::infinite(), and KisKeyframeChannel::previousKeyframeTime().

◆ affectedRect()

QRect KisScalarKeyframeChannel::affectedRect ( int time ) const

overrideprivatevirtual

The rect that is affected by a frame at the given time

Implements KisKeyframeChannel.

Definition at line 449 of file kis_scalar_keyframe_channel.cpp.

{
    Q_UNUSED(time);
 
    if (node()) {
        return node()->exactBounds();
    } else {
        return QRect();
    }
}

References KisBaseNode::exactBounds(), and KisKeyframeChannel::node().

◆ createKeyframe()

KisKeyframeSP KisScalarKeyframeChannel::createKeyframe ( )

overrideprivatevirtual

Virtual keyframe creation function. Derived classes implement this function based on the needs of their specific KisKeyframe subclasses.

Implements KisKeyframeChannel.

Definition at line 442 of file kis_scalar_keyframe_channel.cpp.

{
    KisScalarKeyframe *keyframe = new KisScalarKeyframe(m_d->defaultValue, m_d->limits);
    keyframe->setInterpolationMode(m_d->defaultInterpolationMode);
    return toQShared(keyframe);
}

References m_d, KisScalarKeyframe::setInterpolationMode(), and toQShared().

◆ cubicBezier()

qreal KisScalarKeyframeChannel::cubicBezier	(	qreal	p0,
		qreal	delta1,
		qreal	delta2,
		qreal	p3,
		qreal	t )

staticprivate

Definition at line 416 of file kis_scalar_keyframe_channel.cpp.

                                                                                                   {
    qreal p1 = p0 + delta1;
    qreal p2 = p3 + delta2;
 
    qreal c = 1-t;
    return c*c*c * p0 + 3*c*c*t * p1 + 3*c*t*t * p2 + t*t*t * p3;
}

References p0, p1, p2, and p3.

◆ currentValue()

qreal KisScalarKeyframeChannel::currentValue ( )

inline

Definition at line 138 of file kis_scalar_keyframe_channel.h.

138{ return valueAt(currentTime()); }

KisKeyframeChannel::currentTime

int currentTime() const

Definition kis_keyframe_channel.cpp:444

KisScalarKeyframeChannel::valueAt

qreal valueAt(int time) const

Quickly get the interpolated value at the given time.

Definition kis_scalar_keyframe_channel.cpp:222

◆ findCubicCurveParameter()

qreal KisScalarKeyframeChannel::findCubicCurveParameter	(	int	time0,
		qreal	delta0,
		qreal	delta1,
		int	time1,
		int	time )

staticprivate

Definition at line 393 of file kis_scalar_keyframe_channel.cpp.

{
    if (time == time0) return 0.0;
    if (time == time1) return 1.0;
 
    qreal min_t = 0.0;
    qreal max_t = 1.0;
 
    while (true) {
        qreal t = (max_t + min_t) / 2;
        qreal time_t = cubicBezier(time0, delta0, delta1, time1, t);
 
        if (time_t < time - 0.05) {
            min_t = t;
        } else if (time_t > time + 0.05) {
            max_t = t;
        } else {
            // Close enough
            return t;
        }
    }
}

References cubicBezier().

◆ identicalFrames()

KisTimeSpan KisScalarKeyframeChannel::identicalFrames ( int time ) const

overridevirtual

Get a span of times for which the channel gives identical results compared to frame at a given time. NOTE: This set may be different than the set of affected frames due to interpolation.

Reimplemented from KisKeyframeChannel.

Definition at line 361 of file kis_scalar_keyframe_channel.cpp.

{
    //Failsafe == no keys should mean all frames are identical!
    if (allKeyframeTimes().count() == 0) {
        return KisTimeSpan::infinite(0);
    }
 
    KisScalarKeyframeSP activeScalarKey = activeKeyframeAt<KisScalarKeyframe>(time);
    if ( activeScalarKey &&
         activeScalarKey->interpolationMode() != KisScalarKeyframe::Constant &&
         activeScalarKey != keyframeAt(lastKeyframeTime()) ) {
        //TODO: Two keyframes should be considered identical if linear with same value..
        //TODO: Also, if bezier with same value AND tangents lie between points.
        //                                          (tangenty == keyframey)
        return KisTimeSpan::fromTimeToTime(time, time);
    }
 
    const int nextKeyTime = nextKeyframeTime(time);
 
    //Before the first frame => there's no active frame but a valid next frame.
    if (!activeScalarKey && keyframeAt(nextKeyTime)) {
        return KisTimeSpan::fromTimeToTime(0, nextKeyTime);
    }
 
    //No next frame, all frames after are identical.
    if (!keyframeAt(nextKeyTime)) {
       return KisTimeSpan::infinite(activeKeyframeTime(time));
    }
 
    return KisTimeSpan::fromTimeToTime(activeKeyframeTime(time), nextKeyTime - 1);
}

References KisKeyframeChannel::activeKeyframeTime(), KisKeyframeChannel::allKeyframeTimes(), KisScalarKeyframe::Constant, KisTimeSpan::fromTimeToTime(), KisTimeSpan::infinite(), KisKeyframeChannel::keyframeAt(), KisKeyframeChannel::lastKeyframeTime(), and KisKeyframeChannel::nextKeyframeTime().

◆ insertKeyframe()

void KisScalarKeyframeChannel::insertKeyframe	(	int	time,
		KisKeyframeSP	keyframe,
		KUndo2Command *	parentUndoCmd = nullptr )

overridevirtual

Insert an existing keyframe into the channel at the specified time.

Reimplemented from KisKeyframeChannel.

Definition at line 310 of file kis_scalar_keyframe_channel.cpp.

{
    KisScalarKeyframeSP scalarKeyframe = keyframe.dynamicCast<KisScalarKeyframe>();
    if (scalarKeyframe) {
        scalarKeyframe->valueChangedChannelConnection =
            QObject::connect(scalarKeyframe.data(),
                             &KisScalarKeyframe::sigChanged,
                             [this, time](const KisScalarKeyframe* key){
                                 Q_UNUSED(key);
                                 Q_EMIT sigKeyframeChanged(this, time);
                             });
    }
 
    KisKeyframeChannel::insertKeyframe(time, keyframe, parentUndoCmd);
}

References KisKeyframeChannel::insertKeyframe(), and KisScalarKeyframe::sigChanged().

◆ interpolate()

QPointF KisScalarKeyframeChannel::interpolate	(	QPointF	point1,
		QPointF	rightTangent,
		QPointF	leftTangent,
		QPointF	point2,
		qreal	t )

static

Definition at line 300 of file kis_scalar_keyframe_channel.cpp.

{
    normalizeTangents(point1, rightTangent, leftTangent, point2);
 
    qreal x = cubicBezier(point1.x(), rightTangent.x(), leftTangent.x(), point2.x(), t);
    qreal y = cubicBezier(point1.y(), rightTangent.y(), leftTangent.y(), point2.y(), t);
 
    return QPointF(x,y);
}

References cubicBezier(), and normalizeTangents().

◆ isCurrentTimeAffectedBy()

bool KisScalarKeyframeChannel::isCurrentTimeAffectedBy ( int keyTime )

Definition at line 286 of file kis_scalar_keyframe_channel.cpp.

                                                                  {
    return affectedFrames(activeKeyframeTime(keyTime)).contains(currentTime());
}

References KisKeyframeChannel::activeKeyframeTime(), affectedFrames(), KisTimeSpan::contains(), and KisKeyframeChannel::currentTime().

◆ limits()

QSharedPointer< ScalarKeyframeLimits > KisScalarKeyframeChannel::limits ( ) const

Definition at line 199 of file kis_scalar_keyframe_channel.cpp.

{
    return m_d->limits;
}

References m_d.

◆ loadKeyframe()

QPair< int, KisKeyframeSP > KisScalarKeyframeChannel::loadKeyframe ( const QDomElement & keyframeNode )

overrideprivatevirtual

Implements KisKeyframeChannel.

Definition at line 483 of file kis_scalar_keyframe_channel.cpp.

{
    int time = keyframeNode.toElement().attribute("time").toInt();
    workaroundBrokenFrameTimeBug(&time);
 
    qreal value = KisDomUtils::toDouble(keyframeNode.toElement().attribute("value"));
 
    KisScalarKeyframeSP keyframe = createKeyframe().dynamicCast<KisScalarKeyframe>();
    keyframe->setValue(value);
 
    KisScalarKeyframeSP scalarKey = keyframe.dynamicCast<KisScalarKeyframe>();
 
    QString interpolationMode = keyframeNode.toElement().attribute("interpolation");
    if (interpolationMode == "constant") {
        scalarKey->setInterpolationMode(KisScalarKeyframe::Constant);
    } else if (interpolationMode == "linear") {
        scalarKey->setInterpolationMode(KisScalarKeyframe::Linear);
    } else if (interpolationMode == "bezier") {
        scalarKey->setInterpolationMode(KisScalarKeyframe::Bezier);
    }
 
    QString tangentsMode = keyframeNode.toElement().attribute("tangents");
    if (tangentsMode == "smooth") {
        scalarKey->setTangentsMode(KisScalarKeyframe::Smooth);
    } else if (tangentsMode == "sharp") {
        scalarKey->setTangentsMode(KisScalarKeyframe::Sharp);
    }
 
    QPointF leftTangent;
    QPointF rightTangent;
    KisDomUtils::loadValue(keyframeNode, "leftTangent", &leftTangent);
    KisDomUtils::loadValue(keyframeNode, "rightTangent", &rightTangent);
    scalarKey->setInterpolationTangents(leftTangent, rightTangent);
 
    return QPair<int, KisKeyframeSP>(time, keyframe);
}

References KisScalarKeyframe::Bezier, KisScalarKeyframe::Constant, createKeyframe(), KisScalarKeyframe::Linear, KisDomUtils::loadValue(), KisScalarKeyframe::Sharp, KisScalarKeyframe::Smooth, KisDomUtils::toDouble(), value(), and KisKeyframeChannel::workaroundBrokenFrameTimeBug().

◆ normalizeTangents()

void KisScalarKeyframeChannel::normalizeTangents	(	const QPointF	point1,
		QPointF &	rightTangent,
		QPointF &	leftTangent,
		const QPointF	point2 )

staticprivate

Definition at line 424 of file kis_scalar_keyframe_channel.cpp.

{
    // To ensure that the curve is monotonic wrt time,
    // check that control points lie between the endpoints.
    // If not, force them into range by scaling down the tangents
 
    float interval = point2.x() - point1.x();
    if (rightTangent.x() < 0) rightTangent *= 0;
    if (leftTangent.x() > 0) leftTangent *= 0;
 
    if (rightTangent.x() > interval) {
        rightTangent *= interval / rightTangent.x();
    }
    if (leftTangent.x() < -interval) {
        leftTangent *= interval / -leftTangent.x();
    }
}

◆ removeKeyframe()

void KisScalarKeyframeChannel::removeKeyframe	(	int	time,
		KUndo2Command *	parentUndoCmd = nullptr )

overridevirtual

Remove a keyframe from the channel at the specified time.

Reimplemented from KisKeyframeChannel.

Definition at line 326 of file kis_scalar_keyframe_channel.cpp.

{
    KisScalarKeyframeSP keyframe = keyframeAt<KisScalarKeyframe>(time);
    if (keyframe) {
        disconnect(keyframe->valueChangedChannelConnection);
    }
 
    KisKeyframeChannel::removeKeyframe(time, parentUndoCmd);
}

References KisKeyframeChannel::removeKeyframe().

◆ removeLimits()

void KisScalarKeyframeChannel::removeLimits ( )

Remove limits, allowing channel to operate within any range of values.

Definition at line 215 of file kis_scalar_keyframe_channel.cpp.

{
    if (m_d->limits) {
        m_d->limits.reset();
    }
}

References m_d.

◆ saveKeyframe()

void KisScalarKeyframeChannel::saveKeyframe	(	KisKeyframeSP	keyframe,
		QDomElement	keyframeElement,
		const QString &	layerFilename )

overrideprivatevirtual

Implements KisKeyframeChannel.

Definition at line 460 of file kis_scalar_keyframe_channel.cpp.

{
    Q_UNUSED(layerFilename);
    KisScalarKeyframeSP scalarKey = keyframe.dynamicCast<KisScalarKeyframe>();
    KIS_SAFE_ASSERT_RECOVER_RETURN(scalarKey);
    const qreal value = scalarKey->value();
    keyframeElement.setAttribute("value", KisDomUtils::toString(value));
 
    QString interpolationMode;
    if (scalarKey->interpolationMode() == KisScalarKeyframe::Constant) interpolationMode = "constant";
    if (scalarKey->interpolationMode() == KisScalarKeyframe::Linear) interpolationMode = "linear";
    if (scalarKey->interpolationMode() == KisScalarKeyframe::Bezier) interpolationMode = "bezier";
 
    QString tangentsMode;
    if (scalarKey->tangentsMode() == KisScalarKeyframe::Smooth) tangentsMode = "smooth";
    if (scalarKey->tangentsMode() == KisScalarKeyframe::Sharp) tangentsMode = "sharp";
 
    keyframeElement.setAttribute("interpolation", interpolationMode);
    keyframeElement.setAttribute("tangents", tangentsMode);
    KisDomUtils::saveValue(&keyframeElement, "leftTangent", scalarKey->leftTangent());
    KisDomUtils::saveValue(&keyframeElement, "rightTangent", scalarKey->rightTangent());
}

References KisScalarKeyframe::Bezier, KisScalarKeyframe::Constant, KIS_SAFE_ASSERT_RECOVER_RETURN, KisScalarKeyframe::Linear, KisDomUtils::saveValue(), KisScalarKeyframe::Sharp, KisScalarKeyframe::Smooth, KisDomUtils::toString(), and value().

◆ setDefaultInterpolationMode()

void KisScalarKeyframeChannel::setDefaultInterpolationMode ( KisScalarKeyframe::InterpolationMode mode )

Definition at line 295 of file kis_scalar_keyframe_channel.cpp.

{
    m_d->defaultInterpolationMode = mode;
}

References m_d.

◆ setDefaultValue()

void KisScalarKeyframeChannel::setDefaultValue ( qreal value )

Definition at line 290 of file kis_scalar_keyframe_channel.cpp.

{
    m_d->defaultValue = value;
}

References m_d, and value().

◆ setLimits()

void KisScalarKeyframeChannel::setLimits	(	qreal	low,
		qreal	high )

Limit channel within scalar value range.

Definition at line 204 of file kis_scalar_keyframe_channel.cpp.

{
    m_d->limits = toQShared(new ScalarKeyframeLimits(low, high));
    QSet<int> keyEntries = allKeyframeTimes();
    foreach (const int &time, keyEntries) {
        KisScalarKeyframeSP scalarKey = keyframeAt<KisScalarKeyframe>(time);
        scalarKey->setLimits(m_d->limits);
        scalarKey->setValue(scalarKey->value());
    }
}

References KisKeyframeChannel::allKeyframeTimes(), m_d, and toQShared().

◆ valueAt()

qreal KisScalarKeyframeChannel::valueAt ( int time ) const

Quickly get the interpolated value at the given time.

Definition at line 222 of file kis_scalar_keyframe_channel.cpp.

{
    const int activeKeyTime = activeKeyframeTime(time);
    KisScalarKeyframeSP activeKey = keyframeAt<KisScalarKeyframe>(activeKeyTime);
    KisScalarKeyframeSP nextKeyframe = keyframeAt<KisScalarKeyframe>(nextKeyframeTime(time));
    qreal result = qQNaN();
 
    if (activeKey) {
        if (!nextKeyframe) {
            result = activeKey->value();
        } else {
            switch (activeKey->interpolationMode()) {
            case KisScalarKeyframe::Constant: {
                    result = activeKey->value();
                    break;
                }
            case KisScalarKeyframe::Linear: {
                    const int nextKeyTime = nextKeyframeTime(time);
                    const qreal activeKeyValue = activeKey->value();
                    const qreal nextKeyValue = keyframeAt<KisScalarKeyframe>(nextKeyTime)->value();
                    const int interpolationLength = (nextKeyTime - activeKeyTime);
                    if (interpolationLength > 0) {
                        result = activeKeyValue + (nextKeyValue - activeKeyValue) * (time - activeKeyTime) / (interpolationLength);
                    } else {
                        result = activeKeyValue;
                    }
                    break;
                }
            case KisScalarKeyframe::Bezier: {
                    const int nextKeyTime = nextKeyframeTime(time);
                    const KisScalarKeyframeSP nextKey = keyframeAt<KisScalarKeyframe>(nextKeyTime);
                    QPointF point0 = QPointF(activeKeyTime, activeKey->value());
                    QPointF point1 = QPointF(nextKeyTime, nextKey->value());
 
                    QPointF tangent0 = activeKey->rightTangent();
                    QPointF tangent1 = nextKey->leftTangent();
 
                    normalizeTangents(point0, tangent0, tangent1, point1);
                    qreal t = KisScalarKeyframeChannel::findCubicCurveParameter(point0.x(), tangent0.x(), tangent1.x(), point1.x(), time);
                    result = KisScalarKeyframeChannel::interpolate(point0, tangent0, tangent1, point1, t).y();
                    break;
                }
            default: {
                    KIS_ASSERT_RECOVER_BREAK(false);
                    break;
                }
            }
        }
    } else {
        if (nextKeyframe) {
            result = nextKeyframe->value();
        } else {
            return qQNaN();
        }
    }
 
    // Output value must be also be clamped to account for interpolation.
    if (m_d->limits) {
        return m_d->limits->clamp(result);
    } else {
        return result;
    }
}

References KisKeyframeChannel::activeKeyframeTime(), KisScalarKeyframe::Bezier, KisScalarKeyframe::Constant, findCubicCurveParameter(), interpolate(), KIS_ASSERT_RECOVER_BREAK, KisScalarKeyframe::Linear, m_d, KisKeyframeChannel::nextKeyframeTime(), and normalizeTangents().

Member Data Documentation

◆ m_d

QScopedPointer<Private> KisScalarKeyframeChannel::m_d

private

Definition at line 163 of file kis_scalar_keyframe_channel.h.

The documentation for this class was generated from the following files:

libs/image/kis_scalar_keyframe_channel.h
libs/image/kis_scalar_keyframe_channel.cpp

Classes

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisScalarKeyframeChannel() [1/2]

◆ KisScalarKeyframeChannel() [2/2]

◆ ~KisScalarKeyframeChannel()

Member Function Documentation

◆ addScalarKeyframe()

◆ affectedFrames()

◆ affectedRect()

◆ createKeyframe()

◆ cubicBezier()

◆ currentValue()

◆ findCubicCurveParameter()

◆ identicalFrames()

◆ insertKeyframe()

◆ interpolate()

◆ isCurrentTimeAffectedBy()

◆ limits()

◆ loadKeyframe()

◆ normalizeTangents()

◆ removeKeyframe()

◆ removeLimits()

◆ saveKeyframe()

◆ setDefaultInterpolationMode()

◆ setDefaultValue()

◆ setLimits()

◆ valueAt()

Member Data Documentation

◆ m_d