typescript-to-gdscript 0.1.0

package/typings/classes/SpringBoneSimulator3D.d.ts

@@ -0,0 +1,283 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A {@link SkeletonModifier3D} to apply inertial wavering to bone chains. */
+declare class SpringBoneSimulator3D extends SkeletonModifier3D {
+  /**
+   * The constant force that always affected bones. It is equal to the result when the parent {@link Skeleton3D} moves at this speed in the opposite direction.
+   * This is useful for effects such as wind and anti-gravity.
+   */
+  external_force: Vector3;
+  /**
+   * If `true`, the solver retrieves the bone axis from the bone pose every frame.
+   * If `false`, the solver retrieves the bone axis from the bone rest and caches it, which increases performance slightly, but position changes in the bone pose made before processing this {@link SpringBoneSimulator3D} are ignored.
+   */
+  mutable_bone_axes: boolean;
+  /** The number of settings. */
+  setting_count: int;
+  set_external_force(value: Vector3 | Vector3i): void;
+  get_external_force(): Vector3;
+  set_mutable_bone_axes(value: boolean): void;
+  are_bone_axes_mutable(): boolean;
+  set_setting_count(value: int): void;
+  get_setting_count(): int;
+
+  /**
+   * Returns `true` if all child {@link SpringBoneCollision3D}s are contained in the collision list at `index` in the settings.
+   */
+  are_all_child_collisions_enabled(index: int): boolean;
+  /**
+   * Clears all collisions from the collision list at `index` in the settings when {@link are_all_child_collisions_enabled} is `false`.
+   */
+  clear_collisions(index: int): void;
+  /**
+   * Clears all exclude collisions from the collision list at `index` in the settings when {@link are_all_child_collisions_enabled} is `true`.
+   */
+  clear_exclude_collisions(index: int): void;
+  /** Clears all settings. */
+  clear_settings(): void;
+  /** Returns the center bone index of the bone chain. */
+  get_center_bone(index: int): int;
+  /** Returns the center bone name of the bone chain. */
+  get_center_bone_name(index: int): string;
+  /** Returns what the center originates from in the bone chain. */
+  get_center_from(index: int): int;
+  /** Returns the center node path of the bone chain. */
+  get_center_node(index: int): NodePath;
+  /**
+   * Returns the collision count of the bone chain's collision list when {@link are_all_child_collisions_enabled} is `false`.
+   */
+  get_collision_count(index: int): int;
+  /**
+   * Returns the node path of the {@link SpringBoneCollision3D} at `collision` in the bone chain's collision list when {@link are_all_child_collisions_enabled} is `false`.
+   */
+  get_collision_path(index: int, collision: int): NodePath;
+  /** Returns the drag force damping curve of the bone chain. */
+  get_drag(index: int): float;
+  /** Returns the drag force damping curve of the bone chain. */
+  get_drag_damping_curve(index: int): Curve | null;
+  /** Returns the end bone index of the bone chain. */
+  get_end_bone(index: int): int;
+  /**
+   * Returns the tail direction of the end bone of the bone chain when {@link is_end_bone_extended} is `true`.
+   */
+  get_end_bone_direction(index: int): int;
+  /** Returns the end bone tail length of the bone chain when {@link is_end_bone_extended} is `true`. */
+  get_end_bone_length(index: int): float;
+  /** Returns the end bone name of the bone chain. */
+  get_end_bone_name(index: int): string;
+  /**
+   * Returns the exclude collision count of the bone chain's exclude collision list when {@link are_all_child_collisions_enabled} is `true`.
+   */
+  get_exclude_collision_count(index: int): int;
+  /**
+   * Returns the node path of the {@link SpringBoneCollision3D} at `collision` in the bone chain's exclude collision list when {@link are_all_child_collisions_enabled} is `true`.
+   */
+  get_exclude_collision_path(index: int, collision: int): NodePath;
+  /** Returns the gravity amount of the bone chain. */
+  get_gravity(index: int): float;
+  /** Returns the gravity amount damping curve of the bone chain. */
+  get_gravity_damping_curve(index: int): Curve | null;
+  /** Returns the gravity direction of the bone chain. */
+  get_gravity_direction(index: int): Vector3;
+  /** Returns the bone index at `joint` in the bone chain's joint list. */
+  get_joint_bone(index: int, joint: int): int;
+  /** Returns the bone name at `joint` in the bone chain's joint list. */
+  get_joint_bone_name(index: int, joint: int): string;
+  /** Returns the joint count of the bone chain's joint list. */
+  get_joint_count(index: int): int;
+  /** Returns the drag force at `joint` in the bone chain's joint list. */
+  get_joint_drag(index: int, joint: int): float;
+  /** Returns the gravity amount at `joint` in the bone chain's joint list. */
+  get_joint_gravity(index: int, joint: int): float;
+  /** Returns the gravity direction at `joint` in the bone chain's joint list. */
+  get_joint_gravity_direction(index: int, joint: int): Vector3;
+  /** Returns the radius at `joint` in the bone chain's joint list. */
+  get_joint_radius(index: int, joint: int): float;
+  /** Returns the rotation axis at `joint` in the bone chain's joint list. */
+  get_joint_rotation_axis(index: int, joint: int): int;
+  /**
+   * Returns the rotation axis vector for the specified joint in the bone chain. This vector represents the axis around which the joint can rotate. It is determined based on the rotation axis set for the joint.
+   * If {@link get_joint_rotation_axis} is {@link SkeletonModifier3D.ROTATION_AXIS_ALL}, this method returns `Vector3(0, 0, 0)`.
+   */
+  get_joint_rotation_axis_vector(index: int, joint: int): Vector3;
+  /** Returns the stiffness force at `joint` in the bone chain's joint list. */
+  get_joint_stiffness(index: int, joint: int): float;
+  /** Returns the joint radius of the bone chain. */
+  get_radius(index: int): float;
+  /** Returns the joint radius damping curve of the bone chain. */
+  get_radius_damping_curve(index: int): Curve | null;
+  /** Returns the root bone index of the bone chain. */
+  get_root_bone(index: int): int;
+  /** Returns the root bone name of the bone chain. */
+  get_root_bone_name(index: int): string;
+  /** Returns the rotation axis of the bone chain. */
+  get_rotation_axis(index: int): int;
+  /**
+   * Returns the rotation axis vector of the bone chain. This vector represents the axis around which the bone chain can rotate. It is determined based on the rotation axis set for the bone chain.
+   * If {@link get_rotation_axis} is {@link SkeletonModifier3D.ROTATION_AXIS_ALL}, this method returns `Vector3(0, 0, 0)`.
+   */
+  get_rotation_axis_vector(index: int): Vector3;
+  /** Returns the stiffness force of the bone chain. */
+  get_stiffness(index: int): float;
+  /** Returns the stiffness force damping curve of the bone chain. */
+  get_stiffness_damping_curve(index: int): Curve | null;
+  /** Returns `true` if the config can be edited individually for each joint. */
+  is_config_individual(index: int): boolean;
+  /** Returns `true` if the end bone is extended to have a tail. */
+  is_end_bone_extended(index: int): boolean;
+  /**
+   * Resets a simulating state with respect to the current bone pose.
+   * It is useful to prevent the simulation result getting violent. For example, calling this immediately after a call to {@link AnimationPlayer.play} without a fading, or within the previous {@link SkeletonModifier3D.modification_processed} signal if it's condition changes significantly.
+   */
+  reset(): void;
+  /** Sets the center bone index of the bone chain. */
+  set_center_bone(index: int, bone: int): void;
+  /** Sets the center bone name of the bone chain. */
+  set_center_bone_name(index: int, bone_name: string | NodePath): void;
+  /**
+   * Sets what the center originates from in the bone chain.
+   * Bone movement is calculated based on the difference in relative distance between center and bone in the previous and next frames.
+   * For example, if the parent {@link Skeleton3D} is used as the center, the bones are considered to have not moved if the {@link Skeleton3D} moves in the world.
+   * In this case, only a change in the bone pose is considered to be a bone movement.
+   */
+  set_center_from(index: int, center_from: int): void;
+  /** Sets the center node path of the bone chain. */
+  set_center_node(index: int, node_path: NodePath | string): void;
+  /**
+   * Sets the number of collisions in the collision list at `index` in the settings when {@link are_all_child_collisions_enabled} is `false`.
+   */
+  set_collision_count(index: int, count: int): void;
+  /**
+   * Sets the node path of the {@link SpringBoneCollision3D} at `collision` in the bone chain's collision list when {@link are_all_child_collisions_enabled} is `false`.
+   */
+  set_collision_path(index: int, collision: int, node_path: NodePath | string): void;
+  /**
+   * Sets the drag force of the bone chain. The greater the value, the more suppressed the wiggling.
+   * The value is scaled by {@link set_drag_damping_curve} and cached in each joint setting in the joint list.
+   */
+  set_drag(index: int, drag: float): void;
+  /** Sets the drag force damping curve of the bone chain. */
+  set_drag_damping_curve(index: int, curve: Curve): void;
+  /**
+   * If `enabled` is `true`, all child {@link SpringBoneCollision3D}s are colliding and {@link set_exclude_collision_path} is enabled as an exclusion list at `index` in the settings.
+   * If `enabled` is `false`, you need to manually register all valid collisions with {@link set_collision_path}.
+   */
+  set_enable_all_child_collisions(index: int, enabled: boolean): void;
+  /** Sets the end bone index of the bone chain. */
+  set_end_bone(index: int, bone: int): void;
+  /** Sets the end bone tail direction of the bone chain when {@link is_end_bone_extended} is `true`. */
+  set_end_bone_direction(index: int, bone_direction: int): void;
+  /** Sets the end bone tail length of the bone chain when {@link is_end_bone_extended} is `true`. */
+  set_end_bone_length(index: int, length: float): void;
+  /**
+   * Sets the end bone name of the bone chain.
+   * **Note:** End bone must be the root bone or a child of the root bone. If they are the same, the tail must be extended by {@link set_extend_end_bone} to jiggle the bone.
+   */
+  set_end_bone_name(index: int, bone_name: string | NodePath): void;
+  /**
+   * Sets the number of exclude collisions in the exclude collision list at `index` in the settings when {@link are_all_child_collisions_enabled} is `true`.
+   */
+  set_exclude_collision_count(index: int, count: int): void;
+  /**
+   * Sets the node path of the {@link SpringBoneCollision3D} at `collision` in the bone chain's exclude collision list when {@link are_all_child_collisions_enabled} is `true`.
+   */
+  set_exclude_collision_path(index: int, collision: int, node_path: NodePath | string): void;
+  /**
+   * If `enabled` is `true`, the end bone is extended to have a tail.
+   * The extended tail config is allocated to the last element in the joint list. In other words, if you set `enabled` to `false`, the config of the last element in the joint list has no effect in the simulated result.
+   */
+  set_extend_end_bone(index: int, enabled: boolean): void;
+  /**
+   * Sets the gravity amount of the bone chain. This value is not an acceleration, but a constant velocity of movement in {@link set_gravity_direction}.
+   * If `gravity` is not `0`, the modified pose will not return to the original pose since it is always affected by gravity.
+   * The value is scaled by {@link set_gravity_damping_curve} and cached in each joint setting in the joint list.
+   */
+  set_gravity(index: int, gravity: float): void;
+  /** Sets the gravity amount damping curve of the bone chain. */
+  set_gravity_damping_curve(index: int, curve: Curve): void;
+  /**
+   * Sets the gravity direction of the bone chain. This value is internally normalized and then multiplied by {@link set_gravity}.
+   * The value is cached in each joint setting in the joint list.
+   */
+  set_gravity_direction(index: int, gravity_direction: Vector3 | Vector3i): void;
+  /** If `enabled` is `true`, the config can be edited individually for each joint. */
+  set_individual_config(index: int, enabled: boolean): void;
+  /**
+   * Sets the drag force at `joint` in the bone chain's joint list when {@link is_config_individual} is `true`.
+   */
+  set_joint_drag(index: int, joint: int, drag: float): void;
+  /**
+   * Sets the gravity amount at `joint` in the bone chain's joint list when {@link is_config_individual} is `true`.
+   */
+  set_joint_gravity(index: int, joint: int, gravity: float): void;
+  /**
+   * Sets the gravity direction at `joint` in the bone chain's joint list when {@link is_config_individual} is `true`.
+   */
+  set_joint_gravity_direction(index: int, joint: int, gravity_direction: Vector3 | Vector3i): void;
+  /**
+   * Sets the joint radius at `joint` in the bone chain's joint list when {@link is_config_individual} is `true`.
+   */
+  set_joint_radius(index: int, joint: int, radius: float): void;
+  /**
+   * Sets the rotation axis at `joint` in the bone chain's joint list when {@link is_config_individual} is `true`.
+   * The axes are based on the {@link Skeleton3D.get_bone_rest}'s space, if `axis` is {@link SkeletonModifier3D.ROTATION_AXIS_CUSTOM}, you can specify any axis.
+   * **Note:** The rotation axis and the forward vector shouldn't be colinear to avoid unintended rotation since {@link SpringBoneSimulator3D} does not factor in twisting forces.
+   */
+  set_joint_rotation_axis(index: int, joint: int, axis: int): void;
+  /**
+   * Sets the rotation axis vector for the specified joint in the bone chain.
+   * This vector is normalized by an internal process and represents the axis around which the bone chain can rotate.
+   * If the vector length is `0`, it is considered synonymous with {@link SkeletonModifier3D.ROTATION_AXIS_ALL}.
+   */
+  set_joint_rotation_axis_vector(index: int, joint: int, vector: Vector3 | Vector3i): void;
+  /**
+   * Sets the stiffness force at `joint` in the bone chain's joint list when {@link is_config_individual} is `true`.
+   */
+  set_joint_stiffness(index: int, joint: int, stiffness: float): void;
+  /**
+   * Sets the joint radius of the bone chain. It is used to move and slide with the {@link SpringBoneCollision3D} in the collision list.
+   * The value is scaled by {@link set_radius_damping_curve} and cached in each joint setting in the joint list.
+   */
+  set_radius(index: int, radius: float): void;
+  /** Sets the joint radius damping curve of the bone chain. */
+  set_radius_damping_curve(index: int, curve: Curve): void;
+  /** Sets the root bone index of the bone chain. */
+  set_root_bone(index: int, bone: int): void;
+  /** Sets the root bone name of the bone chain. */
+  set_root_bone_name(index: int, bone_name: string | NodePath): void;
+  /**
+   * Sets the rotation axis of the bone chain. If set to a specific axis, it acts like a hinge joint. The value is cached in each joint setting in the joint list.
+   * The axes are based on the {@link Skeleton3D.get_bone_rest}'s space, if `axis` is {@link SkeletonModifier3D.ROTATION_AXIS_CUSTOM}, you can specify any axis.
+   * **Note:** The rotation axis vector and the forward vector shouldn't be colinear to avoid unintended rotation since {@link SpringBoneSimulator3D} does not factor in twisting forces.
+   */
+  set_rotation_axis(index: int, axis: int): void;
+  /**
+   * Sets the rotation axis vector of the bone chain. The value is cached in each joint setting in the joint list.
+   * This vector is normalized by an internal process and represents the axis around which the bone chain can rotate.
+   * If the vector length is `0`, it is considered synonymous with {@link SkeletonModifier3D.ROTATION_AXIS_ALL}.
+   */
+  set_rotation_axis_vector(index: int, vector: Vector3 | Vector3i): void;
+  /**
+   * Sets the stiffness force of the bone chain. The greater the value, the faster it recovers to its initial pose.
+   * If `stiffness` is `0`, the modified pose will not return to the original pose.
+   * The value is scaled by {@link set_stiffness_damping_curve} and cached in each joint setting in the joint list.
+   */
+  set_stiffness(index: int, stiffness: float): void;
+  /** Sets the stiffness force damping curve of the bone chain. */
+  set_stiffness_damping_curve(index: int, curve: Curve): void;
+
+  // enum CenterFrom
+  /** The world origin is defined as center. */
+  static readonly CENTER_FROM_WORLD_ORIGIN: int;
+  /**
+   * The {@link Node3D} specified by {@link set_center_node} is defined as center.
+   * If {@link Node3D} is not found, the parent {@link Skeleton3D} is treated as center.
+   */
+  static readonly CENTER_FROM_NODE: int;
+  /**
+   * The bone pose origin of the parent {@link Skeleton3D} specified by {@link set_center_bone} is defined as center.
+   * If {@link Node3D} is not found, the parent {@link Skeleton3D} is treated as center.
+   */
+  static readonly CENTER_FROM_BONE: int;
+}

