@ringozz/godot 0.1.0

package/gen/classes/AimModifier3D.ts

@@ -0,0 +1,75 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { BoneConstraint3D } from './BoneConstraint3D.ts';
+import type { BoneAxis } from './SkeletonModifier3D.ts';
+
+/**
+ * This is a simple version of {@link LookAtModifier3D} that only allows bone to the reference without advanced options such as angle limitation or time-based interpolation.
+ * The feature is simplified, but instead it is implemented with smooth tracking without euler, see {@link setUseEuler}.
+ */
+export class AimModifier3D extends BoneConstraint3D {
+    constructor(name = 47) { super(name); }
+
+    /**
+     * Sets the forward axis of the bone.
+     */
+    setForwardAxis(index: number, axis: BoneAxis): void { _C(this, 11467, index, axis); }
+
+    /**
+     * Returns the forward axis of the bone.
+     */
+    getForwardAxis(index: number): BoneAxis { return _C(this, 4864, index) as BoneAxis; }
+
+    /**
+     * If sets `enabled` to `true`, it provides rotation with using euler.
+     * If sets `enabled` to `false`, it provides rotation with using rotation by arc generated from the forward axis vector and the vector toward the reference.
+     */
+    setUseEuler(index: number, enabled: boolean): void { _C(this, 13212, index, enabled); }
+
+    /**
+     * Returns `true` if it provides rotation with using euler.
+     */
+    isUsingEuler(index: number): boolean { return _C(this, 8403, index) as boolean; }
+
+    /**
+     * Sets the axis of the first rotation. It is enabled only if {@link isUsingEuler} is `true`.
+     */
+    setPrimaryRotationAxis(index: number, axis: number): void { _C(this, 12416, index, axis); }
+
+    /**
+     * Returns the axis of the first rotation. It is enabled only if {@link isUsingEuler} is `true`.
+     */
+    getPrimaryRotationAxis(index: number): number { return _C(this, 6011, index) as number; }
+
+    /**
+     * If sets `enabled` to `true`, it provides rotation by two axes. It is enabled only if {@link isUsingEuler} is `true`.
+     */
+    setUseSecondaryRotation(index: number, enabled: boolean): void { _C(this, 13238, index, enabled); }
+
+    /**
+     * Returns `true` if it provides rotation by two axes. It is enabled only if {@link isUsingEuler} is `true`.
+     */
+    isUsingSecondaryRotation(index: number): boolean { return _C(this, 8420, index) as boolean; }
+
+    /**
+     * Sets relative option in the setting at `index` to `enabled`.
+     * If sets `enabled` to `true`, the rotation is applied relative to the pose.
+     * If sets `enabled` to `false`, the rotation is applied relative to the rest. It means to replace the current pose with the {@link AimModifier3D}'s result.
+     */
+    setRelative(index: number, enabled: boolean): void { _C(this, 12511, index, enabled); }
+
+    /**
+     * Returns `true` if the relative option is enabled in the setting at `index`.
+     */
+    isRelative(index: number): boolean { return _C(this, 8237, index) as boolean; }
+
+    /**
+     * The number of settings in the modifier.
+     */
+    get settingCount(): number { return _C(this, 6350) as number; }
+    set settingCount(v: number) { _C(this, 12700, v); }
+
+    static readonly name = _R(47, AimModifier3D);
+}

package/gen/classes/AnimatableBody2D.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 { StaticBody2D } from './StaticBody2D.ts';
+
+/**
+ * An animatable 2D physics body. It can't be moved by external forces or contacts, but can be moved manually by other means such as code, {@link AnimationMixer}s (with {@link AnimationMixer.callbackModeProcess} set to {@link AnimationMixer.ANIMATION_CALLBACK_MODE_PROCESS_PHYSICS}), and {@link RemoteTransform2D}.
+ * When {@link AnimatableBody2D} is moved, its linear and angular velocity are estimated and used to affect other physics bodies in its path. This makes it useful for moving platforms, doors, and other moving objects.
+ */
+export class AnimatableBody2D extends StaticBody2D {
+    constructor(name = 48) { super(name); }
+
+    /**
+     * If `true`, the body's movement will be synchronized to the physics frame. This is useful when animating movement via {@link AnimationPlayer}, for example on moving platforms. Do **not** use together with {@link PhysicsBody2D.moveAndCollide}.
+     */
+    get syncToPhysics(): boolean { return _C(this, 8353) as boolean; }
+    set syncToPhysics(v: boolean) { _C(this, 12963, v); }
+
+    static readonly name = _R(48, AnimatableBody2D);
+}

