Animation

public bool CaptureIncluded { get; }

Returns true if the capture track is included. This is a cached readonly value for performance.

public double Length { get; set; }

The total length of the animation (in seconds). Note: Length is not delimited by the last key, as this one may be before or after the end to ensure correct interpolation and looping.

public Animation.LoopModeEnum LoopMode { get; set; }

Determines the behavior of both ends of the animation timeline during animation playback. This indicates whether and how the animation should be restarted, and is also used to correctly interpolate animation cycles.

public float Step { get; set; }

The animation step value.

public void AddMarker(StringName name, double time);

Adds a marker to this Animation.

public int AddTrack(Animation.TrackType type, int atPosition = -1);

Adds a track to the Animation.

public StringName AnimationTrackGetKeyAnimation(int trackIdx, int keyIdx);

Returns the animation name at the key identified by key_idx. The track_idx must be the index of an Animation Track.

public int AnimationTrackInsertKey(int trackIdx, double time, StringName animation);

Inserts a key with value animation at the given time (in seconds). The track_idx must be the index of an Animation Track.

public void AnimationTrackSetKeyAnimation(int trackIdx, int keyIdx, StringName animation);

Sets the key identified by key_idx to value animation. The track_idx must be the index of an Animation Track.

public float AudioTrackGetKeyEndOffset(int trackIdx, int keyIdx);

Returns the end offset of the key identified by key_idx. The track_idx must be the index of an Audio Track. End offset is the number of seconds cut off at the ending of the audio stream.

public float AudioTrackGetKeyStartOffset(int trackIdx, int keyIdx);

Returns the start offset of the key identified by key_idx. The track_idx must be the index of an Audio Track. Start offset is the number of seconds cut off at the beginning of the audio stream.

public Resource AudioTrackGetKeyStream(int trackIdx, int keyIdx);

Returns the audio stream of the key identified by key_idx. The track_idx must be the index of an Audio Track.

public int AudioTrackInsertKey(int trackIdx, double time, Resource stream, float startOffset = 0f, float endOffset = 0f);

Inserts an Audio Track key at the given time in seconds. The track_idx must be the index of an Audio Track. stream is the AudioStream resource to play. start_offset is the number of seconds cut off at the beginning of the audio stream, while end_offset is at the ending.

public bool AudioTrackIsUseBlend(int trackIdx);

Returns true if the track at track_idx will be blended with other animations.

public void AudioTrackSetKeyEndOffset(int trackIdx, int keyIdx, float offset);

Sets the end offset of the key identified by key_idx to value offset. The track_idx must be the index of an Audio Track.

public void AudioTrackSetKeyStartOffset(int trackIdx, int keyIdx, float offset);

Sets the start offset of the key identified by key_idx to value offset. The track_idx must be the index of an Audio Track.

public void AudioTrackSetKeyStream(int trackIdx, int keyIdx, Resource stream);

Sets the stream of the key identified by key_idx to value stream. The track_idx must be the index of an Audio Track.

public void AudioTrackSetUseBlend(int trackIdx, bool enable);

Sets whether the track will be blended with other animations. If true, the audio playback volume changes depending on the blend value.

public Vector2 BezierTrackGetKeyInHandle(int trackIdx, int keyIdx);

Returns the in handle of the key identified by key_idx. The track_idx must be the index of a Bezier Track.

public Vector2 BezierTrackGetKeyOutHandle(int trackIdx, int keyIdx);

Returns the out handle of the key identified by key_idx. The track_idx must be the index of a Bezier Track.

public float BezierTrackGetKeyValue(int trackIdx, int keyIdx);

Returns the value of the key identified by key_idx. The track_idx must be the index of a Bezier Track.

public int BezierTrackInsertKey(int trackIdx, double time, float value, Vector2? inHandle = default, Vector2? outHandle = default);

