@ringozz/godot 0.1.0

package/gen/classes/AnimationMixer.ts

@@ -0,0 +1,450 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node } from './Node.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray, NodePath, PackedStringArray, Signal, StringName, Variant } from '../heap-types/index.ts';
+import type { Quaternion, Vector3 } from '../value-types/index.ts';
+import type { Animation } from './Animation.ts';
+import type { AnimationLibrary } from './AnimationLibrary.ts';
+import type { EaseType, TransitionType } from './Tween.ts';
+
+/**
+ * Base class for {@link AnimationPlayer} and {@link AnimationTree} to manage animation lists. It also has general properties and methods for playback and blending.
+ * After instantiating the playback information data within the extended class, the blending is processed by the {@link AnimationMixer}.
+ */
+export class AnimationMixer extends Node {
+
+    /**
+     * Adds `library` to the animation player, under the key `name`.
+     * AnimationMixer has a global library by default with an empty string as key. For adding an animation to the global library:
+     *
+     *
+     * ```gdscript
+     *
+     * var global_library = mixer.get_animation_library("")
+     * global_library.add_animation("animation_name", animation_resource)
+     *
+     * ```
+     */
+    addAnimationLibrary(name: StringName, library: AnimationLibrary): Error { return _C(this, 1180, name, library) as Error; }
+
+    /**
+     * Removes the {@link AnimationLibrary} associated with the key `name`.
+     */
+    removeAnimationLibrary(name: StringName): void { _C(this, 9885, name); }
+
+    /**
+     * Moves the {@link AnimationLibrary} associated with the key `name` to the key `newname`.
+     */
+    renameAnimationLibrary(name: StringName, newname: StringName): void { _C(this, 9994, name, newname); }
+
+    /**
+     * Returns `true` if the {@link AnimationMixer} stores an {@link AnimationLibrary} with key `name`.
+     */
+    hasAnimationLibrary(name: StringName): boolean { return _C(this, 7357, name) as boolean; }
+
+    /**
+     * Returns the first {@link AnimationLibrary} with key `name` or `null` if not found.
+     * To get the {@link AnimationMixer}'s global animation library, use `get_animation_library("")`.
+     */
+    getAnimationLibrary(name: StringName): AnimationLibrary | null { return _C(this, 3760, name) as AnimationLibrary | null; }
+
+    /**
+     * Returns the list of stored library keys.
+     */
+    getAnimationLibraryList(): GodotArray<StringName> { return _C(this, 3761) as GodotArray<StringName>; }
+
+    /**
+     * Returns `true` if the {@link AnimationMixer} stores an {@link Animation} with key `name`.
+     */
+    hasAnimation(name: StringName): boolean { return _C(this, 7356, name) as boolean; }
+
+    /**
+     * Returns the {@link Animation} with the key `name`. If the animation does not exist, `null` is returned and an error is logged.
+     */
+    getAnimation(name: StringName): Animation { return _C(this, 3759, name) as Animation; }
+
+    /**
+     * Returns the list of stored animation keys.
+     */
+    getAnimationList(): PackedStringArray { return _C(this, 3762) as PackedStringArray; }
+
+    /**
+     * Retrieve the motion delta of position with the {@link rootMotionTrack} as a {@link Vector3} that can be used elsewhere.
+     * If {@link rootMotionTrack} is not a path to a track of type {@link Animation.TYPE_POSITION_3D}, returns `Vector3(0, 0, 0)`.
+     * See also {@link rootMotionTrack} and {@link RootMotionView}.
+     * The most basic example is applying position to {@link CharacterBody3D}:
+     *
+     *
+     * ```gdscript
+     *
+     * var current_rotation
+     *
+     * func _process(delta):
+     * 	if Input.is_action_just_pressed("animate"):
+     * 		current_rotation = get_quaternion()
+     * 		state_machine.travel("Animate")
+     * 	var velocity = current_rotation * animation_tree.get_root_motion_position() / delta
+     * 	set_velocity(velocity)
+     * 	move_and_slide()
+     *
+     * ```
+     *
+     *
+     * By using this in combination with {@link getRootMotionRotationAccumulator}, you can apply the root motion position more correctly to account for the rotation of the node.
+     *
+     *
+     * ```gdscript
+     *
+     * func _process(delta):
+     * 	if Input.is_action_just_pressed("animate"):
+     * 		state_machine.travel("Animate")
+     * 	set_quaternion(get_quaternion() * animation_tree.get_root_motion_rotation())
+     * 	var velocity = (animation_tree.get_root_motion_rotation_accumulator().inverse() * get_quaternion()) * animation_tree.get_root_motion_position() / delta
+     * 	set_velocity(velocity)
+     * 	move_and_slide()
+     *
+     * ```
+     *
+     *
+     * If {@link rootMotionLocal} is `true`, returns the pre-multiplied translation value with the inverted rotation.
+     * In this case, the code can be written as follows:
+     *
+     *
+     * ```gdscript
+     *
+     * func _process(delta):
+     * 	if Input.is_action_just_pressed("animate"):
+     * 		state_machine.travel("Animate")
+     * 	set_quaternion(get_quaternion() * animation_tree.get_root_motion_rotation())
+     * 	var velocity = get_quaternion() * animation_tree.get_root_motion_position() / delta
+     * 	set_velocity(velocity)
+     * 	move_and_slide()
+     *
+     * ```
+     */
+    getRootMotionPosition(): Vector3 { return _C(this, 6191) as Vector3; }
+
+    /**
+     * Retrieve the motion delta of rotation with the {@link rootMotionTrack} as a {@link Quaternion} that can be used elsewhere.
+     * If {@link rootMotionTrack} is not a path to a track of type {@link Animation.TYPE_ROTATION_3D}, returns `Quaternion(0, 0, 0, 1)`.
+     * See also {@link rootMotionTrack} and {@link RootMotionView}.
+     * The most basic example is applying rotation to {@link CharacterBody3D}:
+     *
+     *
+     * ```gdscript
+     *
+     * func _process(delta):
+     * 	if Input.is_action_just_pressed("animate"):
+     * 		state_machine.travel("Animate")
+     * 	set_quaternion(get_quaternion() * animation_tree.get_root_motion_rotation())
+     *
+     * ```
+     */
+    getRootMotionRotation(): Quaternion { return _C(this, 6193) as Quaternion; }
+
+    /**
+     * Retrieve the motion delta of scale with the {@link rootMotionTrack} as a {@link Vector3} that can be used elsewhere.
+     * If {@link rootMotionTrack} is not a path to a track of type {@link Animation.TYPE_SCALE_3D}, returns `Vector3(0, 0, 0)`.
+     * See also {@link rootMotionTrack} and {@link RootMotionView}.
+     * The most basic example is applying scale to {@link CharacterBody3D}:
+     *
+     *
+     * ```gdscript
+     *
+     * var current_scale = Vector3(1, 1, 1)
+     * var scale_accum = Vector3(1, 1, 1)
+     *
+     * func _process(delta):
+     * 	if Input.is_action_just_pressed("animate"):
+     * 		current_scale = get_scale()
+     * 		scale_accum = Vector3(1, 1, 1)
+     * 		state_machine.travel("Animate")
+     * 	scale_accum += animation_tree.get_root_motion_scale()
+     * 	set_scale(current_scale * scale_accum)
+     *
+     * ```
+     */
+    getRootMotionScale(): Vector3 { return _C(this, 6195) as Vector3; }
+
+    /**
+     * Retrieve the blended value of the position tracks with the {@link rootMotionTrack} as a {@link Vector3} that can be used elsewhere.
+     * This is useful in cases where you want to respect the initial key values of the animation.
+     * For example, if an animation with only one key `Vector3(0, 0, 0)` is played in the previous frame and then an animation with only one key `Vector3(1, 0, 1)` is played in the next frame, the difference can be calculated as follows:
+     *
+     *
+     * ```gdscript
+     *
+     * var prev_root_motion_position_accumulator
+     *
+     * func _process(delta):
+     * 	if Input.is_action_just_pressed("animate"):
+     * 		state_machine.travel("Animate")
+     * 	var current_root_motion_position_accumulator = animation_tree.get_root_motion_position_accumulator()
+     * 	var difference = current_root_motion_position_accumulator - prev_root_motion_position_accumulator
+     * 	prev_root_motion_position_accumulator = current_root_motion_position_accumulator
+     * 	transform.origin += difference
+     *
+     * ```
+     *
+     *
+     * However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
+     */
+    getRootMotionPositionAccumulator(): Vector3 { return _C(this, 6192) as Vector3; }
+
+    /**
+     * Retrieve the blended value of the rotation tracks with the {@link rootMotionTrack} as a {@link Quaternion} that can be used elsewhere.
+     * This is necessary to apply the root motion position correctly, taking rotation into account. See also {@link getRootMotionPosition}.
+     * Also, this is useful in cases where you want to respect the initial key values of the animation.
+     * For example, if an animation with only one key `Quaternion(0, 0, 0, 1)` is played in the previous frame and then an animation with only one key `Quaternion(0, 0.707, 0, 0.707)` is played in the next frame, the difference can be calculated as follows:
+     *
+     *
+     * ```gdscript
+     *
+     * var prev_root_motion_rotation_accumulator
+     *
+     * func _process(delta):
+     * 	if Input.is_action_just_pressed("animate"):
+     * 		state_machine.travel("Animate")
+     * 	var current_root_motion_rotation_accumulator = animation_tree.get_root_motion_rotation_accumulator()
+     * 	var difference = prev_root_motion_rotation_accumulator.inverse() * current_root_motion_rotation_accumulator
+     * 	prev_root_motion_rotation_accumulator = current_root_motion_rotation_accumulator
+     * 	transform.basis *=  Basis(difference)
+     *
+     * ```
+     *
+     *
+     * However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
+     */
+    getRootMotionRotationAccumulator(): Quaternion { return _C(this, 6194) as Quaternion; }
+
+    /**
+     * Retrieve the blended value of the scale tracks with the {@link rootMotionTrack} as a {@link Vector3} that can be used elsewhere.
+     * For example, if an animation with only one key `Vector3(1, 1, 1)` is played in the previous frame and then an animation with only one key `Vector3(2, 2, 2)` is played in the next frame, the difference can be calculated as follows:
+     *
+     *
+     * ```gdscript
+     *
+     * var prev_root_motion_scale_accumulator
+     *
+     * func _process(delta):
+     * 	if Input.is_action_just_pressed("animate"):
+     * 		state_machine.travel("Animate")
+     * 	var current_root_motion_scale_accumulator = animation_tree.get_root_motion_scale_accumulator()
+     * 	var difference = current_root_motion_scale_accumulator - prev_root_motion_scale_accumulator
+     * 	prev_root_motion_scale_accumulator = current_root_motion_scale_accumulator
+     * 	transform.basis = transform.basis.scaled(difference)
+     *
+     * ```
+     *
+     *
+     * However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
+     */
+    getRootMotionScaleAccumulator(): Vector3 { return _C(this, 6196) as Vector3; }
+
+    /**
+     * {@link AnimationMixer} caches animated nodes. It may not notice if a node disappears; {@link clearCaches} forces it to update the cache again.
+     */
+    clearCaches(): void { _C(this, 2247); }
+
+    /**
+     * Manually advance the animations by the specified time (in seconds).
+     */
+    advance(delta: number /* double */): void { _C(this, 1346, delta); }
+
+    /**
+     * If the animation track specified by `name` has an option {@link Animation.UPDATE_CAPTURE}, stores current values of the objects indicated by the track path as a cache. If there is already a captured cache, the old cache is discarded.
+     * After this it will interpolate with current animation blending result during the playback process for the time specified by `duration`, working like a crossfade.
+     * You can specify `transType` as the curve for the interpolation. For better results, it may be appropriate to specify {@link Tween.TRANS_LINEAR} for cases where the first key of the track begins with a non-zero value or where the key value does not change, and {@link Tween.TRANS_QUAD} for cases where the key value changes linearly.
+     */
+    capture(name: StringName, duration: number /* double */, transType?: TransitionType /* = 0 */, easeType?: EaseType /* = 0 */): void { _C(this, 2135, name, duration, transType, easeType); }
+
+    /**
+     * Returns the key of `animation` or an empty {@link StringName} if not found.
+     */
+    findAnimation(animation: Animation): StringName { return _C(this, 3279, animation) as StringName; }
+
+    /**
+     * Returns the key for the {@link AnimationLibrary} that contains `animation` or an empty {@link StringName} if not found.
+     */
+    findAnimationLibrary(animation: Animation): StringName { return _C(this, 3280, animation) as StringName; }
+
+    /**
+     * If `true`, the {@link AnimationMixer} will be processing.
+     */
+    get active(): boolean { return _C(this, 7746) as boolean; }
+    set active(v: boolean) { _C(this, 10426, v); }
+
+    /**
+     * If `true`, the blending uses the deterministic algorithm. The total weight is not normalized and the result is accumulated with an initial value (`0` or a `"RESET"` animation if present).
+     * This means that if the total amount of blending is `0.0`, the result is equal to the `"RESET"` animation.
+     * If the number of tracks between the blended animations is different, the animation with the missing track is treated as if it had the initial value.
+     * If `false`, The blend does not use the deterministic algorithm. The total weight is normalized and always `1.0`. If the number of tracks between the blended animations is different, nothing is done about the animation that is missing a track.
+     * **Note:** In {@link AnimationTree}, the blending with {@link AnimationNodeAdd2}, {@link AnimationNodeAdd3}, {@link AnimationNodeSub2} or the weight greater than `1.0` may produce unexpected results.
+     * For example, if {@link AnimationNodeAdd2} blends two nodes with the amount `1.0`, then total weight is `2.0` but it will be normalized to make the total amount `1.0` and the result will be equal to {@link AnimationNodeBlend2} with the amount `0.5`.
+     */
+    get deterministic(): boolean { return _C(this, 7880) as boolean; }
+    set deterministic(v: boolean) { _C(this, 11105, v); }
+
+    /**
+     * This is used by the editor. If set to `true`, the scene will be saved with the effects of the reset animation (the animation with the key `"RESET"`) applied as if it had been seeked to time 0, with the editor keeping the values that the scene had before saving.
+     * This makes it more convenient to preview and edit animations in the editor, as changes to the scene will not be saved as long as they are set in the reset animation.
+     */
+    get resetOnSave(): boolean { return _C(this, 8243) as boolean; }
+    set resetOnSave(v: boolean) { _C(this, 12538, v); }
+
+    /**
+     * The node which node path references will travel from.
+     */
+    get rootNode(): NodePath { return _C(this, 6198) as NodePath; }
+    set rootNode(v: NodePath) { _C(this, 12570, v); }
+
+    /**
+     * The path to the Animation track used for root motion. Paths must be valid scene-tree paths to a node, and must be specified starting from the parent node of the node that will reproduce the animation. The {@link rootMotionTrack} uses the same format as {@link Animation.trackSetPath}, but note that a bone must be specified.
+     * If the track has type {@link Animation.TYPE_POSITION_3D}, {@link Animation.TYPE_ROTATION_3D}, or {@link Animation.TYPE_SCALE_3D} the transformation will be canceled visually, and the animation will appear to stay in place. See also {@link getRootMotionPosition}, {@link getRootMotionRotation}, {@link getRootMotionScale}, and {@link RootMotionView}.
+     */
+    get rootMotionTrack(): NodePath { return _C(this, 6197) as NodePath; }
+    set rootMotionTrack(v: NodePath) { _C(this, 12569, v); }
+
+    /**
+     * If `true`, {@link getRootMotionPosition} value is extracted as a local translation value before blending. In other words, it is treated like the translation is done after the rotation.
+     */
+    get rootMotionLocal(): boolean { return _C(this, 8251) as boolean; }
+    set rootMotionLocal(v: boolean) { _C(this, 12568, v); }
+
+    /**
+     * The number of possible simultaneous sounds for each of the assigned AudioStreamPlayers.
+     * For example, if this value is `32` and the animation has two audio tracks, the two {@link AudioStreamPlayer}s assigned can play simultaneously up to `32` voices each.
+     */
+    get audioMaxPolyphony(): number { return _C(this, 3820) as number; }
+    set audioMaxPolyphony(v: number) { _C(this, 10558, v); }
+
+    /**
+     * The process notification in which to update animations.
+     */
+    get callbackModeProcess(): AnimationCallbackModeProcess { return _C(this, 4054) as AnimationCallbackModeProcess; }
+    set callbackModeProcess(v: AnimationCallbackModeProcess) { _C(this, 10782, v); }
+
+    /**
+     * The call mode used for "Call Method" tracks.
+     */
+    get callbackModeMethod(): AnimationCallbackModeMethod { return _C(this, 4053) as AnimationCallbackModeMethod; }
+    set callbackModeMethod(v: AnimationCallbackModeMethod) { _C(this, 10781, v); }
+
+    /**
+     * Ordinarily, tracks can be set to {@link Animation.UPDATE_DISCRETE} to update infrequently, usually when using nearest interpolation.
+     * However, when blending with {@link Animation.UPDATE_CONTINUOUS} several results are considered. The {@link callbackModeDiscrete} specify it explicitly. See also {@link AnimationCallbackModeDiscrete}.
+     * To make the blended results look good, it is recommended to set this to {@link ANIMATION_CALLBACK_MODE_DISCRETE_FORCE_CONTINUOUS} to update every frame during blending. Other values exist for compatibility and they are fine if there is no blending, but not so, may produce artifacts.
+     */
+    get callbackModeDiscrete(): AnimationCallbackModeDiscrete { return _C(this, 4052) as AnimationCallbackModeDiscrete; }
+    set callbackModeDiscrete(v: AnimationCallbackModeDiscrete) { _C(this, 10780, v); }
+
+    /**
+     * Notifies when an animation list is changed.
+     */
+    get animationListChanged(): Signal<() => void> { return _G(this, 1482) as Signal<() => void>; }
+    set animationListChanged(v: (() => void) | null) { _G(this, 1482, v); }
+
+    /**
+     * Notifies when the animation libraries have changed.
+     */
+    get animationLibrariesUpdated(): Signal<() => void> { return _G(this, 1481) as Signal<() => void>; }
+    set animationLibrariesUpdated(v: (() => void) | null) { _G(this, 1481, v); }
+
+    /**
+     * Notifies when an animation finished playing.
+     * **Note:** This signal is not emitted if an animation is looping.
+     */
+    get animationFinished(): Signal<(animName: StringName) => void> { return _G(this, 1479) as Signal<(animName: StringName) => void>; }
+    set animationFinished(v: ((animName: StringName) => void) | null) { _G(this, 1479, v); }
+
+    /**
+     * Notifies when an animation starts playing.
+     * **Note:** This signal is not emitted if an animation is looping.
+     */
+    get animationStarted(): Signal<(animName: StringName) => void> { return _G(this, 1491) as Signal<(animName: StringName) => void>; }
+    set animationStarted(v: ((animName: StringName) => void) | null) { _G(this, 1491, v); }
+
+    /**
+     * Notifies when the caches have been cleared, either automatically, or manually via {@link clearCaches}.
+     */
+    get cachesCleared(): Signal<() => void> { return _G(this, 1967) as Signal<() => void>; }
+    set cachesCleared(v: (() => void) | null) { _G(this, 1967, v); }
+
+    /**
+     * Notifies when the blending result related have been applied to the target objects.
+     */
+    get mixerApplied(): Signal<() => void> { return _G(this, 8939) as Signal<() => void>; }
+    set mixerApplied(v: (() => void) | null) { _G(this, 8939, v); }
+
+    /**
+     * Notifies when the property related process have been updated.
+     */
+    get mixerUpdated(): Signal<() => void> { return _G(this, 8940) as Signal<() => void>; }
+    set mixerUpdated(v: (() => void) | null) { _G(this, 8940, v); }
+
+    static readonly name = _R(55, AnimationMixer);
+}
+
+export const AnimationCallbackModeProcess = {
+    /**
+     * Process animation during physics frames (see {@link Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS}). This is especially useful when animating physics bodies.
+     */
+    ANIMATION_CALLBACK_MODE_PROCESS_PHYSICS: 0,
+    /**
+     * Process animation during process frames (see {@link Node.NOTIFICATION_INTERNAL_PROCESS}).
+     */
+    ANIMATION_CALLBACK_MODE_PROCESS_IDLE: 1,
+    /**
+     * Do not process animation. Use {@link advance} to process the animation manually.
+     */
+    ANIMATION_CALLBACK_MODE_PROCESS_MANUAL: 2,
+} as const;
+
+export type AnimationCallbackModeProcess = (typeof AnimationCallbackModeProcess)[keyof typeof AnimationCallbackModeProcess];
+
+export const AnimationCallbackModeMethod = {
+    /**
+     * Batch method calls during the animation process, then do the calls after events are processed. This avoids bugs involving deleting nodes or modifying the AnimationPlayer while playing.
+     */
+    ANIMATION_CALLBACK_MODE_METHOD_DEFERRED: 0,
+    /**
+     * Make method calls immediately when reached in the animation.
+     */
+    ANIMATION_CALLBACK_MODE_METHOD_IMMEDIATE: 1,
+} as const;
+
+export type AnimationCallbackModeMethod = (typeof AnimationCallbackModeMethod)[keyof typeof AnimationCallbackModeMethod];
+
+export const AnimationCallbackModeDiscrete = {
+    /**
+     * An {@link Animation.UPDATE_DISCRETE} track value takes precedence when blending {@link Animation.UPDATE_CONTINUOUS} or {@link Animation.UPDATE_CAPTURE} track values and {@link Animation.UPDATE_DISCRETE} track values.
+     */
+    ANIMATION_CALLBACK_MODE_DISCRETE_DOMINANT: 0,
+    /**
+     * An {@link Animation.UPDATE_CONTINUOUS} or {@link Animation.UPDATE_CAPTURE} track value takes precedence when blending the {@link Animation.UPDATE_CONTINUOUS} or {@link Animation.UPDATE_CAPTURE} track values and the {@link Animation.UPDATE_DISCRETE} track values. This is the default behavior for {@link AnimationPlayer}.
+     */
+    ANIMATION_CALLBACK_MODE_DISCRETE_RECESSIVE: 1,
+    /**
+     * Always treat the {@link Animation.UPDATE_DISCRETE} track value as {@link Animation.UPDATE_CONTINUOUS} with {@link Animation.INTERPOLATION_NEAREST}. This is the default behavior for {@link AnimationTree}.
+     * If a value track has un-interpolatable type key values, it is internally converted to use {@link ANIMATION_CALLBACK_MODE_DISCRETE_RECESSIVE} with {@link Animation.UPDATE_DISCRETE}.
+     * Un-interpolatable type list:
+     * - {@link TYPE_NIL}
+     * - {@link TYPE_NODE_PATH}
+     * - {@link TYPE_RID}
+     * - {@link TYPE_OBJECT}
+     * - {@link TYPE_CALLABLE}
+     * - {@link TYPE_SIGNAL}
+     * - {@link TYPE_DICTIONARY}
+     * - {@link TYPE_PACKED_BYTE_ARRAY}
+     * {@link TYPE_BOOL} and {@link TYPE_INT} are treated as {@link TYPE_FLOAT} during blending and rounded when the result is retrieved.
+     * It is same for arrays and vectors with them such as {@link TYPE_PACKED_INT32_ARRAY} or {@link TYPE_VECTOR2I}, they are treated as {@link TYPE_PACKED_FLOAT32_ARRAY} or {@link TYPE_VECTOR2}. Also note that for arrays, the size is also interpolated.
+     * {@link TYPE_STRING} and {@link TYPE_STRING_NAME} are interpolated between character codes and lengths, but note that there is a difference in algorithm between interpolation between keys and interpolation by blending.
+     */
+    ANIMATION_CALLBACK_MODE_DISCRETE_FORCE_CONTINUOUS: 2,
+} as const;
+
+export type AnimationCallbackModeDiscrete = (typeof AnimationCallbackModeDiscrete)[keyof typeof AnimationCallbackModeDiscrete];
+

