| qabstractanimation.cpp |
!
\class Qt3DAnimation::QAbstractAnimation
\brief An abstract base class for Qt3D animations.
\inmodule Qt3DAnimation
\since 5.9
\inherits QObject
Qt3DAnimation::QAbstractAnimation is an abstract base class for all animations.
Qt3DAnimation::QAbstractAnimation can not be directly instantiated, but rather
through its subclasses. QAbstractAnimation specifies common properties
for all Qt3D animations, such as animation name and type, current position and animation
duration, while leaving the actual animating for the subclasses.
|
4325 |
- |
| qabstractanimation.h |
|
1683 |
- |
| qabstractanimation_p.h |
|
1027 |
- |
| qabstractanimationclip.cpp |
!
\class Qt3DAnimation::QAbstractAnimationClip
\inherits Qt3DCore::QNode
\inmodule Qt3DAnimation
\since 5.9
\brief QAbstractAnimationClip is the base class for types providing key frame animation data.
To utilise the key frame animation framework in the Qt 3D Animation module
the animator component in use needs to be provided with the key frame animation data. The
animation data is provided by one of the concrete subclasses of QAbstractAnimationClip:
\list
\li Qt3DAnimation::QAnimationClip
\li Qt3DAnimation::QAnimationClipLoader
\endlist
QAnimationClip should be used when you want to create the animation data
programmatically within your application. The actual data is set with a
QAnimationClipData value type.
If you are loading baked animation data from a file, e.g. as created by an
artist, then use the QAnimationClipLoader class and set its \c source property.
Once the animation clip has been populated with data using the above
methods, the read-only duration property will be updated by the Qt 3D Animation
backend.
The typical usage of animation clips is:
\code
auto animator = new QClipAnimator();
auto clip = new QAnimationClipLoader();
clip->setSource(QUrl::fromLocalFile("bounce.json"));
animator->setClip(clip);
animator->setChannelMapper(...);
animator->setRunning(true);
\endcode
Animation clips are also used as the leaf node values in animation blend trees:
\code
// Create leaf nodes of blend tree
auto slideClipValue = new QClipBlendValue(
new QAnimationClipLoader(QUrl::fromLocalFile("slide.json")));
auto bounceClipValue = new QClipBlendValue(
new QAnimationClipLoader(QUrl::fromLocalFile("bounce.json")));
// Create blend tree inner node
auto additiveNode = new QAdditiveClipBlend();
additiveNode->setBaseClip(slideClipValue);
additiveNode->setAdditiveClip(bounceClipValue);
additiveNode->setAdditiveFactor(0.5f);
// Run the animator
auto animator = new QBlendedClipAnimator();
animator->setBlendTree(additiveNode);
animator->setChannelMapper(...);
animator->setRunning(true);
\endcode
\sa Qt3DAnimation::QAnimationClip, Qt3DAnimation::QAnimationClipLoader
|
3779 |
- |
| qabstractanimationclip.h |
|
998 |
- |
| qabstractanimationclip_p.h |
|
989 |
- |
| qabstractchannelmapping.cpp |
! \internal |
874 |
- |
| qabstractchannelmapping.h |
|
831 |
- |
| qabstractchannelmapping_p.h |
|
1264 |
- |
| qabstractclipanimator.cpp |
!
\qmltype AbstractClipAnimator
\nativetype Qt3DAnimation::QAbstractClipAnimator
\inqmlmodule Qt3D.Animation
\since 5.9
\brief AbstractClipAnimator is the base class for types providing animation playback
capabilities.
Subclasses of AbstractClipAnimator can be aggregated by an Entity to
provide animation capabilities. The animator components provide an
interface for controlling the animation (e.g. start, stop). Each animator
type requires some form of animation data such as an AbstractAnimationClip
as well as a ChannelMapper which describes how the channels in the
animation clip should be mapped onto the properties of the objects you wish
to animate.
The following subclasses are available:
\list
\li Qt3D.Animation.ClipAnimator
\li Qt3D.Animation.BlendedClipAnimator
\endlist
|
8089 |
- |
| qabstractclipanimator.h |
|
2290 |
- |
| qabstractclipanimator_p.h |
|
1247 |
- |
| qabstractclipblendnode.cpp |
!
\qmltype AbstractClipBlendNode
\nativetype Qt3DAnimation::QAbstractClipBlendNode
\inqmlmodule Qt3D.Animation
\since 5.9
\brief AbstractClipBlendNode is the base class for types used to construct animation blend
trees.
Animation blend trees are used with a BlendedClipAnimator to dynamically blend a set of
animation clips together. The way in which the blending of animation clips is performed is
controlled by the structure of the blend tree and the properties on the nodes it contains.
The leaf nodes in a blend tree are containers for the input animation clips. These clips can be
baked clips read from file via AnimationClipLoader, or they can be clips that you build within
your application with AnimatitonClip and AnimationClipData. To include a clip in your blend
tree, wrap it in a ClipBlendValue node.
The interior nodes of a blend tree represent blending operations that will be applied to their
arguments which hold the input clips or even entire sub-trees of other blend tree nodes.
At present, the Qt 3D Animation module provides the following blend tree node types:
\list
\li Qt3D.Animation.ClipBlendValue
\li Qt3D.Animation.LerpClipBlend
\li Qt3D.Animation.QAdditiveClipBlend
\endlist
Additional node types representing other blending operations will be added in the future.
\sa BlendedClipAnimator
|
3683 |
- |
| qabstractclipblendnode.h |
|
944 |
- |
| qabstractclipblendnode_p.h |
|
969 |
- |
| qadditiveclipblend.cpp |
!
\qmltype AdditiveClipBlend
\nativetype Qt3DAnimation::QAdditiveClipBlend
\inqmlmodule Qt3D.Animation
\since 5.9
\brief Performs an additive blend of two animation clips based on an additive factor.
QAdditiveClipBlend can be useful to create advanced animation effects based on
individual animation clips. For example, if you:
\list
\li set the baseClip property to a normal walk cycle animation clip and
\li set the additiveClip property to a shaking head difference clip,
\endlist
then adjusting the additiveFactor property will control how much of the additiveClip gets added
on to the baseClip. This has he effect that with an additiveFactor of zero, this blend node will
yield the original walk cycle clip. With an additiveFactor of 1, it will yield the walk cycle
including a shaking head animation.
The blending operation implemented by this class is:
\badcode
resultClip = baseClip + additiveFactor * additiveClip
\endcode
There is nothing stopping you from using values for the additiveFacor property outside the 0 to
1 range, but please be aware that the input animation clips may not be authored in such a way
for this to make sense.
\sa BlendedClipAnimator
|
6522 |
- |
| qadditiveclipblend.h |
|
1799 |
- |
| qadditiveclipblend_p.h |
|
1178 |
- |
| qanimationaspect.cpp |
!
\class Qt3DAnimation::QAnimationAspect
\inherits Qt3DCore::QAbstractAspect
\inmodule Qt3DAnimation
\brief Provides key-frame animation capabilities to Qt 3D.
\since 5.9
QAnimationAspect provides key-frame animation to Qt 3D.
|
5963 |
- |
| qanimationaspect.h |
|
903 |
- |
| qanimationaspect_p.h |
|
953 |
- |
| qanimationcallback.cpp |
|
344 |
- |
| qanimationcallback.h |
|
797 |
- |
| qanimationcallback.qdoc |
|
791 |
- |
| qanimationclip.cpp |
!
\class Qt3DAnimation::QAnimationClip
\inherits Qt3dAnimation::QAbstractAnimationClip
\inmodule Qt3DAnimation
\brief Specifies key frame animation data.
|
1527 |
- |
| qanimationclip.h |
|
1232 |
- |
| qanimationclip_p.h |
|
993 |
- |
| qanimationclipdata.cpp |
!
\class Qt3DAnimation::QAnimationClipData
\inmodule Qt3DAnimation
\brief Class containing the animation data.
|
2322 |
- |
| qanimationclipdata.h |
|
2532 |
- |
| qanimationcliploader.cpp |
!
\enum Qt3DAnimation::QAnimationClipLoader::Status
This enum identifies the status of animation clip.
\value NotReady The clip has not been loaded yet
\value Ready The clip was successfully loaded
\value Error An error occurred while loading the clip
|
3225 |
- |
| qanimationcliploader.h |
|
1520 |
- |
| qanimationcliploader_p.h |
|
1090 |
- |
| qanimationcontroller.cpp |
!
\class Qt3DAnimation::QAnimationController
\brief A controller class for animations.
\inmodule Qt3DAnimation
\since 5.9
\inherits QObject
Qt3DAnimation::QAnimationController class controls the selection and playback of animations.
The class can be used to find all animations from Qt3DCore::QEntity tree and create
\l {Qt3DAnimation::QAnimationGroup} {QAnimationGroups} from the animations with the same name.
The user can select which animation group is currently controlled with the animation
controller by setting the active animation. The animation position is then propagated to
that group after scaling and offsetting the provided position value with the
positionScale and positionOffset values.
\note that the animation controller doesn't have internal timer, but instead the user
is responsible for updating the position property in timely manner.
|
11306 |
- |
| qanimationcontroller.h |
|
2609 |
- |
| qanimationcontroller_p.h |
|
1311 |
- |
| qanimationgroup.cpp |
!
\class Qt3DAnimation::QAnimationGroup
\brief A class grouping animations together.
\inmodule Qt3DAnimation
\since 5.9
\inherits QObject
Qt3DAnimation::QAnimationGroup class is used to group multiple animations so that
they can act as one animation. The position set to the group is also set to
all animations in a group. The duration is the maximum of the individual animations.
The animations can be any supported animation type and do not have to have the same name.
|
4729 |
- |
| qanimationgroup.h |
|
1544 |
- |
| qanimationgroup_p.h |
|
987 |
- |
| qblendedclipanimator.cpp |
!
\qmltype BlendedClipAnimator
\nativetype Qt3DAnimation::QBlendedClipAnimator
\inqmlmodule Qt3D.Animation
\inherits AbstractClipAnimator
\since 5.9
\brief BlendedClipAnimator is a component providing animation playback capabilities of a tree
of blend nodes.
An instance of BlendedClipAnimator can be aggregated by an Entity to add the ability to play
back animation clips and to apply the calculated animation values to properties of QObjects.
Whereas a ClipAnimator gets its animation data from a single animation clip,
BlendedClipAnimator can blend together multiple clips. The animation data is obtained by
evaluating a so called \e {blend tree}. A blend tree is a hierarchical tree structure where the
leaf nodes are value nodes that encapsulate an animation clip (AbstractAnimationClip); and the
internal nodes represent blending operations that operate on the nodes pointed to by their
operand properties.
To associate a blend tree with a BlendedClipAnimator, set the animator's blendTree property to
point at the root node of your blend tree:
\badcode
BlendedClipAnimator {
blendTree: AdditiveClipBlend {
....
}
}
\endcode
A blend tree can be constructed from the following node types:
\note The blend node tree should only be edited when the animator is not running.
\list
\li Qt3D.Animation.ClipBlendValue
\li Qt3D.Animation.LerpClipBlend
\li Qt3D.Animation.AdditiveClipBlend
\endlist
Additional node types will be added over time.
As an example consider the following blend tree:
\badcode
Clip0----
|
Lerp Node----
| |
Clip1---- Additive Node
|
Clip2----
\endcode
This can be created and used as follows:
\badcode
BlendedClipAnimator {
blendTree: AdditiveClipBlend {
baseClip: LerpClipBlend {
startClip: ClipBlendValue {
clip: AnimationClipLoader { source: "walk.json" }
}
endClip: ClipBlendValue {
clip: AnimationClipLoader { source: "run.json" }
}
}
additiveClip: ClipBlendValue {
clip: AnimationClipLoader { source: "wave-arm.json" }
}
}
channelMapper: ChannelMapper {...}
running: true
}
\endcode
By authoring a set of animation clips and blending between them dynamically at runtime with a
blend tree, we open up a huge set of possible resulting animations. As some simple examples of
the above blend tree, where alpha is the additive factor and beta is the lerp blend factor we
can get a 2D continuum of possible animations:
\badcode
(alpha = 0, beta = 1) Running, No arm waving --- (alpha = 1, beta = 1) Running, Arm waving
| |
| |
| |
(alpha = 0, beta = 0) Walking, No arm waving --- (alpha = 0, beta = 1) Running, No arm waving
\endcode
More complex blend trees offer even more flexibility for combining your animation clips. Note
that the values used to control the blend tree (alpha and beta above) are simple properties on
the blend nodes. This means, that these properties themselves can also be controlled by
the animation framework.
|
9816 |
- |
| qblendedclipanimator.h |
|
1297 |
- |
| qblendedclipanimator_p.h |
|
1081 |
- |
| qcallbackmapping.cpp |
!
\class Qt3DAnimation::QCallbackMapping
\inherits Qt3DCore::QAbstractChannelMapping
\inmodule Qt3DAnimation
\brief Allows to map the channels within the clip onto an invocation
of a callback object.
|
3442 |
- |
| qcallbackmapping.h |
|
1361 |
- |
| qcallbackmapping_p.h |
|
1227 |
- |
| qchannel.cpp |
!
\class Qt3DAnimation::QChannel
\inmodule Qt3DAnimation
\brief Defines a channel for a QAnimationClipData.
The animation system interpolates each channel component independently
except in the case the QChannel is called "Rotation" (case sensitive),
it has four QChannelComponents and the same number of keyframes for
each QChannelComponent. In that case the interpolation will be performed
using SLERP.
|
2673 |
- |
| qchannel.h |
|
2204 |
- |
| qchannelcomponent.cpp |
|
2177 |
- |
| qchannelcomponent.h |
|
2202 |
- |
| qchannelmapper.cpp |
!
\class Qt3DAnimation::QChannelMapper
\inmodule Qt3DAnimation
\brief Allows to map the channels within the clip onto properties of
objects in the application.
|
2081 |
- |
| qchannelmapper.h |
|
1023 |
- |
| qchannelmapper_p.h |
|
970 |
- |
| qchannelmapping.cpp |
!
\internal
Find the type of the property specified on the target node
|
5599 |
- |
| qchannelmapping.h |
|
1605 |
- |
| qchannelmapping_p.h |
|
1388 |
- |
| qclipanimator.cpp |
!
\qmltype ClipAnimator
\nativetype Qt3DAnimation::QClipAnimator
\inqmlmodule Qt3D.Animation
\inherits AbstractClipAnimator
\since 5.9
\brief ClipAnimator is a component providing simple animation playback capabilities.
An instance of ClipAnimator can be aggregated by an Entity to add the ability to play back
animation clips and to apply the calculated animation values to properties of QObjects.
The animation key frame data is provided via the clip property. This can be created
programmatically with AnimationClip or loaded from file with AnimationClipLoader.
In order to apply the values played back from the channels of data in the animation clip, the
clip animator needs to have a ChannelMapper object assigned to the channelMapper property.
The properties for controlling the animator are provided by the AbstractClipAnimator base
class.
\sa {Qt3DAnimation::QAbstractClipAnimator}{AbstractClipAnimator}, {Qt3DAnimation::QAbstractAnimationClip}{AbstractAnimationClip}, {Qt3DAnimation::QChannelMapper}{ChannelMapper}, {Qt3DAnimation::QBlendedClipAnimator}{BlendedClipAnimator}
|
4392 |
- |
| qclipanimator.h |
|
1216 |
- |
| qclipanimator_p.h |
|
1051 |
- |
| qclipblendvalue.cpp |
!
\class Qt3DAnimation::QClipBlendValue
\inherits Qt3DAnimation::QAbstractClipBlendNode
\inmodule Qt3DAnimation
\brief Class used for including a clip in a blend tree.
|
2266 |
- |
| qclipblendvalue.h |
|
1336 |
- |
| qclipblendvalue_p.h |
|
1004 |
- |
| qclock.cpp |
!
\property Qt3DAnimation::QClock::playbackRate
The playback speed of the animation. The playback speed can be negative.
When that is the case the animation will be played back from the current
normalized time value back to 0 and for the number of loops it had been
played for with a positive playback rate.
|
1263 |
- |
| qclock.h |
|
981 |
- |
| qclock_p.h |
|
864 |
- |
| qkeyframe.cpp |
!
\class Qt3DAnimation::QKeyFrame
\inmodule Qt3DAnimation
\brief A base class for handling keyframes.
|
400 |
- |
| qkeyframe.h |
|
3149 |
- |
| qkeyframeanimation.cpp |
!
\class Qt3DAnimation::QKeyframeAnimation
\brief A class implementing simple keyframe animation to a QTransform.
\inmodule Qt3DAnimation
\since 5.9
\inherits Qt3DAnimation::QAbstractAnimation
A Qt3DAnimation::QKeyframeAnimation class implements simple keyframe animation
that can be used to animate \l QTransform. The keyframes consists of multiple
timed QTransforms, which are interpolated and applied to the target \l QTransform.
\l QEasingCurve is used between keyframes to control the interpolator. RepeatMode
can be set for when the position set to the QKeyframeAnimation is below or above
the values defined in the keyframe positions.
|
12489 |
- |
| qkeyframeanimation.h |
|
2616 |
- |
| qkeyframeanimation_p.h |
|
1456 |
- |
| qlerpclipblend.cpp |
!
\qmltype LerpClipBlend
\nativetype Qt3DAnimation::QLerpClipBlend
\inqmlmodule Qt3D.Animation
\brief Performs a linear interpolation of two animation clips based on a
normalized factor.
\since 5.9
LerpClipBlend can be useful to create advanced animation effects based on
individual animation clips. For instance, given a player character,, lerp
blending could be used to combine a walking animation clip with an injured
animation clip based on a blend factor that increases the more the player
gets injured. This would then allow with blend factor == 0 to have a non
injured walking player, with blend factor == 1 a fully injured player, with
blend factor == 0.5 a partially walking and injured player.
\sa BlendedClipAnimator
|
5423 |
- |
| qlerpclipblend.h |
|
1702 |
- |
| qlerpclipblend_p.h |
|
1130 |
- |
| qmorphinganimation.cpp |
!
\class Qt3DAnimation::QMorphingAnimation
\brief A class implementing blend-shape morphing animation.
\inmodule Qt3DAnimation
\since 5.9
\inherits Qt3DAnimation::QAbstractAnimation
A Qt3DAnimation::QMorphingAnimation class implements blend-shape morphing animation
to a target \l {Qt3DRender::QGeometryRenderer}{QGeometryRenderer}. The QMorphingAnimation
sets the correct \l {Qt3DCore::QAttribute}{QAttributes} from the
\l {Qt3DAnimation::QMorphTarget}{morph targets} to the target
\l {Qt3DRender::QGeometryRenderer::geometry} {QGeometryRenderer::geometry} and calculates
interpolator for the current position. The actual blending between the attributes must
be implemented in the material. Qt3DAnimation::QMorphPhongMaterial implements material
with morphing support for phong lighting model. The blending happens between
2 attributes - 'base' and 'target'. The names for the base and target attributes are taken from
the morph target names, where the base attribute retains the name it already has and the
target attribute name gets 'Target' appended to the name. The interpolator can be
set as a \l {Qt3DRender::QParameter}{QParameter} to the used material.
All morph targets in the animation should contain the attributes with same names as those
in the base geometry.
|
14151 |
- |
| qmorphinganimation.h |
|
2806 |
- |
| qmorphinganimation_p.h |
|
1591 |
- |
| qmorphtarget.cpp |
!
\class Qt3DAnimation::QMorphTarget
\brief A class providing morph targets to blend-shape animation.
\inmodule Qt3DAnimation
\since 5.9
\inherits QObject
A Qt3DAnimation::QMorphTarget class is a convenience class, which provides a list
of \l {Qt3DCore::QAttribute} {QAttributes}, which the QMorphingAnimation uses
to animate geometry. A QMorphTarget can also be created based on existing
\l Qt3DCore::QGeometry.
|
4471 |
- |
| qmorphtarget.h |
|
1334 |
- |
| qmorphtarget_p.h |
|
924 |
- |
| qskeletonmapping.cpp |
!
\property Qt3DAnimation::QSkeletonMapping::skeleton
Holds the skeleton that should be used for the skeleton mapping.
|
1697 |
- |
| qskeletonmapping.h |
|
1221 |
- |
| qskeletonmapping_p.h |
|
1066 |
- |
| qvertexblendanimation.cpp |
!
\class Qt3DAnimation::QVertexBlendAnimation
\brief A class implementing vertex-blend morphing animation.
\inmodule Qt3DAnimation
\since 5.9
\inherits Qt3DAnimation::QAbstractAnimation
A Qt3DAnimation::QVertexBlendAnimation class implements vertex-blend morphing animation
to a target \l {Qt3DRender::QGeometryRenderer}{QGeometryRenderer}. The QVertexBlendAnimation
sets the correct \l {Qt3DCore::QAttribute}{QAttributes} from the
\l {Qt3DAnimation::QMorphTarget}{morph targets} to the target
\l {Qt3DRender::QGeometryRenderer::geometry} {QGeometryRenderer::geometry} and calculates
interpolator for the current position. Unlike with QMorphingAnimation, where the blending is
controller with blend weights, the blending occurs between sequential morph targets.
The actual blending between the attributes must be implemented in the material.
Qt3DAnimation::QMorphPhongMaterial implements material with morphing support for phong
lighting model. The blending happens between 2 attributes - 'base' and 'target'.
The names for the base and target attributes are taken from the morph target names,
where the base attribute retains the name it already has and the target attribute name
gets 'Target' appended to the name. The interpolator can be set as
a \l {Qt3DRender::QParameter}{QParameter} to the used material.
All morph targets in the animation should contain the attributes with same names as those
in the base geometry.
|
11329 |
- |
| qvertexblendanimation.h |
|
2115 |
- |
| qvertexblendanimation_p.h |
|
1370 |
- |