Inserts a Bezier Track key at the given time in seconds. The track_idx must be the index of a Bezier Track. in_handle is the left-side weight of the added Bezier curve point, out_handle is the right-side one, while value is the actual value at this point.

public float BezierTrackInterpolate(int trackIdx, double time);

Returns the interpolated value at the given time (in seconds). The track_idx must be the index of a Bezier Track.

public void BezierTrackSetKeyInHandle(int trackIdx, int keyIdx, Vector2 inHandle, float balancedValueTimeRatio = 1f);

Sets the in handle of the key identified by key_idx to value in_handle. The track_idx must be the index of a Bezier Track.

public void BezierTrackSetKeyOutHandle(int trackIdx, int keyIdx, Vector2 outHandle, float balancedValueTimeRatio = 1f);

Sets the out handle of the key identified by key_idx to value out_handle. The track_idx must be the index of a Bezier Track.

public void BezierTrackSetKeyValue(int trackIdx, int keyIdx, float value);

Sets the value of the key identified by key_idx to the given value. The track_idx must be the index of a Bezier Track.

public int BlendShapeTrackInsertKey(int trackIdx, double time, float amount);

Inserts a key in a given blend shape track. Returns the key index.

public float BlendShapeTrackInterpolate(int trackIdx, double timeSec);

Returns the interpolated blend shape value at the given time (in seconds). The track_idx must be the index of a blend shape track. Note: If backward is true, the keys are retrieved on the reversed timeline. See also Animation.ValueTrackInterpolate.

public float BlendShapeTrackInterpolate(int trackIdx, double timeSec, bool backward = false);

Returns the interpolated blend shape value at the given time (in seconds). The track_idx must be the index of a blend shape track. Note: If backward is true, the keys are retrieved on the reversed timeline. See also Animation.ValueTrackInterpolate.

public void Clear();

Clear the animation (clear all tracks and reset all).

public void Compress(uint pageSize = 8192, uint fps = 120, float splitTolerance = 4f);

Compress the animation and all its tracks in-place. This will make Animation.TrackIsCompressed return true once called on this Animation. Compressed tracks require less memory to be played, and are designed to be used for complex 3D animations (such as cutscenes) imported from external 3D software. Compression is lossy, but the difference is usually not noticeable in real world conditions. Note: Compressed tracks have various limitations (such as not being editable from the editor), so only use compressed animations if you actually need them.

public void CopyTrack(int trackIdx, Animation toAnimation);

Adds a new track to to_animation that is a copy of the given track from this animation.

public int FindTrack(EntityPath path, Animation.TrackType type);

Returns the index of the specified track. If the track is not found, return -1.

public StringName GetMarkerAtTime(double time);

Returns the name of the marker located at the given time.

public Color GetMarkerColor(StringName name);

Returns the given marker's color.

public string[] GetMarkerNames();

Returns every marker in this Animation, sorted ascending by time.

public double GetMarkerTime(StringName name);

Returns the given marker's time.

public StringName GetNextMarker(double time);

Returns the closest marker that comes after the given time. If no such marker exists, an empty string is returned.

public StringName GetPrevMarker(double time);

Returns the closest marker that comes before the given time. If no such marker exists, an empty string is returned.

public int GetTrackCount();

Returns the amount of tracks in the animation.

public bool HasMarker(StringName name);

Returns true if this Animation contains a marker with the given name.

public StringName MethodTrackGetName(int trackIdx, int keyIdx);

Returns the method name of a method track.

public Reckfell.Collections.Array MethodTrackGetParams(int trackIdx, int keyIdx);

Returns the arguments values to be called on a method track for a given key in a given track.

public void Optimize(float allowedVelocityErr = 0.01f, float allowedAngularErr = 0.01f, int precision = 3);

Optimize the animation and all its tracks in-place. This will preserve only as many keys as are necessary to keep the animation within the specified bounds.

public int PositionTrackInsertKey(int trackIdx, double time, Vector3 position);

