@ringozz/godot 0.1.0

package/gen/classes/AnimationNodeOneShot.ts

@@ -0,0 +1,144 @@
+// 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';
+import type { Curve } from './Curve.ts';
+
+/**
+ * A resource to add to an {@link AnimationNodeBlendTree}. This animation node will execute a sub-animation and return once it finishes. Blend times for fading in and out can be customized, as well as filters.
+ * After setting the request and changing the animation playback, the one-shot node automatically clears the request on the next process frame by setting its `request` value to {@link ONE_SHOT_REQUEST_NONE}.
+ *
+ *
+ * ```gdscript
+ *
+ * # Play child animation connected to "shot" port.
+ * animation_tree.set("parameters/OneShot/request", AnimationNodeOneShot.ONE_SHOT_REQUEST_FIRE)
+ * # Alternative syntax (same result as above).
+ * animation_tree["parameters/OneShot/request"] = AnimationNodeOneShot.ONE_SHOT_REQUEST_FIRE
+ *
+ * # Abort child animation connected to "shot" port.
+ * animation_tree.set("parameters/OneShot/request", AnimationNodeOneShot.ONE_SHOT_REQUEST_ABORT)
+ * # Alternative syntax (same result as above).
+ * animation_tree["parameters/OneShot/request"] = AnimationNodeOneShot.ONE_SHOT_REQUEST_ABORT
+ *
+ * # Abort child animation with fading out connected to "shot" port.
+ * animation_tree.set("parameters/OneShot/request", AnimationNodeOneShot.ONE_SHOT_REQUEST_FADE_OUT)
+ * # Alternative syntax (same result as above).
+ * animation_tree["parameters/OneShot/request"] = AnimationNodeOneShot.ONE_SHOT_REQUEST_FADE_OUT
+ *
+ * # Get current state (read-only).
+ * animation_tree.get("parameters/OneShot/active")
+ * # Alternative syntax (same result as above).
+ * animation_tree["parameters/OneShot/active"]
+ *
+ * # Get current internal state (read-only).
+ * animation_tree.get("parameters/OneShot/internal_active")
+ * # Alternative syntax (same result as above).
+ * animation_tree["parameters/OneShot/internal_active"]
+ *
+ * ```
+ */
+export class AnimationNodeOneShot extends AnimationNodeSync {
+    constructor(name = 66) { super(name); }
+
+    /**
+     * The blend type.
+     */
+    get mixMode(): MixMode { return _C(this, 5564) as MixMode; }
+    set mixMode(v: MixMode) { _C(this, 12069, v); }
+
+    /**
+     * The fade-in duration. For example, setting this to `1.0` for a 5 second length animation will produce a cross-fade that starts at 0 second and ends at 1 second during the animation.
+     * **Note:** {@link AnimationNodeOneShot} transitions the current state after the fading has finished.
+     */
+    get fadeinTime(): number { return _C(this, 4740) as number; }
+    set fadeinTime(v: number) { _C(this, 11356, v); }
+
+    /**
+     * Determines how cross-fading between animations is eased. If empty, the transition will be linear. Should be a unit {@link Curve}.
+     */
+    get fadeinCurve(): Curve { return _C(this, 4739) as Curve; }
+    set fadeinCurve(v: Curve) { _C(this, 11355, v); }
+
+    /**
+     * The fade-out duration. For example, setting this to `1.0` for a 5 second length animation will produce a cross-fade that starts at 4 second and ends at 5 second during the animation.
+     * **Note:** {@link AnimationNodeOneShot} transitions the current state after the fading has finished.
+     */
+    get fadeoutTime(): number { return _C(this, 4742) as number; }
+    set fadeoutTime(v: number) { _C(this, 11358, v); }
+
+    /**
+     * Determines how cross-fading between animations is eased. If empty, the transition will be linear. Should be a unit {@link Curve}.
+     */
+    get fadeoutCurve(): Curve { return _C(this, 4741) as Curve; }
+    set fadeoutCurve(v: Curve) { _C(this, 11357, v); }
+
+    /**
+     * If `true`, breaks the loop at the end of the loop cycle for transition, even if the animation is looping.
+     */
+    get breakLoopAtEnd(): boolean { return _C(this, 8093) as boolean; }
+    set breakLoopAtEnd(v: boolean) { _C(this, 10738, v); }
+
+    /**
+     * If `true`, the sub-animation will abort if resumed with a reset after a prior interruption.
+     */
+    get abortOnReset(): boolean { return _C(this, 7727) as boolean; }
+    set abortOnReset(v: boolean) { _C(this, 10397, v); }
+
+    /**
+     * If `true`, the sub-animation will restart automatically after finishing.
+     * In other words, to start auto restarting, the animation must be played once with the {@link ONE_SHOT_REQUEST_FIRE} request. The {@link ONE_SHOT_REQUEST_ABORT} request stops the auto restarting, but it does not disable the {@link autorestart} itself. So, the {@link ONE_SHOT_REQUEST_FIRE} request will start auto restarting again.
+     */
+    get autorestart(): boolean { return _C(this, 7365) as boolean; }
+    set autorestart(v: boolean) { _C(this, 10587, v); }
+
+    /**
+     * The delay after which the automatic restart is triggered, in seconds.
+     */
+    get autorestartDelay(): number { return _C(this, 3843) as number; }
+    set autorestartDelay(v: number) { _C(this, 10588, v); }
+
+    /**
+     * If {@link autorestart} is `true`, a random additional delay (in seconds) between 0 and this value will be added to {@link autorestartDelay}.
+     */
+    get autorestartRandomDelay(): number { return _C(this, 3844) as number; }
+    set autorestartRandomDelay(v: number) { _C(this, 10589, v); }
+
+    static readonly name = _R(66, AnimationNodeOneShot);
+}
+
+export const OneShotRequest = {
+    /**
+     * The default state of the request. Nothing is done.
+     */
+    ONE_SHOT_REQUEST_NONE: 0,
+    /**
+     * The request to play the animation connected to "shot" port.
+     */
+    ONE_SHOT_REQUEST_FIRE: 1,
+    /**
+     * The request to stop the animation connected to "shot" port.
+     */
+    ONE_SHOT_REQUEST_ABORT: 2,
+    /**
+     * The request to fade out the animation connected to "shot" port.
+     */
+    ONE_SHOT_REQUEST_FADE_OUT: 3,
+} as const;
+
+export type OneShotRequest = (typeof OneShotRequest)[keyof typeof OneShotRequest];
+
+export const MixMode = {
+    /**
+     * Blends two animations. See also {@link AnimationNodeBlend2}.
+     */
+    MIX_MODE_BLEND: 0,
+    /**
+     * Blends two animations additively. See also {@link AnimationNodeAdd2}.
+     */
+    MIX_MODE_ADD: 1,
+} as const;
+
+export type MixMode = (typeof MixMode)[keyof typeof MixMode];
+