package/gen/classes/AnimatableBody3D.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 { StaticBody3D } from './StaticBody3D.ts';
+
+/**
+ * An animatable 3D physics body. It can't be moved by external forces or contacts, but can be moved manually by other means such as code, {@link AnimationMixer}s (with {@link AnimationMixer.callbackModeProcess} set to {@link AnimationMixer.ANIMATION_CALLBACK_MODE_PROCESS_PHYSICS}), and {@link RemoteTransform3D}.
+ * When {@link AnimatableBody3D} is moved, its linear and angular velocity are estimated and used to affect other physics bodies in its path. This makes it useful for moving platforms, doors, and other moving objects.
+ */
+export class AnimatableBody3D extends StaticBody3D {
+    constructor(name = 49) { super(name); }
+
+    /**
+     * If `true`, the body's movement will be synchronized to the physics frame. This is useful when animating movement via {@link AnimationPlayer}, for example on moving platforms. Do **not** use together with {@link PhysicsBody3D.moveAndCollide}.
+     */
+    get syncToPhysics(): boolean { return _C(this, 8353) as boolean; }
+    set syncToPhysics(v: boolean) { _C(this, 12963, v); }
+
+    static readonly name = _R(49, AnimatableBody3D);
+}

package/gen/classes/AnimatedSprite2D.ts