package/typings/classes/Sprite2D.d.ts

@@ -0,0 +1,88 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** General-purpose sprite node. */
+declare class Sprite2D extends Node2D {
+  /**
+   * If `true`, texture is 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/snap_2d_vertices_to_pixel} and {@link ProjectSettings.rendering/2d/snap/snap_2d_transforms_to_pixel}.
+   */
+  centered: boolean;
+  /** If `true`, texture is flipped horizontally. */
+  flip_h: boolean;
+  /** If `true`, texture is flipped vertically. */
+  flip_v: boolean;
+  /**
+   * Current frame to display from sprite sheet. {@link hframes} or {@link vframes} must be greater than 1. This property is automatically adjusted when {@link hframes} or {@link vframes} are changed to keep pointing to the same visual frame (same column and row). If that's impossible, this value is reset to `0`.
+   */
+  frame: int;
+  /**
+   * Coordinates of the frame to display from sprite sheet. This is as an alias for the {@link frame} property. {@link hframes} or {@link vframes} must be greater than 1.
+   */
+  frame_coords: Vector2i;
+  /**
+   * The number of columns in the sprite sheet. When this property is changed, {@link frame} is adjusted so that the same visual frame is maintained (same row and column). If that's impossible, {@link frame} is reset to `0`.
+   */
+  hframes: int;
+  /**
+   * The texture's drawing offset.
+   * **Note:** When you increase {@link offset}.y in Sprite2D, the sprite moves downward on screen (i.e., +Y is down).
+   */
+  offset: Vector2;
+  /**
+   * If `true`, texture is cut from a larger atlas texture. See {@link region_rect}.
+   * **Note:** When using a custom {@link Shader} on a {@link Sprite2D}, the `UV` shader built-in will refer to the entire texture space. Use the `REGION_RECT` built-in to get the currently visible region defined in {@link region_rect} instead. See CanvasItem shaders ($DOCS_URL/tutorials/shaders/shader_reference/canvas_item_shader.html) for details.
+   */
+  region_enabled: boolean;
+  /**
+   * If `true`, the area outside of the {@link region_rect} is clipped to avoid bleeding of the surrounding texture pixels. {@link region_enabled} must be `true`.
+   */
+  region_filter_clip_enabled: boolean;
+  /** The region of the atlas texture to display. {@link region_enabled} must be `true`. */
+  region_rect: Rect2;
+  /** {@link Texture2D} object to draw. */
+  texture: Texture2D | null;
+  /**
+   * The number of rows in the sprite sheet. When this property is changed, {@link frame} is adjusted so that the same visual frame is maintained (same row and column). If that's impossible, {@link frame} is reset to `0`.
+   */
+  vframes: int;
+  set_centered(value: boolean): void;
+  is_centered(): boolean;
+  set_flip_h(value: boolean): void;
+  is_flipped_h(): boolean;
+  set_flip_v(value: boolean): void;
+  is_flipped_v(): boolean;
+  set_frame(value: int): void;
+  get_frame(): int;
+  set_frame_coords(value: Vector2i | Vector2): void;
+  get_frame_coords(): Vector2i;
+  set_hframes(value: int): void;
+  get_hframes(): int;
+  set_offset(value: Vector2 | Vector2i): void;
+  get_offset(): Vector2;
+  set_region_enabled(value: boolean): void;
+  is_region_enabled(): boolean;
+  set_region_filter_clip_enabled(value: boolean): void;
+  is_region_filter_clip_enabled(): boolean;
+  set_region_rect(value: Rect2 | Rect2i): void;
+  get_region_rect(): Rect2;
+  set_texture(value: Texture2D | null): void;
+  get_texture(): Texture2D | null;
+  set_vframes(value: int): void;
+  get_vframes(): int;
+
+  /**
+   * Returns a {@link Rect2} representing the Sprite2D's boundary in local coordinates.
+   * **Example:** Detect if the Sprite2D was clicked:
+   */
+  get_rect(): Rect2;
+  /**
+   * Returns `true` if the pixel at the given position is opaque, `false` otherwise. Also returns `false` if the given position is out of bounds or this sprite's {@link texture} is `null`. `pos` is in local coordinates.
+   */
+  is_pixel_opaque(pos: Vector2 | Vector2i): boolean;
+
+  /** Emitted when the {@link frame} changes. */
+  frame_changed: Signal<[]>;
+  /** Emitted when the {@link texture} changes. */
+  texture_changed: Signal<[]>;
+}