Inserts a key in a given 3D position track. Returns the key index.

public Vector3 PositionTrackInterpolate(int trackIdx, double timeSec);

Returns the interpolated position value at the given time (in seconds). The track_idx must be the index of a 3D position track. Note: If backward is true, the keys are retrieved on the reversed timeline. See also Animation.ValueTrackInterpolate.

public Vector3 PositionTrackInterpolate(int trackIdx, double timeSec, bool backward = false);

Returns the interpolated position value at the given time (in seconds). The track_idx must be the index of a 3D position track. Note: If backward is true, the keys are retrieved on the reversed timeline. See also Animation.ValueTrackInterpolate.

public void RemoveMarker(StringName name);

Removes the marker with the given name from this Animation.

public void RemoveTrack(int trackIdx);

Removes a track by specifying the track index.

public int RotationTrackInsertKey(int trackIdx, double time, Quaternion rotation);

Inserts a key in a given 3D rotation track. Returns the key index.

public Quaternion RotationTrackInterpolate(int trackIdx, double timeSec);

Returns the interpolated rotation value at the given time (in seconds). The track_idx must be the index of a 3D rotation track. Note: If backward is true, the keys are retrieved on the reversed timeline. See also Animation.ValueTrackInterpolate.

public Quaternion RotationTrackInterpolate(int trackIdx, double timeSec, bool backward = false);

Returns the interpolated rotation value at the given time (in seconds). The track_idx must be the index of a 3D rotation track. Note: If backward is true, the keys are retrieved on the reversed timeline. See also Animation.ValueTrackInterpolate.

public int ScaleTrackInsertKey(int trackIdx, double time, Vector3 scale);

Inserts a key in a given 3D scale track. Returns the key index.

public Vector3 ScaleTrackInterpolate(int trackIdx, double timeSec);

Returns the interpolated scale value at the given time (in seconds). The track_idx must be the index of a 3D scale track. Note: If backward is true, the keys are retrieved on the reversed timeline. See also Animation.ValueTrackInterpolate.

public Vector3 ScaleTrackInterpolate(int trackIdx, double timeSec, bool backward = false);

Returns the interpolated scale value at the given time (in seconds). The track_idx must be the index of a 3D scale track. Note: If backward is true, the keys are retrieved on the reversed timeline. See also Animation.ValueTrackInterpolate.

public void SetMarkerColor(StringName name, Color color);

Sets the given marker's color.

public int TrackFindKey(int trackIdx, double time, Animation.FindMode findMode);

Finds the key index by time in a given track. Optionally, only find it if the approx/exact time is given. If limit is true, it does not return keys outside the animation range. If backward is true, the direction is reversed in methods that rely on one directional processing. For example, in case find_mode is Animation.FindMode.Nearest, if there is no key in the current position just after seeked, the first key found is retrieved by searching before the position, but if backward is true, the first key found is retrieved after the position.

public int TrackFindKey(int trackIdx, double time, Animation.FindMode findMode = Animation.FindMode.Nearest, bool limit = false, bool backward = false);

Finds the key index by time in a given track. Optionally, only find it if the approx/exact time is given. If limit is true, it does not return keys outside the animation range. If backward is true, the direction is reversed in methods that rely on one directional processing. For example, in case find_mode is Animation.FindMode.Nearest, if there is no key in the current position just after seeked, the first key found is retrieved by searching before the position, but if backward is true, the first key found is retrieved after the position.

public bool TrackGetInterpolationLoopWrap(int trackIdx);

Returns true if the track at track_idx wraps the interpolation loop. New tracks wrap the interpolation loop by default.

public Animation.InterpolationType TrackGetInterpolationType(int trackIdx);

Returns the interpolation type of a given track.

public int TrackGetKeyCount(int trackIdx);

Returns the number of keys in a given track.

public double TrackGetKeyTime(int trackIdx, int keyIdx);

Returns the time at which the key is located.