@@ -0,0 +1,160 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { Signal, StringName } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+import type { SpriteFrames } from './SpriteFrames.ts';
+
+/**
+ * {@link AnimatedSprite2D} is similar to the {@link Sprite2D} node, except it carries multiple textures as animation frames. Animations are created using a {@link SpriteFrames} resource, which allows you to import image files (or a folder containing said files) to provide the animation frames for the sprite. The {@link SpriteFrames} resource can be configured in the editor via the SpriteFrames bottom panel.
+ */
+export class AnimatedSprite2D extends Node2D {
+    constructor(name = 50) { super(name); }
+
+    /**
+     * Returns `true` if an animation is currently playing (even if {@link speedScale} and/or `custom_speed` are `0`).
+     */
+    isPlaying(): boolean { return _C(this, 8183) as boolean; }
+
+    /**
+     * Plays the animation with key `name`. If `customSpeed` is negative and `fromEnd` is `true`, the animation will play backwards (which is equivalent to calling {@link playBackwards}).
+     * If this method is called with that same animation `name`, or with no `name` parameter, the assigned animation will resume playing if it was paused.
+     */
+    play(name?: StringName /* = &"" */, customSpeed?: number /* = 1.0 */, fromEnd?: boolean /* = false */): void { _C(this, 9447, name, customSpeed, fromEnd); }
+
+    /**
+     * Plays the animation with key `name` in reverse.
+     * This method is a shorthand for {@link play} with `custom_speed = -1.0` and `from_end = true`, so see its description for more information.
+     */
+    playBackwards(name?: StringName /* = &"" */): void { _C(this, 9449, name); }
+
+    /**
+     * Pauses the currently playing animation. The {@link frame} and {@link frameProgress} will be kept and calling {@link play} or {@link playBackwards} without arguments will resume the animation from the current playback position.
+     * See also {@link stop}.
+     */
+    pause(): void { _C(this, 9383); }
+
+    /**
+     * Stops the currently playing animation. The animation position is reset to `0` and the `custom_speed` is reset to `1.0`. See also {@link pause}.
+     */
+    stop(): void { _C(this, 13866); }
+
+    /**
+     * Sets {@link frame} and {@link frameProgress} to the given values. Unlike setting {@link frame}, this method does not reset the {@link frameProgress} to `0.0` implicitly.
+     * **Example:** Change the animation while keeping the same {@link frame} and {@link frameProgress}:
+     *
+     *
+     * ```gdscript
+     *
+     * var current_frame = animated_sprite.get_frame()
+     * var current_progress = animated_sprite.get_frame_progress()
+     * animated_sprite.play("walk_another_skin")
+     * animated_sprite.set_frame_and_progress(current_frame, current_progress)
+     *
+     * ```
+     */
+    setFrameAndProgress(frame: number, progress: number): void { _C(this, 11481, frame, progress); }
+
+    /**
+     * Returns the actual playing speed of current animation or `0` if not playing. This speed is the {@link speedScale} property multiplied by `custom_speed` argument specified when calling the {@link play} method.
+     * Returns a negative value if the current animation is playing backwards.
+     */
+    getPlayingSpeed(): number { return _C(this, 5936) as number; }
+
+    /**
+     * The {@link SpriteFrames} resource containing the animation(s). Allows you the option to load, edit, clear, make unique and save the states of the {@link SpriteFrames} resource.
+     */
+    get spriteFrames(): SpriteFrames { return _C(this, 6503) as SpriteFrames; }
+    set spriteFrames(v: SpriteFrames) { _C(this, 12846, v); }
+
+    /**
+     * The current animation from the {@link spriteFrames} resource. If this value is changed, the {@link frame} counter and the {@link frameProgress} are reset.
+     */
+    get animation(): StringName { return _C(this, 3759) as StringName; }
+    set animation(v: StringName) { _C(this, 10502, v); }
+
+    /**
+     * The key of the animation to play when the scene loads.
+     */
+    get autoplay(): string { return _C(this, 3842) as string; }
+    set autoplay(v: string) { _C(this, 10586, v); }
+
+    /**
+     * The displayed animation frame's index. Setting this property also resets {@link frameProgress}. If this is not desired, use {@link setFrameAndProgress}.
+     */
+    get frame(): number { return _C(this, 4878) as number; }
+    set frame(v: number) { _C(this, 11480, v); }
+
+    /**
+     * The progress value between `0.0` and `1.0` until the current frame transitions to the next frame. If the animation is playing backwards, the value transitions from `1.0` to `0.0`.
+     */
+    get frameProgress(): number { return _C(this, 4886) as number; }
+    set frameProgress(v: number) { _C(this, 11484, v); }
+
+    /**
+     * The speed scaling ratio. For example, if this value is `1`, then the animation plays at normal speed. If it's `0.5`, then it plays at half speed. If it's `2`, then it plays at double speed.
+     * If set to a negative value, the animation is played in reverse. If set to `0`, the animation will not advance.
+     */
+    get speedScale(): number { return _C(this, 6495) as number; }
+    set speedScale(v: number) { _C(this, 12839, v); }
+
+    /**
+     * If `true`, texture will be centered.
+     * **Note:** For games with a pixel art aesthetic, textures may appear deformed when centered. This is caused by their position being between pixels. To prevent this, set this property to `false`, or consider enabling {@link ProjectSettings.rendering/2d/snap/snap2dVerticesToPixel} and {@link ProjectSettings.rendering/2d/snap/snap2dTransformsToPixel}.
+     */
+    get centered(): boolean { return _C(this, 7827) as boolean; }
+    set centered(v: boolean) { _C(this, 10847, v); }
+
+    /**
+     * The texture's drawing offset.
+     */
+    get offset(): Vector2 { return _C(this, 5703) as Vector2; }
+    set offset(v: Vector2) { _C(this, 12170, v); }
+
+    /**
+     * If `true`, texture is flipped horizontally.
+     */
+    get flipH(): boolean { return _C(this, 7957) as boolean; }
+    set flipH(v: boolean) { _C(this, 11417, v); }
+
+    /**
+     * If `true`, texture is flipped vertically.
+     */
+    get flipV(): boolean { return _C(this, 7958) as boolean; }
+    set flipV(v: boolean) { _C(this, 11418, v); }
+
+    /**
+     * Emitted when {@link spriteFrames} changes.
+     */
+    get spriteFramesChanged(): Signal<() => void> { return _G(this, 13798) as Signal<() => void>; }
+    set spriteFramesChanged(v: (() => void) | null) { _G(this, 13798, v); }
+
+    /**
+     * Emitted when {@link animation} changes.
+     */
+    get animationChanged(): Signal<() => void> { return _G(this, 1478) as Signal<() => void>; }
+    set animationChanged(v: (() => void) | null) { _G(this, 1478, v); }
+
+    /**
+     * Emitted when {@link frame} changes.
+     */
+    get frameChanged(): Signal<() => void> { return _G(this, 3564) as Signal<() => void>; }
+    set frameChanged(v: (() => void) | null) { _G(this, 3564, v); }
+
+    /**
+     * Emitted when the animation loops.
+     */
+    get animationLooped(): Signal<() => void> { return _G(this, 1483) as Signal<() => void>; }
+    set animationLooped(v: (() => void) | null) { _G(this, 1483, v); }
+
+    /**
+     * Emitted when the animation reaches the end, or the start if it is played in reverse. When the animation finishes, it pauses the playback.
+     * **Note:** This signal is not emitted if an animation is looping.
+     */
+    get animationFinished(): Signal<() => void> { return _G(this, 1479) as Signal<() => void>; }
+    set animationFinished(v: (() => void) | null) { _G(this, 1479, v); }
+
+    static readonly name = _R(50, AnimatedSprite2D);
+}