package/gen/classes/AnimationNode.ts

@@ -0,0 +1,159 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { GodotArray, GodotDictionary, NodePath, Signal, StringName, Variant } from '../heap-types/index.ts';
+import type { LoopedFlag } from './Animation.ts';
+
+/**
+ * Base resource for {@link AnimationTree} nodes. In general, it's not used directly, but you can create custom ones with custom blending formulas.
+ * Inherit this when creating animation nodes mainly for use in {@link AnimationNodeBlendTree}, otherwise {@link AnimationRootNode} should be used instead.
+ * You can access the time information as read-only parameter which is processed and stored in the previous frame for all nodes except {@link AnimationNodeOutput}.
+ * **Note:** If multiple inputs exist in the {@link AnimationNode}, which time information takes precedence depends on the type of {@link AnimationNode}.
+ *
+ * ```text
+ *
+ * var current_length = $AnimationTree["parameters/AnimationNodeName/current_length"]
+ * var current_position = $AnimationTree["parameters/AnimationNodeName/current_position"]
+ * var current_delta = $AnimationTree["parameters/AnimationNodeName/current_delta"]
+ *
+ * ```
+ */
+export class AnimationNode extends Resource {
+    constructor(name = 56) { super(name); }
+
+    /**
+     * Adds an input to the animation node. This is only useful for animation nodes created for use in an {@link AnimationNodeBlendTree}. If the addition fails, returns `false`.
+     */
+    addInput(name: string): boolean { return _C(this, 1237, name) as boolean; }
+
+    /**
+     * Removes an input, call this only when inactive.
+     */
+    removeInput(index: number): void { _C(this, 9919, index); }
+
+    /**
+     * Sets the name of the input at the given `input` index. If the setting fails, returns `false`.
+     */
+    setInputName(input: number, name: string): boolean { return _C(this, 11716, input, name) as boolean; }
+
+    /**
+     * Gets the name of an input by index.
+     */
+    getInputName(input: number): string { return _C(this, 5116, input) as string; }
+
+    /**
+     * Amount of inputs in this animation node, only useful for animation nodes that go into {@link AnimationNodeBlendTree}.
+     */
+    getInputCount(): number { return _C(this, 5110) as number; }
+
+    /**
+     * Returns the input index which corresponds to `name`. If not found, returns `-1`.
+     */
+    findInput(name: string): number { return _C(this, 3287, name) as number; }
+
+    /**
+     * Adds or removes a path for the filter.
+     */
+    setFilterPath(path: NodePath, enable: boolean): void { _C(this, 11393, path, enable); }
+
+    /**
+     * Returns `true` if the given path is filtered.
+     */
+    isPathFiltered(path: NodePath): boolean { return _C(this, 8169, path) as boolean; }
+
+    /**
+     * Returns the object id of the {@link AnimationTree} that owns this node.
+     * **Note:** This method should only be called from within the {@link AnimationNodeExtension.ProcessAnimationNode} method, and will return an invalid id otherwise.
+     */
+    getProcessingAnimationTreeInstanceId(): number { return _C(this, 6032) as number; }
+
+    /**
+     * Returns `true` if this animation node is being processed in test-only mode.
+     */
+    isProcessTesting(): boolean { return _C(this, 8204) as boolean; }
+
+    /**
+     * Blends an animation by `blend` amount (name must be valid in the linked {@link AnimationPlayer}). A `time` and `delta` may be passed, as well as whether `seeked` happened.
+     * A `loopedFlag` is used by internal processing immediately after the loop.
+     */
+    blendAnimation(animation: StringName, time: number /* double */, delta: number /* double */, seeked: boolean, isExternalSeeking: boolean, blend: number, loopedFlag?: LoopedFlag /* = 0 */): void { _C(this, 1788, animation, time, delta, seeked, isExternalSeeking, blend, loopedFlag); }
+
+    /**
+     * Blend another animation node (in case this animation node contains child animation nodes). This function is only useful if you inherit from {@link AnimationRootNode} instead, otherwise editors will not display your animation node for addition.
+     */
+    blendNode(name: StringName, node: AnimationNode, time: number /* double */, seek: boolean, isExternalSeeking: boolean, blend: number, filter?: FilterAction /* = 0 */, sync?: boolean /* = true */, testOnly?: boolean /* = false */): number { return _C(this, 1793, name, node, time, seek, isExternalSeeking, blend, filter, sync, testOnly) as number; }
+
+    /**
+     * Blends an input. This is only useful for animation nodes created for an {@link AnimationNodeBlendTree}. The `time` parameter is a relative delta, unless `seek` is `true`, in which case it is absolute. A filter mode may be optionally passed.
+     */
+    blendInput(inputIndex: number, time: number /* double */, seek: boolean, isExternalSeeking: boolean, blend: number, filter?: FilterAction /* = 0 */, sync?: boolean /* = true */, testOnly?: boolean /* = false */): number { return _C(this, 1791, inputIndex, time, seek, isExternalSeeking, blend, filter, sync, testOnly) as number; }
+
+    /**
+     * Sets a custom parameter. These are used as local memory, because resources can be reused across the tree or scenes.
+     */
+    setParameter(name: StringName, value: Variant): void { _C(this, 12256, name, value); }
+
+    /**
+     * Gets the value of a parameter. Parameters are custom local memory used for your animation nodes, given a resource can be reused in multiple trees.
+     */
+    getParameter(name: StringName): Variant { return _C(this, 5817, name) as Variant; }
+
+    /**
+     * If `true`, filtering is enabled.
+     */
+    get filterEnabled(): boolean { return _C(this, 7948) as boolean; }
+    set filterEnabled(v: boolean) { _C(this, 11390, v); }
+
+    get filters(): GodotArray { return _C(this, 1001) as GodotArray; }
+    set filters(v: GodotArray) { _C(this, 1027, v); }
+
+    /**
+     * Emitted by nodes that inherit from this class and that have an internal tree when one of their animation nodes changes. The animation nodes that emit this signal are {@link AnimationNodeBlendSpace1D}, {@link AnimationNodeBlendSpace2D}, {@link AnimationNodeStateMachine}, {@link AnimationNodeBlendTree} and {@link AnimationNodeTransition}.
+     */
+    get treeChanged(): Signal<() => void> { return _G(this, 14409) as Signal<() => void>; }
+    set treeChanged(v: (() => void) | null) { _G(this, 14409, v); }
+
+    /**
+     * Emitted by {@link AnimationNodeAnimation} when its {@link AnimationNodeAnimation.animation} resource is changed, or by {@link AnimationNodeBlendTree} when its connections change.
+     */
+    get nodeUpdated(): Signal<(objectId: number) => void> { return _G(this, 9087) as Signal<(objectId: number) => void>; }
+    set nodeUpdated(v: ((objectId: number) => void) | null) { _G(this, 9087, v); }
+
+    /**
+     * Emitted by nodes that inherit from this class and that have an internal tree when one of their animation node names changes. The animation nodes that emit this signal are {@link AnimationNodeBlendSpace1D}, {@link AnimationNodeBlendSpace2D}, {@link AnimationNodeStateMachine}, and {@link AnimationNodeBlendTree}.
+     */
+    get animationNodeRenamed(): Signal<(objectId: number, oldName: string, newName: string) => void> { return _G(this, 1485) as Signal<(objectId: number, oldName: string, newName: string) => void>; }
+    set animationNodeRenamed(v: ((objectId: number, oldName: string, newName: string) => void) | null) { _G(this, 1485, v); }
+
+    /**
+     * Emitted by nodes that inherit from this class and that have an internal tree when one of their animation nodes removes. The animation nodes that emit this signal are {@link AnimationNodeBlendSpace1D}, {@link AnimationNodeBlendSpace2D}, {@link AnimationNodeStateMachine}, and {@link AnimationNodeBlendTree}.
+     */
+    get animationNodeRemoved(): Signal<(objectId: number, nodeName: string) => void> { return _G(this, 1484) as Signal<(objectId: number, nodeName: string) => void>; }
+    set animationNodeRemoved(v: ((objectId: number, nodeName: string) => void) | null) { _G(this, 1484, v); }
+
+    static readonly name = _R(56, AnimationNode);
+}
+
+export const FilterAction = {
+    /**
+     * Do not use filtering.
+     */
+    FILTER_IGNORE: 0,
+    /**
+     * Paths matching the filter will be allowed to pass.
+     */
+    FILTER_PASS: 1,
+    /**
+     * Paths matching the filter will be discarded.
+     */
+    FILTER_STOP: 2,
+    /**
+     * Paths matching the filter will be blended (by the blend value).
+     */
+    FILTER_BLEND: 3,
+} as const;
+
+export type FilterAction = (typeof FilterAction)[keyof typeof FilterAction];
+