package/gen/classes/AnimationNodeOutput.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AnimationNode } from './AnimationNode.ts';
+
+/**
+ * A node created automatically in an {@link AnimationNodeBlendTree} that outputs the final animation.
+ */
+export class AnimationNodeOutput extends AnimationNode {
+    constructor(name = 67) { super(name); }
+
+    static readonly name = _R(67, AnimationNodeOutput);
+}

package/gen/classes/AnimationNodeStateMachine.ts

@@ -0,0 +1,163 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AnimationRootNode } from './AnimationRootNode.ts';
+import type { GodotArray, StringName } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+import type { AnimationNode } from './AnimationNode.ts';
+import type { AnimationNodeStateMachineTransition } from './AnimationNodeStateMachineTransition.ts';
+
+/**
+ * Contains multiple {@link AnimationRootNode}s representing animation states, connected in a graph. State transitions can be configured to happen automatically or via code, using a shortest-path algorithm. Retrieve the {@link AnimationNodeStateMachinePlayback} object from the {@link AnimationTree} node to control it programmatically.
+ *
+ *
+ * ```gdscript
+ *
+ * var state_machine = $AnimationTree.get("parameters/playback")
+ * state_machine.travel("some_state")
+ *
+ * ```
+ */
+export class AnimationNodeStateMachine extends AnimationRootNode {
+    constructor(name = 68) { super(name); }
+
+    /**
+     * Adds a new animation node to the graph. The `position` is used for display in the editor.
+     */
+    addNode(name: StringName, node: AnimationNode, position?: Vector2 /* = Vector2(0, 0) */): void { _C(this, 1257, name, node, position); }
+
+    /**
+     * Replaces the given animation node with a new animation node.
+     */
+    replaceNode(name: StringName, node: AnimationNode): void { _C(this, 10045, name, node); }
+
+    /**
+     * Returns the animation node with the given name.
+     */
+    getNode(name: StringName): AnimationNode { return _C(this, 5638, name) as AnimationNode; }
+
+    /**
+     * Deletes the given animation node from the graph.
+     */
+    removeNode(name: StringName): void { _C(this, 9937, name); }
+
+    /**
+     * Renames the given animation node.
+     */
+    renameNode(name: StringName, newName: StringName): void { _C(this, 10000, name, newName); }
+
+    /**
+     * Returns `true` if the graph contains the given animation node.
+     */
+    hasNode(name: StringName): boolean { return _C(this, 7420, name) as boolean; }
+
+    /**
+     * Returns the given animation node's name.
+     */
+    getNodeName(node: AnimationNode): StringName { return _C(this, 5651, node) as StringName; }
+
+    /**
+     * Returns a list containing the names of all animation nodes in this state machine.
+     */
+    getNodeList(): GodotArray<StringName> { return _C(this, 5650) as GodotArray<StringName>; }
+
+    /**
+     * Sets the animation node's coordinates. Used for display in the editor.
+     */
+    setNodePosition(name: StringName, position: Vector2): void { _C(this, 12139, name, position); }
+
+    /**
+     * Returns the given animation node's coordinates. Used for display in the editor.
+     */
+    getNodePosition(name: StringName): Vector2 { return _C(this, 5657, name) as Vector2; }
+
+    /**
+     * Returns `true` if there is a transition between the given animation nodes.
+     */
+    hasTransition(from: StringName, to: StringName): boolean { return _C(this, 7474, from, to) as boolean; }
+
+    /**
+     * Adds a transition between the given animation nodes.
+     */
+    addTransition(from: StringName, to: StringName, transition: AnimationNodeStateMachineTransition): void { _C(this, 1318, from, to, transition); }
+
+    /**
+     * Returns the given transition.
+     */
+    getTransition(idx: number): AnimationNodeStateMachineTransition { return _C(this, 6880, idx) as AnimationNodeStateMachineTransition; }
+
+    /**
+     * Returns the given transition's start node.
+     */
+    getTransitionFrom(idx: number): StringName { return _C(this, 6885, idx) as StringName; }
+
+    /**
+     * Returns the given transition's end node.
+     */
+    getTransitionTo(idx: number): StringName { return _C(this, 6888, idx) as StringName; }
+
+    /**
+     * Returns the number of connections in the graph.
+     */
+    getTransitionCount(): number { return _C(this, 6881) as number; }
+
+    /**
+     * Deletes the given transition by index.
+     */
+    removeTransitionByIndex(idx: number): void { _C(this, 9981, idx); }
+
+    /**
+     * Deletes the transition between the two specified animation nodes.
+     */
+    removeTransition(from: StringName, to: StringName): void { _C(this, 9980, from, to); }
+
+    /**
+     * Sets the draw offset of the graph. Used for display in the editor.
+     */
+    setGraphOffset(offset: Vector2): void { _C(this, 11552, offset); }
+
+    /**
+     * Returns the draw offset of the graph. Used for display in the editor.
+     */
+    getGraphOffset(): Vector2 { return _C(this, 4970) as Vector2; }
+
+    /**
+     * This property can define the process of transitions for different use cases. See also {@link AnimationNodeStateMachine.StateMachineType}.
+     */
+    get stateMachineType(): StateMachineType { return _C(this, 6538) as StateMachineType; }
+    set stateMachineType(v: StateMachineType) { _C(this, 12883, v); }
+
+    /**
+     * If `true`, allows teleport to the self state with {@link AnimationNodeStateMachinePlayback.travel}. When the reset option is enabled in {@link AnimationNodeStateMachinePlayback.travel}, the animation is restarted. If `false`, nothing happens on the teleportation to the self state.
+     */
+    get allowTransitionToSelf(): boolean { return _C(this, 7754) as boolean; }
+    set allowTransitionToSelf(v: boolean) { _C(this, 10461, v); }
+
+    /**
+     * If `true`, treat the cross-fade to the start and end nodes as a blend with the RESET animation.
+     * In most cases, when additional cross-fades are performed in the parent {@link AnimationNode} of the state machine, setting this property to `false` and matching the cross-fade time of the parent {@link AnimationNode} and the state machine's start node and end node gives good results.
+     */
+    get resetEnds(): boolean { return _C(this, 1543) as boolean; }
+    set resetEnds(v: boolean) { _C(this, 12537, v); }
+
+    static readonly name = _R(68, AnimationNodeStateMachine);
+}
+
+export const StateMachineType = {
+    /**
+     * Seeking to the beginning is treated as playing from the start state. Transition to the end state is treated as exiting the state machine.
+     */
+    STATE_MACHINE_TYPE_ROOT: 0,
+    /**
+     * Seeking to the beginning is treated as seeking to the beginning of the animation in the current state. Transition to the end state, or the absence of transitions in each state, is treated as exiting the state machine.
+     */
+    STATE_MACHINE_TYPE_NESTED: 1,
+    /**
+     * This is a grouped state machine that can be controlled from a parent state machine. It does not work independently. There must be a state machine with {@link stateMachineType} of {@link STATE_MACHINE_TYPE_ROOT} or {@link STATE_MACHINE_TYPE_NESTED} in the parent or ancestor.
+     */
+    STATE_MACHINE_TYPE_GROUPED: 2,
+} as const;
+
+export type StateMachineType = (typeof StateMachineType)[keyof typeof StateMachineType];
+