package/typings/classes/Sprite3D.d.ts

@@ -0,0 +1,51 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** 2D sprite node in a 3D world. */
+declare class Sprite3D extends SpriteBase3D {
+  /**
+   * Current frame to display from sprite sheet. {@link hframes} or {@link vframes} must be greater than 1. This property is automatically adjusted when {@link hframes} or {@link vframes} are changed to keep pointing to the same visual frame (same column and row). If that's impossible, this value is reset to `0`.
+   */
+  frame: int;
+  /**
+   * Coordinates of the frame to display from sprite sheet. This is as an alias for the {@link frame} property. {@link hframes} or {@link vframes} must be greater than 1.
+   */
+  frame_coords: Vector2i;
+  /**
+   * The number of columns in the sprite sheet. When this property is changed, {@link frame} is adjusted so that the same visual frame is maintained (same row and column). If that's impossible, {@link frame} is reset to `0`.
+   */
+  hframes: int;
+  /**
+   * If `true`, the sprite will use {@link region_rect} and display only the specified part of its texture.
+   */
+  region_enabled: boolean;
+  /** The region of the atlas texture to display. {@link region_enabled} must be `true`. */
+  region_rect: Rect2;
+  /**
+   * {@link Texture2D} object to draw. If {@link GeometryInstance3D.material_override} is used, this will be overridden. The size information is still used.
+   */
+  texture: Texture2D | null;
+  /**
+   * The number of rows in the sprite sheet. When this property is changed, {@link frame} is adjusted so that the same visual frame is maintained (same row and column). If that's impossible, {@link frame} is reset to `0`.
+   */
+  vframes: int;
+  set_frame(value: int): void;
+  get_frame(): int;
+  set_frame_coords(value: Vector2i | Vector2): void;
+  get_frame_coords(): Vector2i;
+  set_hframes(value: int): void;
+  get_hframes(): int;
+  set_region_enabled(value: boolean): void;
+  is_region_enabled(): boolean;
+  set_region_rect(value: Rect2 | Rect2i): void;
+  get_region_rect(): Rect2;
+  set_texture(value: Texture2D | null): void;
+  get_texture(): Texture2D | null;
+  set_vframes(value: int): void;
+  get_vframes(): int;
+
+  /** Emitted when the {@link frame} changes. */
+  frame_changed: Signal<[]>;
+  /** Emitted when the {@link texture} changes. */
+  texture_changed: Signal<[]>;
+}