public float TrackGetKeyTransition(int trackIdx, int keyIdx);

Returns the transition curve (easing) for a specific key (see the built-in math function @GlobalScope.ease).

public Variant TrackGetKeyValue(int trackIdx, int keyIdx);

Returns the value of a given key in a given track.

public EntityPath TrackGetPath(int trackIdx);

Gets the path of a track. For more information on the path format, see Animation.TrackSetPath.

public Animation.TrackType TrackGetType(int trackIdx);

Gets the type of a track.

public int TrackInsertKey(int trackIdx, double time, Variant key, float transition = 1f);

Inserts a generic key in a given track. Returns the key index.

public bool TrackIsCompressed(int trackIdx);

Returns true if the track is compressed, false otherwise. See also Animation.Compress.

public bool TrackIsEnabled(int trackIdx);

Returns true if the track at index track_idx is enabled.

public bool TrackIsImported(int trackIdx);

Returns true if the given track is imported. Else, return false.

public void TrackMoveDown(int trackIdx);

Moves a track down.

public void TrackMoveTo(int trackIdx, int toIdx);

Changes the index position of track track_idx to the one defined in to_idx.

public void TrackMoveUp(int trackIdx);

Moves a track up.

public void TrackRemoveKey(int trackIdx, int keyIdx);

Removes a key by index in a given track.

public void TrackRemoveKeyAtTime(int trackIdx, double time);

Removes a key at time in a given track.

public void TrackSetEnabled(int trackIdx, bool enabled);

Enables/disables the given track. Tracks are enabled by default.

public void TrackSetImported(int trackIdx, bool imported);

Sets the given track as imported or not.

public void TrackSetInterpolationLoopWrap(int trackIdx, bool interpolation);

If true, the track at track_idx wraps the interpolation loop.

public void TrackSetInterpolationType(int trackIdx, Animation.InterpolationType interpolation);

Sets the interpolation type of a given track.

public void TrackSetKeyTime(int trackIdx, int keyIdx, double time);

Sets the time of an existing key.

public void TrackSetKeyTransition(int trackIdx, int keyIdx, float transition);

Sets the transition curve (easing) for a specific key (see the built-in math function @GlobalScope.ease).

public void TrackSetKeyValue(int trackIdx, int key, Variant value);

Sets the value of an existing key.

public void TrackSetPath(int trackIdx, EntityPath path);

Sets the track target relative to the mixer RootEntity. Value tracks include a property, such as Visual:position. Specialized Position3D/Rotation3D/Scale3D tracks target an Entity3D or bone path without the property suffix. Engine property strings can differ from C# names.

public void TrackSwap(int trackIdx, int withIdx);

Swaps the track track_idx's index position with the track with_idx.

public Animation.UpdateMode ValueTrackGetUpdateMode(int trackIdx);

Returns the update mode of a value track.

public Variant ValueTrackInterpolate(int trackIdx, double timeSec);

Returns the interpolated value at the given time (in seconds). The track_idx must be the index of a value track. If backward is true, the keys are retrieved on the reversed timeline, so the base key is the key after time_sec. This changes the result only for Animation.UpdateMode.Discrete and Animation.InterpolationType.Nearest; the other interpolation types give the same result as forward. Note: AnimationMixer always passes false for continuous tracks with playback API.

public Variant ValueTrackInterpolate(int trackIdx, double timeSec, bool backward = false);

Returns the interpolated value at the given time (in seconds). The track_idx must be the index of a value track. If backward is true, the keys are retrieved on the reversed timeline, so the base key is the key after time_sec. This changes the result only for Animation.UpdateMode.Discrete and Animation.InterpolationType.Nearest; the other interpolation types give the same result as forward. Note: AnimationMixer always passes false for continuous tracks with playback API.

public void ValueTrackSetUpdateMode(int trackIdx, Animation.UpdateMode mode);

Sets the update mode of a value track.