package/gen/classes/AnimationNodeStateMachinePlayback.ts

@@ -0,0 +1,111 @@
+// 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, Signal, StringName } from '../heap-types/index.ts';
+
+/**
+ * Allows control of {@link AnimationTree} state machines created with {@link AnimationNodeStateMachine}. Retrieve with `$AnimationTree.get("parameters/playback")`.
+ *
+ *
+ * ```gdscript
+ *
+ * var state_machine = $AnimationTree.get("parameters/playback")
+ * state_machine.travel("some_state")
+ *
+ * ```
+ */
+export class AnimationNodeStateMachinePlayback extends Resource {
+    constructor(name = 69) { super(name); }
+
+    /**
+     * Transitions from the current state to another one, following the shortest path.
+     * If the path does not connect from the current state, the animation will play after the state teleports.
+     * If `resetOnTeleport` is `true`, the animation is played from the beginning when the travel cause a teleportation.
+     */
+    travel(toNode: StringName, resetOnTeleport?: boolean /* = true */): void { _C(this, 14406, toNode, resetOnTeleport); }
+
+    /**
+     * Starts playing the given animation.
+     * If `reset` is `true`, the animation is played from the beginning.
+     */
+    start(node: StringName, reset?: boolean /* = true */): void { _C(this, 13829, node, reset); }
+
+    /**
+     * If there is a next path by travel or auto advance, immediately transitions from the current state to the next state.
+     */
+    next(): void { _C(this, 9070); }
+
+    /**
+     * Stops the currently playing animation.
+     */
+    stop(): void { _C(this, 13866); }
+
+    /**
+     * Returns `true` if an animation is playing.
+     */
+    isPlaying(): boolean { return _C(this, 8183) as boolean; }
+
+    /**
+     * Returns the currently playing animation state.
+     * **Note:** When using a cross-fade, the current state changes to the next state immediately after the cross-fade begins.
+     */
+    getCurrentNode(): StringName { return _C(this, 4359) as StringName; }
+
+    /**
+     * Returns the playback position within the current animation state.
+     */
+    getCurrentPlayPosition(): number { return _C(this, 4362) as number; }
+
+    /**
+     * Returns the current state length.
+     * **Note:** It is possible that any {@link AnimationRootNode} can be nodes as well as animations. This means that there can be multiple animations within a single state. Which animation length has priority depends on the nodes connected inside it. Also, if a transition does not reset, the remaining length at that point will be returned.
+     */
+    getCurrentLength(): number { return _C(this, 4354) as number; }
+
+    /**
+     * Returns the starting state of currently fading animation.
+     */
+    getFadingFromNode(): StringName { return _C(this, 4744) as StringName; }
+
+    /**
+     * Returns the playback position of the node from {@link getFadingFromNode}. Returns `0` if no animation fade is occurring.
+     */
+    getFadingFromPlayPosition(): number { return _C(this, 4745) as number; }
+
+    /**
+     * Returns the playback state length of the node from {@link getFadingFromNode}. Returns `0` if no animation fade is occurring.
+     */
+    getFadingFromLength(): number { return _C(this, 4743) as number; }
+
+    /**
+     * Returns the playback position of the current fade animation. Returns `0` if no animation fade is occurring.
+     */
+    getFadingPosition(): number { return _C(this, 4747) as number; }
+
+    /**
+     * Returns the length of the current fade animation. Returns `0` if no animation fade is occurring.
+     */
+    getFadingLength(): number { return _C(this, 4746) as number; }
+
+    /**
+     * Returns the current travel path as computed internally by the A* algorithm.
+     */
+    getTravelPath(): GodotArray<StringName> { return _C(this, 6903) as GodotArray<StringName>; }
+
+    /**
+     * Emitted when the `state` starts playback. If `state` is a state machine set to grouped mode, its signals are passed through with its name prefixed.
+     */
+    get stateStarted(): Signal<(state: StringName) => void> { return _G(this, 13848) as Signal<(state: StringName) => void>; }
+    set stateStarted(v: ((state: StringName) => void) | null) { _G(this, 13848, v); }
+
+    /**
+     * Emitted when the `state` finishes playback. If `state` is a state machine set to grouped mode, its signals are passed through with its name prefixed.
+     * If there is a crossfade, this will be fired when the influence of the {@link getFadingFromNode} animation is no longer present.
+     */
+    get stateFinished(): Signal<(state: StringName) => void> { return _G(this, 13846) as Signal<(state: StringName) => void>; }
+    set stateFinished(v: ((state: StringName) => void) | null) { _G(this, 13846, v); }
+
+    static readonly name = _R(69, AnimationNodeStateMachinePlayback);
+}