package/typings/classes/SpriteBase3D.d.ts

@@ -0,0 +1,147 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** 2D sprite node in 3D environment. */
+declare class SpriteBase3D extends GeometryInstance3D {
+  /** Threshold at which antialiasing will be applied on the alpha channel. */
+  alpha_antialiasing_edge: float;
+  /** The type of alpha antialiasing to apply. */
+  alpha_antialiasing_mode: int;
+  /** The alpha cutting mode to use for the sprite. */
+  alpha_cut: int;
+  /** The hashing scale for Alpha Hash. Recommended values between `0` and `2`. */
+  alpha_hash_scale: float;
+  /** Threshold at which the alpha scissor will discard values. */
+  alpha_scissor_threshold: float;
+  /** The direction in which the front of the texture faces. */
+  axis: int;
+  /**
+   * The billboard mode to use for the sprite.
+   * **Note:** When billboarding is enabled and the material also casts shadows, billboards will face **the** camera in the scene when rendering shadows. In scenes with multiple cameras, the intended shadow cannot be determined and this will result in undefined behavior. See GitHub Pull Request #72638 (https://github.com/godotengine/godot/pull/72638) for details.
+   */
+  billboard: int;
+  /** If `true`, texture will be centered. */
+  centered: boolean;
+  /**
+   * If `true`, texture can be seen from the back as well, if `false`, it is invisible when looking at it from behind.
+   */
+  double_sided: boolean;
+  /**
+   * If `true`, the texture is rendered at the same size regardless of distance. The texture's size on screen is the same as if the camera was `1.0` units away from the texture's origin, regardless of the actual distance from the camera. The {@link Camera3D}'s field of view (or {@link Camera3D.size} when in orthogonal/frustum mode) still affects the size the sprite is drawn at.
+   */
+  fixed_size: boolean;
+  /** If `true`, texture is flipped horizontally. */
+  flip_h: boolean;
+  /** If `true`, texture is flipped vertically. */
+  flip_v: boolean;
+  /**
+   * A color value used to *multiply* the texture's colors. Can be used for mood-coloring or to simulate the color of ambient light.
+   * **Note:** Unlike {@link CanvasItem.modulate} for 2D, colors with values above `1.0` (overbright) are not supported.
+   * **Note:** If a {@link GeometryInstance3D.material_override} is defined on the {@link SpriteBase3D}, the material override must be configured to take vertex colors into account for albedo. Otherwise, the color defined in {@link modulate} will be ignored. For a {@link BaseMaterial3D}, {@link BaseMaterial3D.vertex_color_use_as_albedo} must be `true`. For a {@link ShaderMaterial}, `ALBEDO *= COLOR.rgb;` must be inserted in the shader's `fragment()` function.
+   */
+  modulate: Color;
+  /** If `true`, depth testing is disabled and the object will be drawn in render order. */
+  no_depth_test: boolean;
+  /**
+   * The texture's drawing offset.
+   * **Note:** When you increase {@link offset}.y in Sprite3D, the sprite moves upward in world space (i.e., +Y is up).
+   */
+  offset: Vector2;
+  /** The size of one pixel's width on the sprite to scale it in 3D. */
+  pixel_size: float;
+  /**
+   * Sets the render priority for the sprite. Higher priority objects will be sorted in front of lower priority objects.
+   * **Note:** This only applies if {@link alpha_cut} is set to {@link ALPHA_CUT_DISABLED} (default value).
+   * **Note:** This only applies to sorting of transparent objects. This will not impact how transparent objects are sorted relative to opaque objects. This is because opaque objects are not sorted, while transparent objects are sorted from back to front (subject to priority).
+   */
+  render_priority: int;
+  /** If `true`, the {@link Light3D} in the {@link Environment} has effects on the sprite. */
+  shaded: boolean;
+  /**
+   * Filter flags for the texture.
+   * **Note:** Linear filtering may cause artifacts around the edges, which are especially noticeable on opaque textures. To prevent this, use textures with transparent or identical colors around the edges.
+   */
+  texture_filter: int;
+  /**
+   * If `true`, the texture's transparency and the opacity are used to make those parts of the sprite invisible.
+   */
+  transparent: boolean;
+  set_alpha_antialiasing_edge(value: float): void;
+  get_alpha_antialiasing_edge(): float;
+  set_alpha_antialiasing(value: int): void;
+  get_alpha_antialiasing(): int;
+  set_alpha_cut_mode(value: int): void;
+  get_alpha_cut_mode(): int;
+  set_alpha_hash_scale(value: float): void;
+  get_alpha_hash_scale(): float;
+  set_alpha_scissor_threshold(value: float): void;
+  get_alpha_scissor_threshold(): float;
+  set_axis(value: int): void;
+  get_axis(): int;
+  set_billboard_mode(value: int): void;
+  get_billboard_mode(): int;
+  set_centered(value: boolean): void;
+  is_centered(): boolean;
+  set_flip_h(value: boolean): void;
+  is_flipped_h(): boolean;
+  set_flip_v(value: boolean): void;
+  is_flipped_v(): boolean;
+  set_modulate(value: Color): void;
+  get_modulate(): Color;
+  set_offset(value: Vector2 | Vector2i): void;
+  get_offset(): Vector2;
+  set_pixel_size(value: float): void;
+  get_pixel_size(): float;
+  set_render_priority(value: int): void;
+  get_render_priority(): int;
+  set_texture_filter(value: int): void;
+  get_texture_filter(): int;
+
+  /**
+   * Returns a {@link TriangleMesh} with the sprite's vertices following its current configuration (such as its {@link axis} and {@link pixel_size}).
+   */
+  generate_triangle_mesh(): TriangleMesh;
+  /** Returns the value of the specified flag. */
+  get_draw_flag(flag: int): boolean;
+  /** Returns the rectangle representing this sprite. */
+  get_item_rect(): Rect2;
+  /** If `true`, the specified flag will be enabled. */
+  set_draw_flag(flag: int, enabled: boolean): void;
+
+  // enum DrawFlags
+  /**
+   * If set, the texture's transparency and the opacity are used to make those parts of the sprite invisible.
+   */
+  static readonly FLAG_TRANSPARENT: int;
+  /** If set, lights in the environment affect the sprite. */
+  static readonly FLAG_SHADED: int;
+  /**
+   * If set, texture can be seen from the back as well. If not, the texture is invisible when looking at it from behind.
+   */
+  static readonly FLAG_DOUBLE_SIDED: int;
+  /**
+   * Disables the depth test, so this object is drawn on top of all others. However, objects drawn after it in the draw order may cover it.
+   */
+  static readonly FLAG_DISABLE_DEPTH_TEST: int;
+  /** Label is scaled by depth so that it always appears the same size on screen. */
+  static readonly FLAG_FIXED_SIZE: int;
+  /** Represents the size of the {@link DrawFlags} enum. */
+  static readonly FLAG_MAX: int;
+  // enum AlphaCutMode
+  /**
+   * This mode performs standard alpha blending. It can display translucent areas, but transparency sorting issues may be visible when multiple transparent materials are overlapping.
+   */
+  static readonly ALPHA_CUT_DISABLED: int;
+  /**
+   * This mode only allows fully transparent or fully opaque pixels. Harsh edges will be visible unless some form of screen-space antialiasing is enabled (see {@link ProjectSettings.rendering/anti_aliasing/quality/screen_space_aa}). On the bright side, this mode doesn't suffer from transparency sorting issues when multiple transparent materials are overlapping. This mode is also known as *alpha testing* or *1-bit transparency*.
+   */
+  static readonly ALPHA_CUT_DISCARD: int;
+  /**
+   * This mode draws fully opaque pixels in the depth prepass. This is slower than {@link ALPHA_CUT_DISABLED} or {@link ALPHA_CUT_DISCARD}, but it allows displaying translucent areas and smooth edges while using proper sorting.
+   */
+  static readonly ALPHA_CUT_OPAQUE_PREPASS: int;
+  /**
+   * This mode draws cuts off all values below a spatially-deterministic threshold, the rest will remain opaque.
+   */
+  static readonly ALPHA_CUT_HASH: int;
+}