package/gen/classes/AnimatedSprite3D.ts

@@ -0,0 +1,134 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { SpriteBase3D } from './SpriteBase3D.ts';
+import type { Signal, StringName } from '../heap-types/index.ts';
+import type { SpriteFrames } from './SpriteFrames.ts';
+
+/**
+ * {@link AnimatedSprite3D} is similar to the {@link Sprite3D} node, except it carries multiple textures as animation {@link spriteFrames}. Animations are created using a {@link SpriteFrames} resource, which allows you to import image files (or a folder containing said files) to provide the animation frames for the sprite. The {@link SpriteFrames} resource can be configured in the editor via the SpriteFrames bottom panel.
+ */
+export class AnimatedSprite3D extends SpriteBase3D {
+    constructor(name = 51) { super(name); }
+
+    /**
+     * Returns `true` if an animation is currently playing (even if {@link speedScale} and/or `custom_speed` are `0`).
+     */
+    isPlaying(): boolean { return _C(this, 8183) as boolean; }
+
+    /**
+     * Plays the animation with key `name`. If `customSpeed` is negative and `fromEnd` is `true`, the animation will play backwards (which is equivalent to calling {@link playBackwards}).
+     * If this method is called with that same animation `name`, or with no `name` parameter, the assigned animation will resume playing if it was paused.
+     */
+    play(name?: StringName /* = &"" */, customSpeed?: number /* = 1.0 */, fromEnd?: boolean /* = false */): void { _C(this, 9447, name, customSpeed, fromEnd); }
+
+    /**
+     * Plays the animation with key `name` in reverse.
+     * This method is a shorthand for {@link play} with `custom_speed = -1.0` and `from_end = true`, so see its description for more information.
+     */
+    playBackwards(name?: StringName /* = &"" */): void { _C(this, 9449, name); }
+
+    /**
+     * Pauses the currently playing animation. The {@link frame} and {@link frameProgress} will be kept and calling {@link play} or {@link playBackwards} without arguments will resume the animation from the current playback position.
+     * See also {@link stop}.
+     */
+    pause(): void { _C(this, 9383); }
+
+    /**
+     * Stops the currently playing animation. The animation position is reset to `0` and the `custom_speed` is reset to `1.0`. See also {@link pause}.
+     */
+    stop(): void { _C(this, 13866); }
+
+    /**
+     * Sets {@link frame} and {@link frameProgress} to the given values. Unlike setting {@link frame}, this method does not reset the {@link frameProgress} to `0.0` implicitly.
+     * **Example:** Change the animation while keeping the same {@link frame} and {@link frameProgress}:
+     *
+     *
+     * ```gdscript
+     *
+     * var current_frame = animated_sprite.get_frame()
+     * var current_progress = animated_sprite.get_frame_progress()
+     * animated_sprite.play("walk_another_skin")
+     * animated_sprite.set_frame_and_progress(current_frame, current_progress)
+     *
+     * ```
+     */
+    setFrameAndProgress(frame: number, progress: number): void { _C(this, 11481, frame, progress); }
+
+    /**
+     * Returns the actual playing speed of current animation or `0` if not playing. This speed is the {@link speedScale} property multiplied by `custom_speed` argument specified when calling the {@link play} method.
+     * Returns a negative value if the current animation is playing backwards.
+     */
+    getPlayingSpeed(): number { return _C(this, 5936) as number; }
+
+    /**
+     * The {@link SpriteFrames} resource containing the animation(s). Allows you the option to load, edit, clear, make unique and save the states of the {@link SpriteFrames} resource.
+     */
+    get spriteFrames(): SpriteFrames { return _C(this, 6503) as SpriteFrames; }
+    set spriteFrames(v: SpriteFrames) { _C(this, 12846, v); }
+
+    /**
+     * The current animation from the {@link spriteFrames} resource. If this value is changed, the {@link frame} counter and the {@link frameProgress} are reset.
+     */
+    get animation(): StringName { return _C(this, 3759) as StringName; }
+    set animation(v: StringName) { _C(this, 10502, v); }
+
+    /**
+     * The key of the animation to play when the scene loads.
+     */
+    get autoplay(): string { return _C(this, 3842) as string; }
+    set autoplay(v: string) { _C(this, 10586, v); }
+
+    /**
+     * The displayed animation frame's index. Setting this property also resets {@link frameProgress}. If this is not desired, use {@link setFrameAndProgress}.
+     */
+    get frame(): number { return _C(this, 4878) as number; }
+    set frame(v: number) { _C(this, 11480, v); }
+
+    /**
+     * The progress value between `0.0` and `1.0` until the current frame transitions to the next frame. If the animation is playing backwards, the value transitions from `1.0` to `0.0`.
+     */
+    get frameProgress(): number { return _C(this, 4886) as number; }
+    set frameProgress(v: number) { _C(this, 11484, v); }
+
+    /**
+     * The speed scaling ratio. For example, if this value is `1`, then the animation plays at normal speed. If it's `0.5`, then it plays at half speed. If it's `2`, then it plays at double speed.
+     * If set to a negative value, the animation is played in reverse. If set to `0`, the animation will not advance.
+     */
+    get speedScale(): number { return _C(this, 6495) as number; }
+    set speedScale(v: number) { _C(this, 12839, v); }
+
+    /**
+     * Emitted when {@link spriteFrames} changes.
+     */
+    get spriteFramesChanged(): Signal<() => void> { return _G(this, 13798) as Signal<() => void>; }
+    set spriteFramesChanged(v: (() => void) | null) { _G(this, 13798, v); }
+
+    /**
+     * Emitted when {@link animation} changes.
+     */
+    get animationChanged(): Signal<() => void> { return _G(this, 1478) as Signal<() => void>; }
+    set animationChanged(v: (() => void) | null) { _G(this, 1478, v); }
+
+    /**
+     * Emitted when {@link frame} changes.
+     */
+    get frameChanged(): Signal<() => void> { return _G(this, 3564) as Signal<() => void>; }
+    set frameChanged(v: (() => void) | null) { _G(this, 3564, v); }
+
+    /**
+     * Emitted when the animation loops.
+     */
+    get animationLooped(): Signal<() => void> { return _G(this, 1483) as Signal<() => void>; }
+    set animationLooped(v: (() => void) | null) { _G(this, 1483, v); }
+
+    /**
+     * Emitted when the animation reaches the end, or the start if it is played in reverse. When the animation finishes, it pauses the playback.
+     * **Note:** This signal is not emitted if an animation is looping.
+     */
+    get animationFinished(): Signal<() => void> { return _G(this, 1479) as Signal<() => void>; }
+    set animationFinished(v: (() => void) | null) { _G(this, 1479, v); }
+
+    static readonly name = _R(51, AnimatedSprite3D);
+}