package/gen/classes/AnimationNodeStateMachineTransition.ts

@@ -0,0 +1,120 @@
+// 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 { Signal, StringName } from '../heap-types/index.ts';
+import type { Curve } from './Curve.ts';
+
+/**
+ * The path generated when using {@link AnimationNodeStateMachinePlayback.travel} is limited to the nodes connected by {@link AnimationNodeStateMachineTransition}.
+ * You can set the timing and conditions of the transition in detail.
+ */
+export class AnimationNodeStateMachineTransition extends Resource {
+    constructor(name = 70) { super(name); }
+
+    /**
+     * The time to cross-fade between this state and the next.
+     * **Note:** {@link AnimationNodeStateMachine} transitions the current state immediately after the start of the fading. The precise remaining time can only be inferred from the main animation. When {@link AnimationNodeOutput} is considered as the most upstream, so the {@link xfadeTime} is not scaled depending on the downstream delta. See also {@link AnimationNodeOneShot.fadeoutTime}.
+     */
+    get xfadeTime(): number { return _C(this, 7174) as number; }
+    set xfadeTime(v: number) { _C(this, 13396, v); }
+
+    /**
+     * Ease curve for better control over cross-fade between this state and the next. Should be a unit {@link Curve}.
+     */
+    get xfadeCurve(): Curve { return _C(this, 7173) as Curve; }
+    set xfadeCurve(v: Curve) { _C(this, 13395, v); }
+
+    /**
+     * If `true`, breaks the loop at the end of the loop cycle for transition, even if the animation is looping.
+     */
+    get breakLoopAtEnd(): boolean { return _C(this, 8093) as boolean; }
+    set breakLoopAtEnd(v: boolean) { _C(this, 10738, v); }
+
+    /**
+     * If `true`, the destination animation is played back from the beginning when switched.
+     */
+    get reset(): boolean { return _C(this, 8242) as boolean; }
+    set reset(v: boolean) { _C(this, 12536, v); }
+
+    /**
+     * Lower priority transitions are preferred when travelling through the tree via {@link AnimationNodeStateMachinePlayback.travel} or {@link advanceMode} is set to {@link ADVANCE_MODE_AUTO}.
+     */
+    get priority(): number { return _C(this, 6015) as number; }
+    set priority(v: number) { _C(this, 12419, v); }
+
+    /**
+     * The transition type.
+     */
+    get switchMode(): SwitchMode { return _C(this, 6644) as SwitchMode; }
+    set switchMode(v: SwitchMode) { _C(this, 12947, v); }
+
+    /**
+     * Determines whether the transition should be disabled, enabled when using {@link AnimationNodeStateMachinePlayback.travel}, or traversed automatically if the {@link advanceCondition} and {@link advanceExpression} checks are `true` (if assigned).
+     */
+    get advanceMode(): AdvanceMode { return _C(this, 3704) as AdvanceMode; }
+    set advanceMode(v: AdvanceMode) { _C(this, 10439, v); }
+
+    /**
+     * Turn on auto advance when this condition is set. The provided name will become a boolean parameter on the {@link AnimationTree} that can be controlled from code (see [Using AnimationTree]($DOCS_URL/tutorials/animation/animation_tree.html#controlling-from-code)). For example, if {@link AnimationTree.treeRoot} is an {@link AnimationNodeStateMachine} and {@link advanceCondition} is set to `"idle"`:
+     *
+     *
+     * ```gdscript
+     *
+     * $animation_tree.set("parameters/conditions/idle", is_on_floor and (linear_velocity.x == 0))
+     *
+     * ```
+     */
+    get advanceCondition(): StringName { return _C(this, 3701) as StringName; }
+    set advanceCondition(v: StringName) { _C(this, 10436, v); }
+
+    /**
+     * Use an expression as a condition for state machine transitions. It is possible to create complex animation advance conditions for switching between states and gives much greater flexibility for creating complex state machines by directly interfacing with the script code.
+     */
+    get advanceExpression(): string { return _C(this, 3702) as string; }
+    set advanceExpression(v: string) { _C(this, 10437, v); }
+
+    /**
+     * Emitted when {@link advanceCondition} is changed.
+     */
+    get advanceConditionChanged(): Signal<() => void> { return _G(this, 1348) as Signal<() => void>; }
+    set advanceConditionChanged(v: (() => void) | null) { _G(this, 1348, v); }
+
+    static readonly name = _R(70, AnimationNodeStateMachineTransition);
+}
+
+export const SwitchMode = {
+    /**
+     * Switch to the next state immediately. The current state will end and blend into the beginning of the new one.
+     */
+    SWITCH_MODE_IMMEDIATE: 0,
+    /**
+     * Switch to the next state immediately, but will seek the new state to the playback position of the old state.
+     */
+    SWITCH_MODE_SYNC: 1,
+    /**
+     * Wait for the current state playback to end, then switch to the beginning of the next state animation.
+     */
+    SWITCH_MODE_AT_END: 2,
+} as const;
+
+export type SwitchMode = (typeof SwitchMode)[keyof typeof SwitchMode];
+
+export const AdvanceMode = {
+    /**
+     * Don't use this transition.
+     */
+    ADVANCE_MODE_DISABLED: 0,
+    /**
+     * Only use this transition during {@link AnimationNodeStateMachinePlayback.travel}.
+     */
+    ADVANCE_MODE_ENABLED: 1,
+    /**
+     * Automatically use this transition if the {@link advanceCondition} and {@link advanceExpression} checks are `true` (if assigned).
+     */
+    ADVANCE_MODE_AUTO: 2,
+} as const;
+
+export type AdvanceMode = (typeof AdvanceMode)[keyof typeof AdvanceMode];
+