package/gen/classes/AnimationNodeAdd2.ts

@@ -0,0 +1,16 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AnimationNodeSync } from './AnimationNodeSync.ts';
+
+/**
+ * A resource to add to an {@link AnimationNodeBlendTree}. Blends two animations additively based on the amount value.
+ * If the amount is greater than `1.0`, the animation connected to "in" port is blended with the amplified animation connected to "add" port.
+ * If the amount is less than `0.0`, the animation connected to "in" port is blended with the inverted animation connected to "add" port.
+ */
+export class AnimationNodeAdd2 extends AnimationNodeSync {
+    constructor(name = 57) { super(name); }
+
+    static readonly name = _R(57, AnimationNodeAdd2);
+}

package/gen/classes/AnimationNodeAdd3.ts

@@ -0,0 +1,20 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AnimationNodeSync } from './AnimationNodeSync.ts';
+
+/**
+ * A resource to add to an {@link AnimationNodeBlendTree}. Blends two animations out of three additively out of three based on the amount value.
+ * This animation node has three inputs:
+ * - The base animation to add to
+ * - A "-add" animation to blend with when the blend amount is negative
+ * - A "+add" animation to blend with when the blend amount is positive
+ * If the absolute value of the amount is greater than `1.0`, the animation connected to "in" port is blended with the amplified animation connected to "-add"/"+add" port.
+ * **Note:** The signs are only used to distinguish ports, and additive blending occurs based on absolute values always, meaning the animation of a "-add" port does not subtract from the animation of an "in" port.
+ */
+export class AnimationNodeAdd3 extends AnimationNodeSync {
+    constructor(name = 58) { super(name); }
+
+    static readonly name = _R(58, AnimationNodeAdd3);
+}