package/gen/classes/AnimatedTexture.ts

@@ -0,0 +1,74 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture2D } from './Texture2D.ts';
+
+/**
+ * {@link AnimatedTexture} is a resource format for frame-based animations, where multiple textures can be chained automatically with a predefined delay for each frame. Unlike {@link AnimationPlayer} or {@link AnimatedSprite2D}, it isn't a {@link Node}, but has the advantage of being usable anywhere a {@link Texture2D} resource can be used, e.g. in a {@link TileSet}.
+ * The playback of the animation is controlled by the {@link speedScale} property, as well as each frame's duration (see {@link setFrameDuration}). The animation loops, i.e. it will restart at frame 0 automatically after playing the last frame.
+ * {@link AnimatedTexture} currently requires all frame textures to have the same size, otherwise the bigger ones will be cropped to match the smallest one.
+ * **Note:** AnimatedTexture doesn't support using {@link AtlasTexture}s. Each frame needs to be a separate {@link Texture2D}.
+ * **Warning:** The current implementation is not efficient for the modern renderers.
+ */
+export class AnimatedTexture extends Texture2D {
+    constructor(name = 52) { super(name); }
+
+    /**
+     * Assigns a {@link Texture2D} to the given frame. Frame IDs start at 0, so the first frame has ID 0, and the last frame of the animation has ID {@link frames} - 1.
+     * You can define any number of textures up to {@link MAX_FRAMES}, but keep in mind that only frames from 0 to {@link frames} - 1 will be part of the animation.
+     */
+    setFrameTexture(frame: number, texture: Texture2D): void { _C(this, 11485, frame, texture); }
+
+    /**
+     * Returns the given frame's {@link Texture2D}.
+     */
+    getFrameTexture(frame: number): Texture2D { return _C(this, 4888, frame) as Texture2D; }
+
+    /**
+     * Sets the duration of any given `frame`. The final duration is affected by the {@link speedScale}. If set to `0`, the frame is skipped during playback.
+     */
+    setFrameDuration(frame: number, duration: number): void { _C(this, 11483, frame, duration); }
+
+    /**
+     * Returns the given `frame`'s duration, in seconds.
+     */
+    getFrameDuration(frame: number): number { return _C(this, 4882, frame) as number; }
+
+    /**
+     * Number of frames to use in the animation. While you can create the frames independently with {@link setFrameTexture}, you need to set this value for the animation to take new frames into account. The maximum number of frames is {@link MAX_FRAMES}.
+     */
+    get frames(): number { return _C(this, 4889) as number; }
+    set frames(v: number) { _C(this, 11486, v); }
+
+    /**
+     * Sets the currently visible frame of the texture. Setting this frame while playing resets the current frame time, so the newly selected frame plays for its whole configured frame duration.
+     */
+    get currentFrame(): number { return _C(this, 4352) as number; }
+    set currentFrame(v: number) { _C(this, 10988, v); }
+
+    /**
+     * If `true`, the animation will pause where it currently is (i.e. at {@link currentFrame}). The animation will continue from where it was paused when changing this property to `false`.
+     */
+    get pause(): boolean { return _C(this, 5869) as boolean; }
+    set pause(v: boolean) { _C(this, 12300, v); }
+
+    /**
+     * If `true`, the animation will only play once and will not loop back to the first frame after reaching the end. Note that reaching the end will not set {@link pause} to `true`.
+     */
+    get oneShot(): boolean { return _C(this, 5718) as boolean; }
+    set oneShot(v: boolean) { _C(this, 12185, v); }
+
+    /**
+     * The animation speed is multiplied by this value. If set to a negative value, the animation is played in reverse.
+     */
+    get speedScale(): number { return _C(this, 6495) as number; }
+    set speedScale(v: number) { _C(this, 12839, v); }
+
+    /**
+     * The maximum number of frames supported by {@link AnimatedTexture}. If you need more frames in your animation, use {@link AnimationPlayer} or {@link AnimatedSprite2D}.
+     */
+    static readonly MAX_FRAMES = 256;
+
+    static readonly name = _R(52, AnimatedTexture);
+}