package/gen/classes/AnimationNodeSub2.ts

@@ -0,0 +1,17 @@
+// 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 subtractively based on the amount value.
+ * This animation node is usually used for pre-calculation to cancel out any extra poses from the animation for the "add" animation source in {@link AnimationNodeAdd2} or {@link AnimationNodeAdd3}.
+ * In general, the blend value should be in the `[0.0, 1.0]` range, but values outside of this range can be used for amplified or inverted animations.
+ * **Note:** This calculation is different from using a negative value in {@link AnimationNodeAdd2}, since the transformation matrices do not satisfy the commutative law. {@link AnimationNodeSub2} multiplies the transformation matrix of the inverted animation from the left side, while negative {@link AnimationNodeAdd2} multiplies it from the right side.
+ */
+export class AnimationNodeSub2 extends AnimationNodeSync {
+    constructor(name = 71) { super(name); }
+
+    static readonly name = _R(71, AnimationNodeSub2);
+}

package/gen/classes/AnimationNodeSync.ts

@@ -0,0 +1,21 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AnimationNode } from './AnimationNode.ts';
+
+/**
+ * An animation node used to combine, mix, or blend two or more animations together while keeping them synchronized within an {@link AnimationTree}.
+ */
+export class AnimationNodeSync extends AnimationNode {
+    constructor(name = 72) { super(name); }
+
+    /**
+     * If `false`, the blended animations' frame are stopped when the blend value is `0`.
+     * If `true`, forcing the blended animations to advance frame.
+     */
+    get sync(): boolean { return _C(this, 8422) as boolean; }
+    set sync(v: boolean) { _C(this, 13239, v); }
+
+    static readonly name = _R(72, AnimationNodeSync);
+}

