typescript-to-gdscript 0.1.0 → 0.1.2

package/typings/classes/RenderingDevice.d.ts

@@ -3,16 +3,15 @@
 
 /** Abstraction for working with modern low-level graphics APIs. */
 declare class RenderingDevice extends GodotObject {
-  /** Builds the `acceleration_structure`. */
-  acceleration_structure_build(acceleration_structure: RID): int;
   /** This method does nothing. */
   barrier(from_: int, to: int): void;
+  /** Builds the `blas`. */
+  blas_build(blas: RID): int;
   /**
-   * Creates a new Bottom Level Acceleration Structure. It can be accessed with the RID that is returned.
+   * Creates a new Bottom-Level Acceleration Structure (BLAS). It can be accessed with the RID that is returned.
    * Once finished with your RID, you will want to free the RID using the RenderingDevice's {@link free_rid} method.
-   * `position_attribute_location` selects which vertex attribute location supplies the position data (default is 0).
    */
-  blas_create(vertex_array: RID, index_array: RID, geometry_bits: int, position_attribute_location?: int): RID;
+  blas_create(geometries: Array<RDAccelerationStructureGeometry>, flags: int): RID;
   /**
    * Clears the contents of the `buffer`, clearing `size_bytes` bytes, starting at `offset`.
    * Prints an error if:
@@ -335,6 +334,44 @@ declare class RenderingDevice extends GodotObject {
   get_tracked_object_type_count(): int;
   /** Returns `true` if the `feature` is supported by the GPU. */
   has_feature(feature: int): boolean;
+  /**
+   * Creates a new hit shader binding table (SBT). It can be accessed with the RID that is returned.
+   * Once finished with your RID, you will want to free the RID using the RenderingDevice's {@link free_rid} method.
+   * This will be freed automatically when the `raytracing_pipeline` is freed.
+   * The hit SBT resizes itself as needed. `initial_hit_group_capacity` is used to allocate the initial backing memory.
+   */
+  hit_sbt_create(raytracing_pipeline: RID, initial_hit_group_capacity: int): RID;
+  /**
+   * Allocates a contiguous range of SBT entries from `hit_sbt`.
+   * The returned value should be assigned to {@link RDAccelerationStructureInstance.hit_sbt_range}.
+   * During ray traversal, hit group index is computed as:
+   * (geometry index in {@link RDAccelerationStructureInstance.blas})
+   * × (SBT stride used in `traceRayEXT`)
+   * + (SBT offset used in `traceRayEXT`)
+   * + (range offset)
+   * `hit_group_count` must be large enough to cover all SBT entries that may be indexed by this equation. This typically corresponds to:
+   * (geometry count in {@link RDAccelerationStructureInstance.blas})
+   * × (SBT stride used in `traceRayEXT`)
+   * The allocated range is uninitialized and must be filled using {@link hit_sbt_range_update}.
+   */
+  hit_sbt_range_alloc(hit_sbt: RID, hit_group_count: int): int;
+  /**
+   * Frees a hit SBT range previously allocated with {@link hit_sbt_range_alloc}.
+   * The range must not be in use by any acceleration structure after being freed.
+   */
+  hit_sbt_range_free(hit_sbt: RID, range: int): int;
+  /**
+   * Updates the contents of a hit SBT range.
+   * `hit_group_indices` specifies indices into the hit group array provided in {@link raytracing_pipeline_create}.
+   * The `offset` parameter specifies where within the allocated range the writing begins. This allows partial updates of a range. However, the complete range must be fully initialized before it is used in a raytracing dispatch.
+   */
+  hit_sbt_range_update(hit_sbt: RID, range: int, offset: int, hit_group_indices: PackedInt32Array | Array<unknown>): int;
+  /**
+   * Sets a new `raytracing_pipeline` for `hit_sbt`.
+   * The new pipeline must be a superset of the previous one. Existing hit groups must keep the same order and new hit groups should be appended to the end. This preserves existing SBT entries.
+   * The previous pipeline must remain valid during the call.
+   */
+  hit_sbt_set_pipeline(hit_sbt: RID, raytracing_pipeline: RID): int;
   /**
    * Creates a new index array. It can be accessed with the RID that is returned.
    * Once finished with your RID, you will want to free the RID using the RenderingDevice's {@link free_rid} method.
@@ -368,15 +405,21 @@ declare class RenderingDevice extends GodotObject {
    */
   raytracing_list_set_push_constant(raytracing_list: int, buffer: PackedByteArray | Array<unknown>, size_bytes: int): void;
   /**
-   * Initializes a ray tracing dispatch for the specified `raytracing_list` assembling a group of `width` x `height` rays.
+   * Initializes a raytracing dispatch for `raytracing_list`, launching `width` × `height` × `depth` rays.
+   * `raygen_shader_index` selects the ray generation shader from the pipeline bound with {@link raytracing_list_bind_raytracing_pipeline}.
+   * `hit_sbt` must use the same pipeline bound to `raytracing_list`.
    */
-  raytracing_list_trace_rays(raytracing_list: int, width: int, height: int): void;
+  raytracing_list_trace_rays(raytracing_list: int, raygen_shader_index: int, hit_sbt: RID, width: int, height: int, depth: int): void;
   /**
    * Creates a new raytracing pipeline. It can be accessed with the RID that is returned.
    * Once finished with your RID, you will want to free the RID using the RenderingDevice's {@link free_rid} method.
-   * **Note:**: Recursive raytracing is not permitted.
+   * Each shader must provide the required stage. All stages must use compatible pipeline layouts. The pipeline selects the required stage from each shader.
+   * Input order defines stable indices used by the API:
+   * - `raygen_shaders` is indexed in {@link raytracing_list_trace_rays}.
+   * - `miss_shaders` is indexed in `traceRayEXT`.
+   * - `hit_groups` is indexed in {@link hit_sbt_range_update}.
    */
-  raytracing_pipeline_create(shader: RID, specialization_constants?: Array<RDPipelineSpecializationConstant>): RID;
+  raytracing_pipeline_create(raygen_shaders: Array<RDPipelineShader>, miss_shaders: Array<RDPipelineShader>, hit_groups: Array<RDHitGroup>, max_trace_recursion_depth: int): RID;
   /**
    * Returns `true` if the raytracing pipeline specified by the `raytracing_pipeline` RID is valid, `false` otherwise.
    */
@@ -476,7 +519,7 @@ declare class RenderingDevice extends GodotObject {
    */
   texture_clear(texture: RID, color: Color, base_mipmap: int, mipmap_count: int, base_layer: int, layer_count: int): int;
   /**
-   * Copies the `from_texture` to `to_texture` with the specified `from_pos`, `to_pos` and `size` coordinates. The Z axis of the `from_pos`, `to_pos` and `size` must be `0` for 2-dimensional textures. Source and destination mipmaps/layers must also be specified, with these parameters being `0` for textures without mipmaps or single-layer textures. Returns {@link @GlobalScope.OK} if the texture copy was successful or {@link @GlobalScope.ERR_INVALID_PARAMETER} otherwise.
+   * Copies the `from_texture` to `to_texture` with the specified `from_pos`, `to_pos` and `size` coordinates. For 2-dimensional textures, `from_pos` and `to_pos` must have a Z axis of `0`, and `size` must have a Z axis of `1`. Source and destination mipmaps/layers must also be specified, with these parameters being `0` for textures without mipmaps or single-layer textures. Returns {@link @GlobalScope.OK} if the texture copy was successful or {@link @GlobalScope.ERR_INVALID_PARAMETER} otherwise.
    * **Note:** `from_texture` texture can't be copied while a draw list that uses it as part of a framebuffer is being created. Ensure the draw list is finalized (and that the color/depth texture using it is not set to {@link FINAL_ACTION_CONTINUE}) to copy this texture.
    * **Note:** `from_texture` texture requires the {@link TEXTURE_USAGE_CAN_COPY_FROM_BIT} to be retrieved.
    * **Note:** `to_texture` can't be copied while a draw list that uses it as part of a framebuffer is being created. Ensure the draw list is finalized (and that the color/depth texture using it is not set to {@link FINAL_ACTION_CONTINUE}) to copy this texture.
@@ -564,20 +607,17 @@ declare class RenderingDevice extends GodotObject {
    */
   texture_update(texture: RID, layer: int, data: PackedByteArray | Array<unknown>): int;
   /**
-   * Creates a new Top Level Acceleration Structure. It can be accessed with the RID that is returned.
-   * The instances buffer passed as input is expected to be filled before building the TLAS.
-   * Once finished with your RID, you will want to free the RID using the RenderingDevice's {@link free_rid} method.
+   * Builds the `tlas`. The contents of previous builds are discarded.
+   * Any BLAS provided through the {@link RDAccelerationStructureInstance.blas} member must already have been built using the {@link blas_build} method.
+   * The number of instances can be equal to or smaller than the maximum instance count provided in the {@link tlas_create} method.
+   * **Note:** Freeing or rebuilding any of the provided BLASes after this method invalidates the TLAS and requires it to be rebuilt.
    */
-  tlas_create(instances_buffer: RID): RID;
+  tlas_build(tlas: RID, instances: Array<RDAccelerationStructureInstance>): int;
   /**
-   * Creates a new instances buffer which can be used to create a TLAS. It can be accessed with the RID that is returned.
+   * Creates a new Top-Level Acceleration Structure (TLAS). It can be accessed with the RID that is returned.
    * Once finished with your RID, you will want to free the RID using the RenderingDevice's {@link free_rid} method.
    */
-  tlas_instances_buffer_create(instance_count: int, creation_bits: int): RID;
-  /**
-   * Fills the content of an instances buffer. The number of BLASes and transforms passed as input should be the same and should equal the instance count used at instance buffer creation time.
-   */
-  tlas_instances_buffer_fill(instances_buffer: RID, blases: Array<RID>, transforms: Array<Transform3D>): void;
+  tlas_create(max_instance_count: int, flags: int): RID;
   /**
    * Creates a new uniform buffer. It can be accessed with the RID that is returned.
    * Once finished with your RID, you will want to free the RID using the RenderingDevice's {@link free_rid} method.
@@ -1777,11 +1817,41 @@ declare class RenderingDevice extends GodotObject {
    * Allows usage of this buffer as input data for an acceleration structure build operation. You must first check that the GPU supports it:
    */
   static readonly BUFFER_CREATION_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT: int;
-  // enum AccelerationStructureGeometryBits
+  // enum AccelerationStructureFlagBits
+  /** Allows the acceleration structure to be updated after it has been built. */
+  static readonly ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT: int;
+  /** Allows the acceleration structure to be compacted to reduce memory usage after it has been built. */
+  static readonly ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT: int;
+  /**
+   * Prioritizes ray traversal performance over build performance when building the acceleration structure.
+   */
+  static readonly ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT: int;
+  /**
+   * Prioritizes build performance over ray traversal performance when building the acceleration structure.
+   */
+  static readonly ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT: int;
+  /**
+   * Reduces the memory usage of the acceleration structure, potentially at the cost of reduced ray traversal performance.
+   */
+  static readonly ACCELERATION_STRUCTURE_LOW_MEMORY_BIT: int;
+  // enum AccelerationStructureGeometryFlagBits
   /** An opaque geometry does not invoke the any hit shaders. */
-  static readonly ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE: int;
+  static readonly ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT: int;
   /** This geometry only calls the any hit shader a single time for each primitive. */
-  static readonly ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION: int;
+  static readonly ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT: int;
+  // enum AccelerationStructureInstanceFlagBits
+  /** Disables triangle face culling for this instance during ray traversal. */
+  static readonly ACCELERATION_STRUCTURE_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT: int;
+  /** Flips the triangle facing direction for this instance during ray traversal. */
+  static readonly ACCELERATION_STRUCTURE_INSTANCE_TRIANGLE_FLIP_FACING_BIT: int;
+  /**
+   * Forces all geometries in this instance to be treated as opaque, preventing any hit shaders from being invoked.
+   */
+  static readonly ACCELERATION_STRUCTURE_INSTANCE_FORCE_OPAQUE_BIT: int;
+  /**
+   * Forces all geometries in this instance to be treated as non-opaque, allowing any hit shaders to be invoked.
+   */
+  static readonly ACCELERATION_STRUCTURE_INSTANCE_FORCE_NO_OPAQUE_BIT: int;
   // enum UniformType
   /** Sampler uniform. */
   static readonly UNIFORM_TYPE_SAMPLER: int;

package/typings/classes/RenderingServer.d.ts

@@ -10,6 +10,13 @@ declare interface RenderingServer extends GodotObject {
   set_render_loop_enabled(value: boolean): void;
   is_render_loop_enabled(): boolean;
 
+  /**
+   * Creates a new area light and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID can be used in most `light_*` RenderingServer functions.
+   * Once finished with your RID, you will want to free the RID using the RenderingServer's {@link free_rid} method.
+   * To place in a scene, attach this area light to an instance using {@link instance_set_base} using the returned RID.
+   * **Note:** The equivalent node is {@link AreaLight3D}.
+   */
+  area_light_create(): RID;
   /**
    * Bakes the material data of the Mesh passed in the `base` parameter with optional `material_overrides` to a set of {@link Image}s of size `image_size`. Returns an array of {@link Image}s containing material properties as specified in {@link BakeChannels}.
    */
@@ -612,7 +619,7 @@ declare interface RenderingServer extends GodotObject {
   /**
    * Sets the variables to be used with the volumetric fog post-process effect. See {@link Environment} for more details.
    */
-  environment_set_volumetric_fog(env: RID, enable: boolean, density: float, albedo: Color, emission: Color, emission_energy: float, anisotropy: float, length: float, p_detail_spread: float, gi_inject: float, temporal_reprojection: boolean, temporal_reprojection_amount: float, ambient_inject: float, sky_affect: float): void;
+  environment_set_volumetric_fog(env: RID, enable: boolean, density: float, albedo: Color, emission: Color, emission_energy: float, anisotropy: float, length: float, detail_spread: float, gi_inject: float, temporal_reprojection: boolean, temporal_reprojection_amount: float, ambient_inject: float, sky_affect: float): void;
   /**
    * Enables filtering of the volumetric fog scattering buffer. This results in much smoother volumes with very few under-sampling artifacts.
    */
@@ -884,6 +891,14 @@ declare interface RenderingServer extends GodotObject {
   instances_cull_ray(from_: Vector3 | Vector3i, to: Vector3 | Vector3i, scenario?: RID): PackedInt64Array;
   /** Returns `true` if our code is currently executing on the rendering thread. */
   is_on_render_thread(): boolean;
+  /**
+   * Defines whether the energy of an {@link AreaLight3D} is normalized (divided) by its area. If set to `true`, changing the size does not affect the total energy output. Equivalent to {@link AreaLight3D.area_normalize_energy}.
+   */
+  light_area_set_normalize_energy(light: RID, enable: boolean): void;
+  /**
+   * Sets the extents (width and height) in meters for this area light. Equivalent to {@link AreaLight3D.area_size}.
+   */
+  light_area_set_size(light: RID, size: Vector2 | Vector2i): void;
   /**
    * If `true`, this directional light will blend between shadow map splits resulting in a smoother transition between them. Equivalent to {@link DirectionalLight3D.directional_shadow_blend_splits}.
    */
@@ -1338,8 +1353,11 @@ declare interface RenderingServer extends GodotObject {
    * Add particle system to list of particle systems that need to be updated. Update will take place on the next frame, or on the next call to {@link instances_cull_aabb}, {@link instances_cull_convex}, or {@link instances_cull_ray}.
    */
   particles_request_process(particles: RID): void;
-  /** Requests particles to process for extra process time during a single frame. */
-  particles_request_process_time(particles: RID, time: float): void;
+  /**
+   * Requests the particles to process for extra process time during a single frame.
+   * `process_time` defines the time that the particles will process while emitting is on. `process_time_residual` defines the time that particles will process with emitting turned off for the simulation. When combined with the particles' speed scale set to `0.0`, this is useful to be able to seek a particle system timeline.
+   */
+  particles_request_process_time(particles: RID, process_time: float, process_time_residual?: float): void;
   /** Reset the particles on the next update. Equivalent to {@link GPUParticles3D.restart}. */
   particles_restart(particles: RID): void;
   /**
@@ -1433,6 +1451,10 @@ declare interface RenderingServer extends GodotObject {
    * Sets the transform alignment for the particle system. Equivalent to {@link GPUParticles3D.transform_align}.
    */
   particles_set_transform_align(particles: RID, align: int): void;
+  /** Sets which axis to use for transform alignment. */
+  particles_set_transform_align_axis(particles: RID, rotation_axis: int): void;
+  /** When using Z-Billboarding, which CUSTOM channel to read from. */
+  particles_set_transform_align_channel_filter(particles: RID, channel_filter: int): void;
   /**
    * If `true`, particles use local coordinates. If `false` they use global coordinates. Equivalent to {@link GPUParticles3D.local_coords}.
    */
@@ -1904,6 +1926,7 @@ declare interface RenderingServer extends GodotObject {
   /**
    * Affects the final texture sharpness by reading from a lower or higher mipmap (also called "texture LOD bias"). Negative values make mipmapped textures sharper but grainier when viewed at a distance, while positive values make mipmapped textures blurrier (even when up close). To get sharper textures at a distance without introducing too much graininess, set this between `-0.75` and `0.0`. Enabling temporal antialiasing ({@link ProjectSettings.rendering/anti_aliasing/quality/use_taa}) can help reduce the graininess visible when using negative mipmap bias.
    * **Note:** When the 3D scaling mode is set to FSR 1.0, this value is used to adjust the automatic mipmap bias which is calculated internally based on the scale factor. The formula for this is `-log2(1.0 / scale) + mipmap_bias`.
+   * **Note:** This method is only supported in the Forward+ and Mobile renderers, not Compatibility. In Compatibility, this method is always treated as if `mipmap_bias` was set to `0.0`.
    */
   viewport_set_texture_mipmap_bias(viewport: RID, mipmap_bias: float): void;
   /** If `true`, the viewport renders its background as transparent. */
@@ -2282,6 +2305,8 @@ declare interface RenderingServer extends GodotObject {
   readonly LIGHT_OMNI: int;
   /** Spot light (see {@link SpotLight3D}). */
   readonly LIGHT_SPOT: int;
+  /** Area light (see {@link AreaLight3D}). */
+  readonly LIGHT_AREA: int;
   // enum LightParam
   /** The light's energy multiplier. */
   readonly LIGHT_PARAM_ENERGY: int;
@@ -2471,6 +2496,24 @@ declare interface RenderingServer extends GodotObject {
   readonly PARTICLES_TRANSFORM_ALIGN_Y_TO_VELOCITY: int;
   /** Align each particle's Z axis to face the camera and Y axis to the velocity vector. */
   readonly PARTICLES_TRANSFORM_ALIGN_Z_BILLBOARD_Y_TO_VELOCITY: int;
+  /** Billboard each particles around a local axis. */
+  readonly PARTICLES_TRANSFORM_ALIGN_LOCAL_BILLBOARD: int;
+  // enum ParticlesTransformAlignCustomSrc
+  /** Do not read from CUSTOM when performing billboarding. */
+  readonly PARTICLES_ALIGN_CHANNEL_FILTER_DISABLED: int;
+  /** Read from `CUSTOM.x` when performing billboarding and use it as an angle, in radians. */
+  readonly PARTICLES_ALIGN_CHANNEL_FILTER_X: int;
+  /** Read from `CUSTOM.y` when performing billboarding and use it as an angle, in radians. */
+  readonly PARTICLES_ALIGN_CHANNEL_FILTER_Y: int;
+  /** Read from `CUSTOM.z` when performing billboarding and use it as an angle, in radians. */
+  readonly PARTICLES_ALIGN_CHANNEL_FILTER_Z: int;
+  /** Read from `CUSTOM.w` when performing billboarding and use it as an angle, in radians. */
+  readonly PARTICLES_ALIGN_CHANNEL_FILTER_W: int;
+  // enum ParticlesTransformAlignAxis
+  /** Use the X axis for local billboarding. */
+  readonly PARTICLES_ALIGN_AXIS_X: int;
+  /** Use the Y axis for local billboarding. */
+  readonly PARTICLES_ALIGN_AXIS_Y: int;
   // enum ParticlesDrawOrder
   /** Draw particles in the order that they appear in the particles array. */
   readonly PARTICLES_DRAW_ORDER_INDEX: int;
@@ -2560,6 +2603,11 @@ declare interface RenderingServer extends GodotObject {
    * **Note:** Only supported when the Metal rendering driver is in use, which limits this scaling mode to macOS and iOS.
    */
   readonly VIEWPORT_SCALING_3D_MODE_METALFX_TEMPORAL: int;
+  /**
+   * Use nearest-neighbor filtering for the viewport's 3D buffer. This looks crisper than {@link VIEWPORT_SCALING_3D_MODE_BILINEAR} and has no additional rendering cost. The amount of scaling can be set using {@link Viewport.scaling_3d_scale}. Values greater than `1.0` are not supported and bilinear downsampling will be used instead. A value of `1.0` disables scaling.
+   * **Note:** When using the **Nearest** scaling mode, to avoid uneven pixel scaling, it's highly recommended to use a value equal to an integer divisor with a dividend of `1`. For example, it's best to use a scale of `0.5` (1/2), `0.3333` (1/3), `0.25` (1/4), `0.2` (1/5), and so on.
+   */
+  readonly VIEWPORT_SCALING_3D_MODE_NEAREST: int;
   /** Represents the size of the {@link ViewportScaling3DMode} enum. */
   readonly VIEWPORT_SCALING_3D_MODE_MAX: int;
   // enum ViewportUpdateMode

package/typings/classes/Resource.d.ts

@@ -49,6 +49,8 @@ declare class Resource extends RefCounted {
    * **Example:** Set a random `damage` value to every local resource from an instantiated scene:
    */
   _setup_local_to_scene(): void;
+  /** Copies the data from `resource` into this resource. Both resources must share the same class. */
+  copy_from_resource(resource: Resource): int;
   /**
    * Duplicates this resource, returning a new resource with its `export`ed or {@link PROPERTY_USAGE_STORAGE} properties copied from the original.
    * If `deep` is `false`, a **shallow** copy is returned: nested {@link Array}, {@link Dictionary}, and {@link Resource} properties are not duplicated and are shared with the original resource.

package/typings/classes/ResourceImporterOBJ.d.ts

@@ -23,7 +23,7 @@ declare class ResourceImporterOBJ extends ResourceImporter {
    */
   generate_shadow_mesh: boolean;
   /**
-   * If `true`, generate vertex tangents using Mikktspace (http://www.mikktspace.com/) if the source mesh doesn't have tangent data. When possible, it's recommended to let the 3D modeling software generate tangents on export instead on relying on this option. Tangents are required for correct display of normal and height maps, along with any material/shader features that require tangents.
+   * If `true`, generate vertex tangents using Mikktspace (http://www.mikktspace.com/) if the source mesh doesn't have tangent data. When possible, it's recommended to let the 3D modeling software generate tangents on export instead of relying on this option. Tangents are required for correct display of normal and height maps, along with any material/shader features that require tangents.
    * If you don't need material features that require tangents, disabling this can reduce output file size and speed up importing if the source 3D file doesn't contain tangents.
    */
   generate_tangents: boolean;

package/typings/classes/ResourceImporterScene.d.ts

@@ -25,6 +25,10 @@ declare class ResourceImporterScene extends ResourceImporter {
    * If `true`, trim the beginning and end of animations if there are no keyframe changes. This can reduce output file size and memory usage with certain 3D scenes, depending on the contents of their animation tracks.
    */
   'animation/trimming': boolean;
+  /**
+   * If the 3D model file contains only one mesh, this option has no effect. If `true` and the 3D model file contains multiple meshes with the same surface names and formats, the surfaces will be merged together when the meshes are merged. This is useful for reducing the number of surfaces in the resulting mesh, and avoids duplicating materials. If `false` and the 3D model file contains multiple meshes, the surfaces will always be kept separate.
+   */
+  'array_mesh/deduplicate_surfaces': boolean;
   /**
    * Path to an import script, which can run code after the import process has completed for custom processing. See Using import scripts for automation ($DOCS_URL/tutorials/assets_pipeline/importing_3d_scenes/import_configuration.html#using-import-scripts-for-automation) for more information.
    */
@@ -45,12 +49,16 @@ declare class ResourceImporterScene extends ResourceImporter {
   'materials/extract_format': int;
   /** Path extracted materials are saved to. If empty, source scene path is used. */
   'materials/extract_path': string;
+  /**
+   * If `true`, the mesh names will be set to the names of the nodes in the 3D model file. If `false`, the mesh names will be set to the names of the meshes in the 3D model file. Enabling this is a common work-around when the author of the 3D model file did not properly set the mesh names in Blender or other 3D modeling apps. For example, a file may have a node named "Turret" with a mesh named "Cube.002", so enabling this option will set the mesh name to "Turret" instead of "Cube_002".
+   */
+  'mesh_library/use_node_names_as_mesh_names': boolean;
   /**
    * If `true`, enables the generation of shadow meshes on import. This optimizes shadow rendering without reducing quality by welding vertices together when possible. This in turn reduces the memory bandwidth required to render shadows. Shadow mesh generation currently doesn't support using a lower detail level than the source mesh (but shadow rendering will make use of LODs when relevant).
    */
   'meshes/create_shadow_meshes': boolean;
   /**
-   * If `true`, generate vertex tangents using Mikktspace (http://www.mikktspace.com/) if the input meshes don't have tangent data. When possible, it's recommended to let the 3D modeling software generate tangents on export instead on relying on this option. Tangents are required for correct display of normal and height maps, along with any material/shader features that require tangents.
+   * If `true`, generate vertex tangents using Mikktspace (http://www.mikktspace.com/) if the input meshes don't have tangent data. When possible, it's recommended to let the 3D modeling software generate tangents on export instead of relying on this option. Tangents are required for correct display of normal and height maps, along with any material/shader features that require tangents.
    * If you don't need material features that require tangents, disabling this can reduce output file size and speed up importing if the source 3D file doesn't contain tangents.
    */
   'meshes/ensure_tangents': boolean;
@@ -105,9 +113,9 @@ declare class ResourceImporterScene extends ResourceImporter {
   'nodes/use_node_type_suffixes': boolean;
   /**
    * If checked, use named {@link Skin}s for animation. The {@link MeshInstance3D} node contains 3 properties of relevance here: a skeleton {@link NodePath} pointing to the {@link Skeleton3D} node (usually `..`), a mesh, and a skin:
-   * - The {@link Skeleton3D} node contains a list of bones with names, their pose and rest, a name and a parent bone.
+   * - The {@link Skeleton3D} node contains a list of bones with names, their pose and rest, a name, and a parent bone.
    * - The mesh is all of the raw vertex data needed to display a mesh. In terms of the mesh, it knows how vertices are weight-painted and uses some internal numbering often imported from 3D modeling software.
-   * - The skin contains the information necessary to bind this mesh onto this Skeleton3D. For every one of the internal bone IDs chosen by the 3D modeling software, it contains two things. Firstly, a matrix known as the Bind Pose Matrix, Inverse Bind Matrix, or IBM for short. Secondly, the {@link Skin} contains each bone's name (if {@link skins/use_named_skins} is `true`), or the bone's index within the {@link Skeleton3D} list (if {@link skins/use_named_skins} is `false`).
+   * - The skin contains the information necessary to bind this mesh onto this Skeleton3D. For each of the internal bone IDs chosen by the 3D modeling software, it contains two things. Firstly, a matrix known as the Bind Pose Matrix, Inverse Bind Matrix, or IBM for short. Secondly, the {@link Skin} contains each bone's name (if {@link skins/use_named_skins} is `true`), or the bone's index within the {@link Skeleton3D} list (if {@link skins/use_named_skins} is `false`).
    * Together, this information is enough to tell Godot how to use the bone poses in the {@link Skeleton3D} node to render the mesh from each {@link MeshInstance3D}. Note that each {@link MeshInstance3D} may share binds, as is common in models exported from Blender, or each {@link MeshInstance3D} may use a separate {@link Skin} object, as is common in models exported from other tools such as Maya.
    */
   'skins/use_named_skins': boolean;

package/typings/classes/RichTextLabel.d.ts

@@ -5,6 +5,7 @@
 declare class RichTextLabel extends Control {
   /**
    * If set to something other than {@link TextServer.AUTOWRAP_OFF}, the text gets wrapped inside the node's bounding rectangle.
+   * **Note:** RichTextLabels with autowrapping and {@link fit_content} enabled must have a custom maximum width configured to work correctly, either through the RichTextLabel's own {@link Control.custom_maximum_size} or as a result of a propagated maximum size from a parent Control with {@link Control.propagate_maximum_size} enabled.
    */
   autowrap_mode: int;
   /**
@@ -32,6 +33,7 @@ declare class RichTextLabel extends Control {
   drag_and_drop_selection_enabled: boolean;
   /**
    * If `true`, the label's minimum size will be automatically updated to fit its content, matching the behavior of {@link Label}.
+   * **Note:** RichTextLabels with autowrapping and {@link fit_content} enabled must have a custom maximum width configured to work correctly, either through the RichTextLabel's own {@link Control.custom_maximum_size} or as a result of a propagated maximum size from a parent Control with {@link Control.propagate_maximum_size} enabled.
    */
   fit_content: boolean;
   /**
@@ -175,11 +177,10 @@ declare class RichTextLabel extends Control {
    * If `width` and `height` are not set, but `region` is, the region's rect will be used.
    * `key` is an optional identifier, that can be used to modify the image via {@link update_image}.
    * If `pad` is set, and the image is smaller than the size specified by `width` and `height`, the image padding is added to match the size instead of upscaling.
-   * If `width_in_percent` is set, `width` values are percentages of the control width instead of pixels.
-   * If `height_in_percent` is set, `height` values are percentages of the control width instead of pixels.
+   * Parameters `width_unit` and `height_unit` determine the units used to calculate the image width and height, respectively.
    * `alt_text` is used as the image description for assistive apps.
    */
-  add_image(image: Texture2D, width?: int, height?: int, color?: Color, inline_align?: int, region?: Rect2 | Rect2i, key?: unknown, pad?: boolean, tooltip?: string | NodePath, width_in_percent?: boolean, height_in_percent?: boolean, alt_text?: string | NodePath): void;
+  add_image(image: Texture2D, width?: float, height?: float, color?: Color, inline_align?: int, region?: Rect2 | Rect2i, key?: unknown, pad?: boolean, tooltip?: string | NodePath, width_unit?: int, height_unit?: int, alt_text?: string | NodePath): void;
   /** Adds raw non-BBCode-parsed text to the tag stack. */
   add_text(text: string | NodePath): void;
   /**
@@ -462,7 +463,7 @@ declare class RichTextLabel extends Control {
   /**
    * Updates the existing images with the key `key`. Only properties specified by `mask` bits are updated. See {@link add_image}.
    */
-  update_image(key: unknown, mask: int, image: Texture2D, width?: int, height?: int, color?: Color, inline_align?: int, region?: Rect2 | Rect2i, pad?: boolean, tooltip?: string | NodePath, width_in_percent?: boolean, height_in_percent?: boolean): void;
+  update_image(key: unknown, mask: int, image: Texture2D, width?: float, height?: float, color?: Color, inline_align?: int, region?: Rect2 | Rect2i, pad?: boolean, tooltip?: string | NodePath, width_unit?: int, height_unit?: int): void;
 
   /**
    * Triggered when the document is fully loaded.
@@ -519,6 +520,13 @@ declare class RichTextLabel extends Control {
   static readonly UPDATE_PAD: int;
   /** If this bit is set, {@link update_image} changes image tooltip. */
   static readonly UPDATE_TOOLTIP: int;
-  /** If this bit is set, {@link update_image} changes image width from/to percents. */
-  static readonly UPDATE_WIDTH_IN_PERCENT: int;
+  /** If this bit is set, {@link update_image} changes the units used to calculate image size. */
+  static readonly UPDATE_WIDTH_UNIT: int;
+  // enum ImageUnit
+  /** Images drawn with this unit will be in pixels. */
+  static readonly IMAGE_UNIT_PIXEL: int;
+  /** Images drawn with this unit will be in percentages of the control width. */
+  static readonly IMAGE_UNIT_PERCENT: int;
+  /** Images drawn with this unit will be in percentages of the surrounding font size. */
+  static readonly IMAGE_UNIT_EM: int;
 }

package/typings/classes/SceneTree.d.ts

@@ -93,8 +93,18 @@ declare class SceneTree extends MainLoop {
    * Calls the given `method` on each node inside this tree added to the given `group`. Use `flags` to customize this method's behavior (see {@link GroupCallFlags}). Additional arguments for `method` can be passed at the end of this method. Nodes that cannot call `method` (either because the method doesn't exist or the arguments do not match) are ignored.
    * **Note:** In C#, `method` must be in snake_case when referring to built-in Godot methods. Prefer using the names exposed in the `MethodName` class to avoid allocating a new {@link StringName} on each call.
    */
-  call_group_flags(flags: int, group: GodotGroupNames, method: string, ...args: any[]): void;
-  call_group_flags(flags: int, group: string, method: string, ...args: any[]): void;
+  call_group_flags(
+  flags: int,
+  group: GodotGroupNames,
+  method: string,
+  ...args: any[]
+  ): void;
+  call_group_flags(
+  flags: int,
+  group: string,
+  method: string,
+  ...args: any[]
+  ): void;
   /**
    * Changes the running scene to the one at the given `path`, after loading it into a {@link PackedScene} and creating a new instance.
    * Returns {@link OK} on success, {@link ERR_CANT_OPEN} if the `path` cannot be loaded into a {@link PackedScene}, or {@link ERR_CANT_CREATE} if that scene cannot be instantiated.
@@ -174,7 +184,11 @@ declare class SceneTree extends MainLoop {
   /**
    * Calls {@link Object.notification} with the given `notification` to all nodes inside this tree added to the `group`. Use `call_flags` to customize this method's behavior (see {@link GroupCallFlags}).
    */
-  notify_group_flags(call_flags: int, group: GodotGroupNames, notification: int): void;
+  notify_group_flags(
+  call_flags: int,
+  group: GodotGroupNames,
+  notification: int,
+  ): void;
   notify_group_flags(call_flags: int, group: string, notification: int): void;
   /**
    * Queues the given `obj` to be deleted, calling its {@link Object.free} at the end of the current frame. This method is similar to {@link Node.queue_free}.
@@ -202,8 +216,18 @@ declare class SceneTree extends MainLoop {
    * Sets the given `property` to `value` on all nodes inside this tree added to the given `group`. Nodes that do not have the `property` are ignored. Use `call_flags` to customize this method's behavior (see {@link GroupCallFlags}).
    * **Note:** In C#, `property` must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the `PropertyName` class to avoid allocating a new {@link StringName} on each call.
    */
-  set_group_flags(call_flags: int, group: GodotGroupNames, property: string, value: unknown): void;
-  set_group_flags(call_flags: int, group: string, property: string, value: unknown): void;
+  set_group_flags(
+  call_flags: int,
+  group: GodotGroupNames,
+  property: string,
+  value: unknown,
+  ): void;
+  set_group_flags(
+  call_flags: int,
+  group: string,
+  property: string,
+  value: unknown,
+  ): void;
   /**
    * Sets a custom {@link MultiplayerAPI} with the given `root_path` (controlling also the relative subpaths), or override the default one if `root_path` is empty.
    * **Note:** No {@link MultiplayerAPI} must be configured for the subpath containing `root_path`, nested custom multiplayers are not allowed. I.e. if one is configured for `"/root/Foo"` setting one for `"/root/Foo/Bar"` will cause an error.

package/typings/classes/Script.d.ts

@@ -44,6 +44,8 @@ declare class Script extends Resource {
    * **Note:** The dictionaries returned by this method are formatted identically to those returned by {@link Object.get_signal_list}.
    */
   get_script_signal_list(): Array<Dictionary>;
+  /** Returns `true` if the script, or a base class, defines a method with the given name. */
+  has_script_method(method_name: string): boolean;
   /** Returns `true` if the script, or a base class, defines a signal with the given name. */
   has_script_signal(signal_name: string): boolean;
   /**

package/typings/classes/ScriptEditor.d.ts

@@ -8,6 +8,11 @@ declare class ScriptEditor extends PanelContainer {
    * **Note:** This should be called whenever the script is changed to keep the open documentation state up to date.
    */
   clear_docs_from_script(script: Script): void;
+  /**
+   * Closes the file at the given `path`, discarding any unsaved changes.
+   * Returns {@link OK} on success or {@link ERR_FILE_NOT_FOUND} if the file is not found.
+   */
+  close_file(path: string | NodePath): int;
   /** Returns array of breakpoints. */
   get_breakpoints(): PackedStringArray;
   /** Returns the {@link ScriptEditorBase} object that the user is currently editing. */
@@ -18,6 +23,8 @@ declare class ScriptEditor extends PanelContainer {
   get_open_script_editors(): Array<ScriptEditorBase>;
   /** Returns an array with all {@link Script} objects which are currently open in editor. */
   get_open_scripts(): Array<Script>;
+  /** Returns an array of file paths of scripts with unsaved changes open in the editor. */
+  get_unsaved_files(): PackedStringArray;
   /**
    * Opens help for the given topic. The `topic` is an encoded string that controls which class, method, constant, signal, annotation, property, or theme item should be focused.
    * The supported `topic` formats include `class_name:class`, `class_method:class:method`, `class_constant:class:constant`, `class_signal:class:signal`, `class_annotation:class:@annotation`, `class_property:class:property`, and `class_theme_item:class:item`, where `class` is the class name, `method` is the method name, `constant` is the constant name, `signal` is the signal name, `annotation` is the annotation name, `property` is the property name, and `item` is the theme item.

package/typings/classes/ScriptLanguageExtension.d.ts

@@ -55,7 +55,13 @@ declare class ScriptLanguageExtension extends ScriptLanguage {
   _profiling_start(): void;
   _profiling_stop(): void;
   _reload_all_scripts(): void;
+  /**
+   * Reloads all `scripts` from disk and the specifics of how that happens is {@link ScriptLanguageExtension} specific.
+   */
   _reload_scripts(scripts: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array, soft_reload: boolean): void;
+  /**
+   * Reloads the given `script` from disk and the specifics of how that happens is {@link ScriptLanguageExtension} specific.
+   */
   _reload_tool_script(script: Script, soft_reload: boolean): void;
   _remove_named_global_constant(name: string): void;
   _supports_builtin_mode(): boolean;
@@ -106,5 +112,6 @@ declare class ScriptLanguageExtension extends ScriptLanguage {
   static readonly CODE_COMPLETION_KIND_NODE_PATH: int;
   static readonly CODE_COMPLETION_KIND_FILE_PATH: int;
   static readonly CODE_COMPLETION_KIND_PLAIN_TEXT: int;
+  static readonly CODE_COMPLETION_KIND_KEYWORD: int;
   static readonly CODE_COMPLETION_KIND_MAX: int;
 }

package/typings/classes/ScrollContainer.d.ts

@@ -14,8 +14,11 @@ declare class ScrollContainer extends Container {
   follow_focus: boolean;
   /** Controls whether horizontal scrollbar can be used and when it should be visible. */
   horizontal_scroll_mode: int;
-  /** Deadzone for touch scrolling. Lower deadzone makes the scrolling more sensitive. */
-  scroll_deadzone: int;
+  /**
+   * <member name="scroll_deadzone" type="int" setter="set_deadzone" getter="get_deadzone" default="0">
+   * Deadzone for touch scrolling. Lower deadzone makes the scrolling more sensitive.
+   */
+  propagate_maximum_size: boolean;
   /**
    * The way which scroll hints (indicators that show that the content can still be scrolled in a certain direction) will be shown.
    * **Note:** Hints won't be shown if the content can be scrolled both vertically and horizontally.
@@ -26,6 +29,11 @@ declare class ScrollContainer extends Container {
    * **Note:** If you are setting this value in the {@link Node._ready} function or earlier, it needs to be wrapped with {@link Object.set_deferred}, since scroll bar's {@link Range.max_value} is not initialized yet.
    */
   scroll_horizontal: int;
+  /**
+   * If `true`, the mouse wheel scrolls the view horizontally, and holding `Shift` scrolls vertically.
+   * If `false` (default), the mouse wheel scrolls the view vertically, and holding `Shift` scrolls horizontally.
+   */
+  scroll_horizontal_by_default: boolean;
   /**
    * Overrides the {@link ScrollBar.custom_step} used when clicking the internal scroll bar's horizontal increment and decrement buttons or when using arrow keys when the {@link ScrollBar} is focused.
    */
@@ -49,12 +57,12 @@ declare class ScrollContainer extends Container {
   is_following_focus(): boolean;
   set_horizontal_scroll_mode(value: int): void;
   get_horizontal_scroll_mode(): int;
-  set_deadzone(value: int): void;
-  get_deadzone(): int;
   set_scroll_hint_mode(value: int): void;
   get_scroll_hint_mode(): int;
   set_h_scroll(value: int): void;
   get_h_scroll(): int;
+  set_scroll_horizontal_by_default(value: boolean): void;
+  is_scroll_horizontal_by_default(): boolean;
   set_horizontal_custom_step(value: float): void;
   get_horizontal_custom_step(): float;
   set_v_scroll(value: int): void;
@@ -88,7 +96,7 @@ declare class ScrollContainer extends Container {
    */
   scroll_ended: Signal<[]>;
   /**
-   * Emitted when scrolling starts when dragging the scrollable area w*ith a touch event*. This signal is *not* emitted when scrolling by dragging the scrollbar, scrolling with the mouse wheel or scrolling with keyboard/gamepad events.
+   * Emitted when scrolling starts when dragging the scrollable area *with a touch event*. This signal is *not* emitted when scrolling by dragging the scrollbar, scrolling with the mouse wheel or scrolling with keyboard/gamepad events.
    * **Note:** This signal is only emitted on Android or iOS, or on desktop/web platforms when {@link ProjectSettings.input_devices/pointing/emulate_touch_from_mouse} is enabled.
    */
   scroll_started: Signal<[]>;
@@ -108,6 +116,10 @@ declare class ScrollContainer extends Container {
    * Combines {@link SCROLL_MODE_AUTO} and {@link SCROLL_MODE_SHOW_ALWAYS}. The scrollbar is only visible if necessary, but the content size is adjusted as if it was always visible. It's useful for ensuring that content size stays the same regardless if the scrollbar is visible.
    */
   static readonly SCROLL_MODE_RESERVE: int;
+  /**
+   * Behaves like {@link SCROLL_MODE_AUTO}, but makes the {@link ScrollContainer} report a minimum size based on its content (limited by {@link Control.custom_maximum_size} when set on the corresponding axis). This allows it to grow first and only start scrolling once constrained.
+   */
+  static readonly SCROLL_MODE_MAXIMIZE_FIRST: int;
   // enum ScrollHintMode
   /** Scroll hints will never be shown. */
   static readonly SCROLL_HINT_MODE_DISABLED: int;

package/typings/classes/SkeletonModification2DJiggle.d.ts

@@ -66,6 +66,10 @@ declare class SkeletonModification2DJiggle extends SkeletonModification2D {
   get_jiggle_joint_use_gravity(joint_idx: int): boolean;
   /** Returns whether the jiggle modifier is taking physics colliders into account when solving. */
   get_use_colliders(): boolean;
+  /**
+   * Resets the internal jiggle simulation state to the current bone positions, clearing velocity, acceleration, and accumulated forces.
+   */
+  reset(): void;
   /**
    * Sets the collision mask that the Jiggle modifier will use when reacting to colliders, if the Jiggle modifier is set to take colliders into account.
    */

package/typings/classes/SpringBoneSimulator3D.d.ts

@@ -221,7 +221,8 @@ declare class SpringBoneSimulator3D extends SkeletonModifier3D {
   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.
+   * The axes are based on the reference pose's space, if `axis` is {@link SkeletonModifier3D.ROTATION_AXIS_CUSTOM}, you can specify any axis.
+   * In here, the reference pose is the bone pose immediately before the simulation.
    * **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;
@@ -248,7 +249,8 @@ declare class SpringBoneSimulator3D extends SkeletonModifier3D {
   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.
+   * The axes are based on the reference pose's space, if `axis` is {@link SkeletonModifier3D.ROTATION_AXIS_CUSTOM}, you can specify any axis.
+   * In here, the reference pose is the bone pose immediately before the simulation.
    * **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;