package/typings/classes/SpriteFrames.d.ts

@@ -0,0 +1,57 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Sprite frame library for AnimatedSprite2D and AnimatedSprite3D. */
+declare class SpriteFrames extends Resource {
+  /** Adds a new `anim` animation to the library. */
+  add_animation(anim: string): void;
+  /**
+   * Adds a frame to the `anim` animation. If `at_position` is `-1`, the frame will be added to the end of the animation. `duration` specifies the relative duration, see {@link get_frame_duration} for details.
+   */
+  add_frame(anim: string, texture: Texture2D, duration?: float, at_position?: int): void;
+  /** Removes all frames from the `anim` animation. */
+  clear(anim: string): void;
+  /** Removes all animations. An empty `default` animation will be created. */
+  clear_all(): void;
+  /**
+   * Duplicates the animation `anim_from` to a new animation named `anim_to`. Fails if `anim_to` already exists, or if `anim_from` does not exist.
+   */
+  duplicate_animation(anim_from: string, anim_to: string): void;
+  /**
+   * Returns `true` if the given animation is configured to loop when it finishes playing. Otherwise, returns `false`.
+   */
+  get_animation_loop(anim: string): boolean;
+  /**
+   * Returns an array containing the names associated to each animation. Values are placed in alphabetical order.
+   */
+  get_animation_names(): PackedStringArray;
+  /** Returns the speed in frames per second for the `anim` animation. */
+  get_animation_speed(anim: string): float;
+  /** Returns the number of frames for the `anim` animation. */
+  get_frame_count(anim: string): int;
+  /**
+   * Returns a relative duration of the frame `idx` in the `anim` animation (defaults to `1.0`). For example, a frame with a duration of `2.0` is displayed twice as long as a frame with a duration of `1.0`. You can calculate the absolute duration (in seconds) of a frame using the following formula:
+   * In this example, `playing_speed` refers to either {@link AnimatedSprite2D.get_playing_speed} or {@link AnimatedSprite3D.get_playing_speed}.
+   */
+  get_frame_duration(anim: string, idx: int): float;
+  /** Returns the texture of the frame `idx` in the `anim` animation. */
+  get_frame_texture(anim: string, idx: int): Texture2D | null;
+  /** Returns `true` if the `anim` animation exists. */
+  has_animation(anim: string): boolean;
+  /** Removes the `anim` animation. */
+  remove_animation(anim: string): void;
+  /** Removes the `anim` animation's frame `idx`. */
+  remove_frame(anim: string, idx: int): void;
+  /** Changes the `anim` animation's name to `newname`. */
+  rename_animation(anim: string, newname: string): void;
+  /**
+   * If `loop` is `true`, the `anim` animation will loop when it reaches the end, or the start if it is played in reverse.
+   */
+  set_animation_loop(anim: string, loop: boolean): void;
+  /** Sets the speed for the `anim` animation in frames per second. */
+  set_animation_speed(anim: string, fps: float): void;
+  /**
+   * Sets the `texture` and the `duration` of the frame `idx` in the `anim` animation. `duration` specifies the relative duration, see {@link get_frame_duration} for details.
+   */
+  set_frame(anim: string, idx: int, texture: Texture2D, duration?: float): void;
+}

package/typings/classes/StandardMaterial3D.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A PBR (Physically Based Rendering) material to be used on 3D objects. */
+declare class StandardMaterial3D extends BaseMaterial3D {
+}

package/typings/classes/StaticBody2D.d.ts

@@ -0,0 +1,27 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A 2D physics body that can't be moved by external forces. When moved manually, it doesn't affect other bodies in its path.
+ */
+declare class StaticBody2D extends PhysicsBody2D {
+  /**
+   * The body's constant angular velocity. This does not rotate the body, but affects touching bodies, as if it were rotating.
+   */
+  constant_angular_velocity: float;
+  /**
+   * The body's constant linear velocity. This does not move the body, but affects touching bodies, as if it were moving.
+   */
+  constant_linear_velocity: Vector2;
+  /**
+   * The physics material override for the body.
+   * If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one.
+   */
+  physics_material_override: PhysicsMaterial | null;
+  set_constant_angular_velocity(value: float): void;
+  get_constant_angular_velocity(): float;
+  set_constant_linear_velocity(value: Vector2 | Vector2i): void;
+  get_constant_linear_velocity(): Vector2;
+  set_physics_material_override(value: PhysicsMaterial | null): void;
+  get_physics_material_override(): PhysicsMaterial | null;
+}