package/gen/classes/AnimationNodeTimeScale.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AnimationNode } from './AnimationNode.ts';
+
+/**
+ * Allows to scale the speed of the animation (or reverse it) in any child {@link AnimationNode}s. Setting it to `0.0` will pause the animation.
+ */
+export class AnimationNodeTimeScale extends AnimationNode {
+    constructor(name = 73) { super(name); }
+
+    static readonly name = _R(73, AnimationNodeTimeScale);
+}

package/gen/classes/AnimationNodeTimeSeek.ts

@@ -0,0 +1,36 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AnimationNode } from './AnimationNode.ts';
+
+/**
+ * This animation node can be used to cause a seek command to happen to any sub-children of the animation graph. Use to play an {@link Animation} from the start or a certain playback position inside the {@link AnimationNodeBlendTree}.
+ * After setting the time and changing the animation playback, the time seek node automatically goes into sleep mode on the next process frame by setting its `seek_request` value to `-1.0`.
+ *
+ *
+ * ```gdscript
+ *
+ * # Play child animation from the start.
+ * animation_tree.set("parameters/TimeSeek/seek_request", 0.0)
+ * # Alternative syntax (same result as above).
+ * animation_tree["parameters/TimeSeek/seek_request"] = 0.0
+ *
+ * # Play child animation from 12 second timestamp.
+ * animation_tree.set("parameters/TimeSeek/seek_request", 12.0)
+ * # Alternative syntax (same result as above).
+ * animation_tree["parameters/TimeSeek/seek_request"] = 12.0
+ *
+ * ```
+ */
+export class AnimationNodeTimeSeek extends AnimationNode {
+    constructor(name = 74) { super(name); }
+
+    /**
+     * If `true`, some processes are executed to handle keys between seeks, such as calculating root motion and finding the nearest discrete key.
+     */
+    get explicitElapse(): boolean { return _C(this, 7944) as boolean; }
+    set explicitElapse(v: boolean) { _C(this, 11327, v); }
+
+    static readonly name = _R(74, AnimationNodeTimeSeek);
+}