typescript-to-gdscript 0.1.0

package/typings/classes/ResourceImporterScene.d.ts

@@ -0,0 +1,114 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Imports a glTF, FBX, COLLADA, or Blender 3D scene. */
+declare class ResourceImporterScene extends ResourceImporter {
+  /**
+   * Contains properties for the scene's subresources. This is an internal option which is not visible in the Import dock.
+   */
+  _subresources: Dictionary;
+  /**
+   * The number of frames per second to use for baking animation curves to a series of points with linear interpolation. It's recommended to configure this value to match the value you're using as a baseline in your 3D modeling software. Higher values result in more precise animation with fast movement changes, at the cost of higher file sizes and memory usage. Thanks to interpolation, there is usually not much benefit in going above 30 FPS (as the animation will still appear smooth at higher rendering framerates).
+   */
+  'animation/fps': float;
+  /** If `true`, import animations from the 3D scene. */
+  'animation/import': boolean;
+  /**
+   * If `true`, adds an {@link Animation} named `RESET`, containing the {@link Skeleton3D.get_bone_rest} from {@link Skeleton3D} nodes. This can be useful to extract an animation in the reference pose.
+   */
+  'animation/import_rest_as_RESET': boolean;
+  /**
+   * If `true`, remove animation tracks that only contain default values. This can reduce output file size and memory usage with certain 3D scenes, depending on the contents of their animation tracks.
+   */
+  'animation/remove_immutable_tracks': boolean;
+  /**
+   * 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;
+  /**
+   * 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.
+   */
+  'import_script/path': string;
+  /**
+   * Material extraction mode.
+   * - `0 (Keep Internal)`, materials are not extracted.
+   * - `1 (Extract Once)`, materials are extracted once and reused on subsequent import.
+   * - `2 (Extract and Overwrite)`, materials are extracted and overwritten on every import.
+   */
+  'materials/extract': int;
+  /**
+   * Extracted material file format.
+   * - `0 (Text)`, text file format (`*.tres`).
+   * - `1 (Binary)`, binary file format (`*.res`).
+   * - `2 (Material)`, binary file format (`*.material`).
+   */
+  'materials/extract_format': int;
+  /** Path extracted materials are saved to. If empty, source scene path is used. */
+  'materials/extract_path': string;
+  /**
+   * 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 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;
+  /**
+   * If `true`, mesh compression will not be used. Consider enabling if you notice blocky artifacts in your mesh normals or UVs, or if you have meshes that are larger than a few thousand meters in each direction.
+   */
+  'meshes/force_disable_compression': boolean;
+  /**
+   * If `true`, generates lower detail variants of the mesh which will be displayed in the distance to improve rendering performance. Not all meshes benefit from LOD, especially if they are never rendered from far away. Disabling this can reduce output file size and speed up importing. See Mesh level of detail (LOD) ($DOCS_URL/tutorials/3d/mesh_lod.html#doc-mesh-lod) for more information.
+   */
+  'meshes/generate_lods': boolean;
+  /**
+   * Configures the meshes' {@link GeometryInstance3D.gi_mode} in the 3D scene. If set to **Static Lightmaps**, sets the meshes' GI mode to Static and generates UV2 on import for {@link LightmapGI} baking.
+   */
+  'meshes/light_baking': int;
+  /**
+   * Controls the size of each texel on the baked lightmap. A smaller value results in more precise lightmaps, at the cost of larger lightmap sizes and longer bake times.
+   * **Note:** Only effective if {@link meshes/light_baking} is set to **Static Lightmaps**.
+   */
+  'meshes/lightmap_texel_size': float;
+  /**
+   * If `true`, {@link nodes/root_scale} will be applied to the descendant nodes, meshes, animations, bones, etc. This means that if you add a child node later on within the imported scene, it won't be scaled. If `false`, {@link nodes/root_scale} will multiply the scale of the root node instead.
+   */
+  'nodes/apply_root_scale': boolean;
+  /**
+   * Treat all nodes in the imported scene as if they are bones within a single {@link Skeleton3D}. Can be used to guarantee that imported animations target skeleton bones rather than nodes. May also be used to assign the `"Root"` bone in a {@link BoneMap}. See Retargeting 3D Skeletons ($DOCS_URL/tutorials/assets_pipeline/retargeting_3d_skeletons.html) for more information.
+   */
+  'nodes/import_as_skeleton_bones': boolean;
+  /**
+   * Override for the root node name. If empty, the root node will use what the scene specifies, or the file name if the scene does not specify a root name.
+   */
+  'nodes/root_name': string;
+  /**
+   * The uniform scale to use for the scene root. The default value of `1.0` will not perform any rescaling. See {@link nodes/apply_root_scale} for details of how this scale is applied.
+   */
+  'nodes/root_scale': float;
+  /**
+   * If set to a valid script, attaches the script to the root node of the imported scene. If the type of the root node is not compatible with the script, the root node will be replaced with a type that is compatible with the script. This setting can also be used on other non-mesh nodes in the scene to attach scripts to them.
+   */
+  'nodes/root_script': Script | null;
+  /**
+   * Override for the root node type. If empty, the root node will use what the scene specifies, or {@link Node3D} if the scene does not specify a root type. Using a node type that inherits from {@link Node3D} is recommended. Otherwise, you'll lose the ability to position the node directly in the 3D editor.
+   */
+  'nodes/root_type': string;
+  /**
+   * If `true`, will use suffixes in the names of imported objects such as nodes and resources to determine types and properties, such as `-noimp` to skip import of a node or animation, `-alpha` to enable alpha transparency on a material, and `-vcol` to enable vertex colors on a material. Disabling this makes editor-imported files more similar to the original files, and more similar to files imported at runtime. See Node type customization using name suffixes ($DOCS_URL/tutorials/assets_pipeline/importing_3d_scenes/node_type_customization.html) for more information.
+   */
+  'nodes/use_name_suffixes': boolean;
+  /**
+   * If `true`, will use suffixes in the node names to determine the node type, such as `-col` for collision shapes. This is only used when {@link nodes/use_name_suffixes} is `true`. Disabling this makes editor-imported files more similar to the original files, and more similar to files imported at runtime. See Node type customization using name suffixes ($DOCS_URL/tutorials/assets_pipeline/importing_3d_scenes/node_type_customization.html) for more information.
+   */
+  '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 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`).
+   * 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/ResourceImporterShaderFile.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Imports native GLSL shaders (not Godot shaders) as an {@link RDShaderFile}. */
+declare class ResourceImporterShaderFile extends ResourceImporter {
+}

package/typings/classes/ResourceImporterTexture.d.ts

@@ -0,0 +1,188 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Imports an image for use in 2D or 3D rendering. */
+declare class ResourceImporterTexture extends ResourceImporter {
+  /**
+   * Controls how color channels should be used in the imported texture.
+   * **sRGB Friendly:** Prevents the R and RG color formats from being used, as they do not support nonlinear sRGB encoding.
+   * **Optimized:** Allows the RG color format to be used if the texture does not use the blue channel. This reduces memory usage if the texture's blue channel can be discarded (all pixels must have a blue value of `0`).
+   */
+  'compress/channel_pack': int;
+  /**
+   * Controls how VRAM compression should be performed for HDR images.
+   * **Disabled:** Never use VRAM compression for HDR textures, regardless of whether they're opaque or transparent. Instead, the texture is converted to RGBE9995 (9-bits per channel + 5-bit exponent = 32 bits per pixel) to reduce memory usage compared to a half-float or single-precision float image format.
+   * **Opaque Only:** Only uses VRAM compression for opaque HDR textures. This is due to a limitation of HDR formats, as there is no VRAM-compressed HDR format that supports transparency at the same time.
+   * **Always:** Force VRAM compression even for HDR textures with an alpha channel. To perform this, the alpha channel is discarded on import.
+   * **Note:** Only effective on Radiance HDR (`.hdr`) and OpenEXR (`.exr`) images.
+   */
+  'compress/hdr_compression': int;
+  /**
+   * If `true`, uses BPTC compression on desktop platforms and ASTC compression on mobile platforms. When using BPTC, BC7 is used for SDR textures and BC6H is used for HDR textures.
+   * If `false`, uses the faster but lower-quality S3TC compression on desktop platforms and ETC2 on mobile/web platforms. When using S3TC, DXT1 (BC1) is used for opaque textures and DXT5 (BC3) is used for transparent or normal map (RGTC) textures.
+   * BPTC and ASTC support VRAM compression for HDR textures, but S3TC and ETC2 do not (see {@link compress/hdr_compression}).
+   */
+  'compress/high_quality': boolean;
+  /**
+   * The quality to use when using the **Lossy** compression mode. Higher values result in better quality, at the cost of larger file sizes. Lossy quality does not affect memory usage of the imported texture, only its file size on disk.
+   */
+  'compress/lossy_quality': float;
+  /**
+   * The compression mode to use. Each compression mode provides a different tradeoff:
+   * **Lossless**: Original quality, high memory usage, high size on disk, fast import.
+   * **Lossy:** Reduced quality, high memory usage, low size on disk, fast import.
+   * **VRAM Compressed:** Reduced quality, low memory usage, low size on disk, slowest import. Only use for textures in 3D scenes, not for 2D elements.
+   * **VRAM Uncompressed:** Original quality, high memory usage, highest size on disk, fastest import.
+   * **Basis Universal:** Reduced quality, low memory usage, lowest size on disk, slow import. Only use for textures in 3D scenes, not for 2D elements.
+   * See Compress mode ($DOCS_URL/tutorials/assets_pipeline/importing_images.html#compress-mode) in the manual for more details.
+   */
+  'compress/mode': int;
+  /**
+   * When using a texture as normal map, only the red and green channels are required. Given regular texture compression algorithms produce artifacts that don't look that nice in normal maps, the RGTC compression format is the best fit for this data. Forcing this option to Enable will make Godot import the image as RGTC compressed. By default, it's set to Detect. This means that if the texture is ever detected to be used as a normal map, it will be changed to Enable and reimported automatically.
+   * Note that RGTC compression affects the resulting normal map image. You will have to adjust custom shaders that use the normal map's blue channel to take this into account. Built-in material shaders already ignore the blue channel in a normal map (regardless of the actual normal map's contents).
+   */
+  'compress/normal_map': int;
+  /**
+   * If greater than or equal to `0.01`, enables Rate-Distortion Optimization (RDO) to reduce file size. Higher values result in smaller file sizes but lower quality.
+   * **Note:** Enabling RDO makes encoding times significantly longer, especially when the image is large.
+   * See also {@link ProjectSettings.rendering/textures/basis_universal/rdo_dict_size} and {@link ProjectSettings.rendering/textures/basis_universal/zstd_supercompression_level} if you want to reduce the file size further.
+   */
+  'compress/rdo_quality_loss': float;
+  /** The UASTC encoding level. Higher values result in better quality but make encoding times longer. */
+  'compress/uastc_level': int;
+  /**
+   * This changes the {@link compress/mode} option that is used when a texture is detected as being used in 3D.
+   * Changing this import option only has an effect if a texture is detected as being used in 3D. Changing this to **Disabled** then reimporting will not change the existing compress mode on a texture (if it's detected to be used in 3D), but choosing **VRAM Compressed** or **Basis Universal** will.
+   */
+  'detect_3d/compress_to': int;
+  /**
+   * If `true`, converts the imported image's colors to match {@link EditorSettings.interface/theme/icon_and_font_color}. This assumes the image uses the exact same colors as Godot's own color palette for editor icons ($DOCS_URL/engine_details/editor/creating_icons.html), with the source file designed for a dark editor theme. This should be enabled for editor plugin icons and custom class icons, but should be left disabled otherwise.
+   * **Note:** Only available for SVG images.
+   */
+  'editor/convert_colors_with_editor_theme': boolean;
+  /**
+   * If `true`, scales the imported image to match {@link EditorSettings.interface/editor/appearance/custom_display_scale}. This should be enabled for editor plugin icons and custom class icons, but should be left disabled otherwise.
+   * **Note:** Only available for SVG images.
+   */
+  'editor/scale_with_editor_scale': boolean;
+  /**
+   * If `true`, smaller versions of the texture are generated on import. For example, a 64×64 texture will generate 6 mipmaps (32×32, 16×16, 8×8, 4×4, 2×2, 1×1). This has several benefits:
+   * - Textures will not become grainy in the distance (in 3D), or if scaled down due to {@link Camera2D} zoom or {@link CanvasItem} scale (in 2D).
+   * - Performance will improve if the texture is displayed in the distance, since sampling smaller versions of the original texture is faster and requires less memory bandwidth.
+   * The downside of mipmaps is that they increase memory usage by roughly 33%.
+   * It's recommended to enable mipmaps in 3D. However, in 2D, this should only be enabled if your project visibly benefits from having mipmaps enabled. If the camera never zooms out significantly, there won't be a benefit to enabling mipmaps but memory usage will increase.
+   */
+  'mipmaps/generate': boolean;
+  /** Unimplemented. This currently has no effect when changed. */
+  'mipmaps/limit': int;
+  /**
+   * Specifies the data source of the output image's alpha channel.
+   * **Red:** Use the values from the source image's red channel.
+   * **Green:** Use the values from the source image's green channel.
+   * **Blue:** Use the values from the source image's blue channel.
+   * **Alpha:** Use the values from the source image's alpha channel.
+   * **Red Inverted:** Use inverted values from the source image's red channel (`1.0 - R`).
+   * **Green Inverted:** Use inverted values from the source image's green channel (`1.0 - G`).
+   * **Blue Inverted:** Use inverted values from the source image's blue channel (`1.0 - B`).
+   * **Alpha Inverted:** Use inverted values from the source image's alpha channel (`1.0 - A`).
+   * **Unused:** Set the color channel's value to the default (`1.0` for alpha, `0.0` for red, green or blue).
+   * **Zero:** Set the color channel's value to `0.0`.
+   * **One:** Set the color channel's value to `1.0`.
+   */
+  'process/channel_remap/alpha': int;
+  /**
+   * Specifies the data source of the output image's blue channel.
+   * **Red:** Use the values from the source image's red channel.
+   * **Green:** Use the values from the source image's green channel.
+   * **Blue:** Use the values from the source image's blue channel.
+   * **Alpha:** Use the values from the source image's alpha channel.
+   * **Red Inverted:** Use inverted values from the source image's red channel (`1.0 - R`).
+   * **Green Inverted:** Use inverted values from the source image's green channel (`1.0 - G`).
+   * **Blue Inverted:** Use inverted values from the source image's blue channel (`1.0 - B`).
+   * **Alpha Inverted:** Use inverted values from the source image's alpha channel (`1.0 - A`).
+   * **Unused:** Set the color channel's value to the default (`1.0` for alpha, `0.0` for red, green or blue).
+   * **Zero:** Set the color channel's value to `0.0`.
+   * **One:** Set the color channel's value to `1.0`.
+   */
+  'process/channel_remap/blue': int;
+  /**
+   * Specifies the data source of the output image's green channel.
+   * **Red:** Use the values from the source image's red channel.
+   * **Green:** Use the values from the source image's green channel.
+   * **Blue:** Use the values from the source image's blue channel.
+   * **Alpha:** Use the values from the source image's alpha channel.
+   * **Red Inverted:** Use inverted values from the source image's red channel (`1.0 - R`).
+   * **Green Inverted:** Use inverted values from the source image's green channel (`1.0 - G`).
+   * **Blue Inverted:** Use inverted values from the source image's blue channel (`1.0 - B`).
+   * **Alpha Inverted:** Use inverted values from the source image's alpha channel (`1.0 - A`).
+   * **Unused:** Set the color channel's value to the default (`1.0` for alpha, `0.0` for red, green or blue).
+   * **Zero:** Set the color channel's value to `0.0`.
+   * **One:** Set the color channel's value to `1.0`.
+   */
+  'process/channel_remap/green': int;
+  /**
+   * Specifies the data source of the output image's red channel.
+   * **Red:** Use the values from the source image's red channel.
+   * **Green:** Use the values from the source image's green channel.
+   * **Blue:** Use the values from the source image's blue channel.
+   * **Alpha:** Use the values from the source image's alpha channel.
+   * **Red Inverted:** Use inverted values from the source image's red channel (`1.0 - R`).
+   * **Green Inverted:** Use inverted values from the source image's green channel (`1.0 - G`).
+   * **Blue Inverted:** Use inverted values from the source image's blue channel (`1.0 - B`).
+   * **Alpha Inverted:** Use inverted values from the source image's alpha channel (`1.0 - A`).
+   * **Unused:** Set the color channel's value to the default (`1.0` for alpha, `0.0` for red, green or blue).
+   * **Zero:** Set the color channel's value to `0.0`.
+   * **One:** Set the color channel's value to `1.0`.
+   */
+  'process/channel_remap/red': int;
+  /**
+   * If `true`, puts pixels of the same surrounding color in transition from transparent to opaque areas. For textures displayed with bilinear filtering, this helps to reduce the outline effect when exporting images from an image editor.
+   * It's recommended to leave this enabled (as it is by default), unless this causes issues for a particular image.
+   */
+  'process/fix_alpha_border': boolean;
+  /**
+   * Some HDR images you can find online may be broken and contain data that is encoded using the nonlinear sRGB transfer function (instead of using linear encoding). It is advised not to use those files. If you absolutely have to, enabling {@link process/hdr_as_srgb} will make them look correct.
+   * **Warning:** Enabling {@link process/hdr_as_srgb} on well-formatted HDR images will cause the resulting image to look too dark, so leave this on `false` if unsure.
+   */
+  'process/hdr_as_srgb': boolean;
+  /**
+   * If `true`, clamps exposure in the imported high dynamic range images using a smart clamping formula (without introducing *visible* clipping).
+   * Some HDR panorama images you can find online may contain extremely bright pixels, due to being taken from real life sources without any clipping.
+   * While these HDR panorama images are accurate to real life, this can cause the radiance map generated by Godot to contain sparkles when used as a background sky. This can be seen in material reflections (even on rough materials in extreme cases). Enabling {@link process/hdr_clamp_exposure} can resolve this.
+   */
+  'process/hdr_clamp_exposure': boolean;
+  /**
+   * If `true`, convert the normal map from Y- (DirectX-style) to Y+ (OpenGL-style) by inverting its green color channel. This is the normal map convention expected by Godot.
+   * More information about normal maps (including a coordinate order table for popular engines) can be found here (http://wiki.polycount.com/wiki/Normal_Map_Technical_Details).
+   */
+  'process/normal_map_invert_y': boolean;
+  /**
+   * An alternative to fixing darkened borders with {@link process/fix_alpha_border} is to use premultiplied alpha. By enabling this option, the texture will be converted to this format. A premultiplied alpha texture requires specific materials to be displayed correctly:
+   * - In 2D, a {@link CanvasItemMaterial} will need to be created and configured to use the {@link CanvasItemMaterial.BLEND_MODE_PREMULT_ALPHA} blend mode on {@link CanvasItem}s that use this texture. In custom `canvas_item` shaders, `render_mode blend_premul_alpha;` should be used.
+   * - In 3D, a {@link BaseMaterial3D} will need to be created and configured to use the {@link BaseMaterial3D.BLEND_MODE_PREMULT_ALPHA} blend mode on materials that use this texture. In custom `spatial` shaders, `render_mode blend_premul_alpha;` should be used.
+   */
+  'process/premult_alpha': boolean;
+  /**
+   * If set to a value greater than `0`, the size of the texture is limited on import to a value smaller than or equal to the value specified here. For non-square textures, the size limit affects the longer dimension, with the shorter dimension scaled to preserve aspect ratio. Resizing is performed using cubic interpolation.
+   * This can be used to reduce memory usage without affecting the source images, or avoid issues with textures not displaying on mobile/web platforms (as these usually can't display textures larger than 4096×4096).
+   * **Note:** Even if this is set to `0`, import size is limited to the following dimensions for technical reasons. Depending on {@link compress/mode}, textures will be downsampled on import if necessary:
+   * - **Lossy:** 16383 pixels width or height, whichever is larger;
+   * - **Basis Universal:** 16384 pixels width or height, whichever is larger;
+   * - **All other modes:** 32768 pixels width or height, whichever is larger.
+   */
+  'process/size_limit': int;
+  /**
+   * The color channel to consider as a roughness map in this texture. Only effective if {@link roughness/src_normal} is not empty.
+   */
+  'roughness/mode': int;
+  /**
+   * The path to the texture to consider as a normal map for roughness filtering on import. Specifying this can help decrease specular aliasing slightly in 3D.
+   * Roughness filtering on import is only used in 3D rendering, not 2D.
+   */
+  'roughness/src_normal': string;
+  /**
+   * The scale the SVG should be rendered at, with `1.0` being the original design size. Higher values result in a larger image. Note that unlike font oversampling, this affects the size the SVG is rendered at in 2D. See also {@link editor/scale_with_editor_scale}.
+   * **Note:** Only available for SVG images.
+   */
+  'svg/scale': float;
+}

package/typings/classes/ResourceImporterTextureAtlas.d.ts

@@ -0,0 +1,27 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Imports a collection of textures from a PNG image into an optimized {@link AtlasTexture} for 2D rendering.
+ */
+declare class ResourceImporterTextureAtlas extends ResourceImporter {
+  /**
+   * Path to the atlas spritesheet. This *must* be set to valid path to a PNG image. Otherwise, the atlas will fail to import.
+   */
+  atlas_file: string;
+  /**
+   * If `true`, discards empty areas from the atlas. This only affects final sprite positioning, not storage. See also {@link trim_alpha_border_from_region}.
+   * **Note:** Only effective if {@link import_mode} is **Region**.
+   */
+  crop_to_region: boolean;
+  /**
+   * **Region:** Imports the atlas in an {@link AtlasTexture} resource, which is rendered as a rectangle. This is fast to render, but transparent areas still have to be rendered if they can't be trimmed effectively by {@link trim_alpha_border_from_region}. This can reduce performance when rendering large sprites on screen.
+   * **Mesh:** Imports the atlas as an {@link ArrayMesh} resource, keeping the original bitmap visible (but rendered as a polygon). This can be used to reduce fill rate when rendering large transparent sprites, at the cost of slower rendering if there are little to no transparent areas in the sprite.
+   */
+  import_mode: int;
+  /**
+   * If `true`, trims the region to exclude fully transparent pixels using a clipping rectangle (which is never rotated). This can be used to save memory. See also {@link crop_to_region}.
+   * **Note:** Only effective if {@link import_mode} is **Region**.
+   */
+  trim_alpha_border_from_region: boolean;
+}

package/typings/classes/ResourceImporterWAV.d.ts

@@ -0,0 +1,57 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Imports a WAV audio file for playback. */
+declare class ResourceImporterWAV extends ResourceImporter {
+  /**
+   * The compression mode to use on import.
+   * - **PCM (Uncompressed):** Imports audio data without any form of compression, preserving the highest possible quality. It has the lowest CPU cost, but the highest memory usage.
+   * - **IMA ADPCM:** Applies fast, lossy compression during import, noticeably decreasing the quality, but with low CPU cost and memory usage. Does not support seeking and only Forward loop mode is supported.
+   * - **Quite OK Audio (https://qoaformat.org/):** Also applies lossy compression on import, having a slightly higher CPU cost compared to IMA ADPCM, but much higher quality and the lowest memory usage.
+   */
+  'compress/mode': int;
+  /**
+   * The begin loop point to use when {@link edit/loop_mode} is **Forward**, **Ping-Pong**, or **Backward**. This is set in samples after the beginning of the audio file.
+   */
+  'edit/loop_begin': int;
+  /**
+   * The end loop point to use when {@link edit/loop_mode} is **Forward**, **Ping-Pong**, or **Backward**. This is set in samples after the beginning of the audio file. A value of `-1` uses the end of the audio file as the end loop point.
+   */
+  'edit/loop_end': int;
+  /**
+   * Controls how audio should loop.
+   * - **Detect From WAV:** Uses loop information from the WAV metadata.
+   * - **Disabled:** Don't loop audio, even if the metadata indicates the file playback should loop.
+   * - **Forward:** Standard audio looping. Plays the audio forward from the beginning to {@link edit/loop_end}, then returns to {@link edit/loop_begin} and repeats.
+   * - **Ping-Pong:** Plays the audio forward until {@link edit/loop_end}, then backwards to {@link edit/loop_begin}, repeating this cycle.
+   * - **Backward:** Plays the audio backwards from {@link edit/loop_end} to {@link edit/loop_begin}, then repeats.
+   * **Note:** In {@link AudioStreamPlayer}, the {@link AudioStreamPlayer.finished} signal won't be emitted for looping audio when it reaches the end of the audio file, as the audio will keep playing indefinitely.
+   */
+  'edit/loop_mode': int;
+  /**
+   * If `true`, normalize the audio volume so that its peak volume is equal to 0 dB. When enabled, normalization will make audio sound louder depending on its original peak volume.
+   */
+  'edit/normalize': boolean;
+  /**
+   * If `true`, automatically trim the beginning and end of the audio if it's lower than -50 dB after normalization (see {@link edit/normalize}). This prevents having files with silence at the beginning or end, which increases their size unnecessarily and adds latency to the moment they are played back. A fade-in/fade-out period of 500 samples is also used during trimming to avoid audible pops.
+   */
+  'edit/trim': boolean;
+  /**
+   * If `true`, forces the imported audio to use 8-bit quantization if the source file is 16-bit or higher.
+   * Enabling this is generally not recommended, as 8-bit quantization decreases audio quality significantly. If you need smaller file sizes, consider using Ogg Vorbis or MP3 audio instead.
+   */
+  'force/8_bit': boolean;
+  /**
+   * If set to a value greater than `0`, forces the audio's sample rate to be reduced to a value lower than or equal to the value specified in {@link force/max_rate_hz}.
+   * This can decrease file size noticeably on certain sounds, without impacting quality depending on the actual sound's contents. See Best practices ($DOCS_URL/tutorials/assets_pipeline/importing_audio_samples.html#doc-importing-audio-samples-best-practices) for more information.
+   */
+  'force/max_rate': boolean;
+  /**
+   * The frequency to limit the imported audio sample to (in Hz). Only effective if {@link force/max_rate} is `true`.
+   */
+  'force/max_rate_hz': float;
+  /**
+   * If `true`, forces the imported audio to be mono if the source file is stereo. This decreases the file size by 50% by merging the two channels into one.
+   */
+  'force/mono': boolean;
+}

package/typings/classes/ResourceLoader.d.ts

@@ -0,0 +1,106 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A singleton for loading resource files. */
+declare interface ResourceLoader extends GodotObject {
+  /**
+   * Registers a new {@link ResourceFormatLoader}. The ResourceLoader will use the ResourceFormatLoader as described in {@link load}.
+   * This method is performed implicitly for ResourceFormatLoaders written in GDScript (see {@link ResourceFormatLoader} for more information).
+   */
+  add_resource_format_loader(format_loader: ResourceFormatLoader, at_front?: boolean): void;
+  /**
+   * Returns whether a recognized resource exists for the given `path`.
+   * An optional `type_hint` can be used to further specify the {@link Resource} type that should be handled by the {@link ResourceFormatLoader}. Anything that inherits from {@link Resource} can be used as a type hint, for example {@link Image}.
+   * **Note:** If you use {@link Resource.take_over_path}, this method will return `true` for the taken path even if the resource wasn't saved (i.e. exists only in resource cache).
+   */
+  exists(path: string | NodePath, type_hint?: string | NodePath): boolean;
+  /**
+   * Returns the cached resource reference for the given `path`.
+   * **Note:** If the resource is not cached, the returned {@link Resource} will be invalid.
+   */
+  get_cached_ref(path: string | NodePath): Resource | null;
+  /**
+   * Returns the dependencies for the resource at the given `path`.
+   * Each dependency is a string that can be divided into sections by `::`. There can be either one section or three sections, with the second section always being empty. When there is one section, it contains the file path. When there are three sections, the first section contains the UID and the third section contains the fallback path.
+   */
+  get_dependencies(path: string | NodePath): PackedStringArray;
+  /** Returns the list of recognized extensions for a resource type. */
+  get_recognized_extensions_for_type(type_: string | NodePath): PackedStringArray;
+  /** Returns the ID associated with a given resource path, or `-1` when no such ID exists. */
+  get_resource_uid(path: string | NodePath): int;
+  /**
+   * Returns whether a cached resource is available for the given `path`.
+   * Once a resource has been loaded by the engine, it is cached in memory for faster access, and future calls to the {@link load} method will use the cached version. The cached resource can be overridden by using {@link Resource.take_over_path} on a new resource for that same path.
+   */
+  has_cached(path: string | NodePath): boolean;
+  /**
+   * Lists a directory, returning all resources and subdirectories contained within. The resource files have the original file names as visible in the editor before exporting. The directories have `"/"` appended.
+   * **Note:** The order of files and directories returned by this method is not deterministic, and can vary between operating systems.
+   * **Note:** To normally traverse the filesystem, see {@link DirAccess}.
+   */
+  list_directory(directory_path: string | NodePath): PackedStringArray;
+  /**
+   * Loads a resource at the given `path`, caching the result for further access.
+   * The registered {@link ResourceFormatLoader}s are queried sequentially to find the first one which can handle the file's extension, and then attempt loading. If loading fails, the remaining ResourceFormatLoaders are also attempted.
+   * An optional `type_hint` can be used to further specify the {@link Resource} type that should be handled by the {@link ResourceFormatLoader}. Anything that inherits from {@link Resource} can be used as a type hint, for example {@link Image}.
+   * The `cache_mode` property defines whether and how the cache should be used or updated when loading the resource.
+   * Returns an empty resource if no {@link ResourceFormatLoader} could handle the file, and prints an error if no file is found at the specified path.
+   * GDScript has a simplified {@link @GDScript.load} built-in method which can be used in most situations, leaving the use of {@link ResourceLoader} for more advanced scenarios.
+   * **Note:** If {@link ProjectSettings.editor/export/convert_text_resources_to_binary} is `true`, {@link @GDScript.load} will not be able to read converted files in an exported project. If you rely on run-time loading of files present within the PCK, set {@link ProjectSettings.editor/export/convert_text_resources_to_binary} to `false`.
+   * **Note:** Relative paths will be prefixed with `"res://"` before loading, to avoid unexpected results make sure your paths are absolute.
+   */
+  load(path: string | NodePath, type_hint?: string | NodePath, cache_mode?: int): Resource | null;
+  /**
+   * Returns the resource loaded by {@link load_threaded_request}.
+   * If this is called before the loading thread is done (i.e. {@link load_threaded_get_status} is not {@link THREAD_LOAD_LOADED}), the calling thread will be blocked until the resource has finished loading. However, it's recommended to use {@link load_threaded_get_status} to known when the load has actually completed.
+   */
+  load_threaded_get(path: string | NodePath): Resource | null;
+  /**
+   * Returns the status of a threaded loading operation started with {@link load_threaded_request} for the resource at `path`.
+   * An array variable can optionally be passed via `progress`, and will return a one-element array containing the ratio of completion of the threaded loading (between `0.0` and `1.0`).
+   * **Note:** The recommended way of using this method is to call it during different frames (e.g., in {@link Node._process}, instead of a loop).
+   */
+  load_threaded_get_status(path: string | NodePath, progress?: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): int;
+  /**
+   * Loads the resource using threads. If `use_sub_threads` is `true`, multiple threads will be used to load the resource, which makes loading faster, but may affect the main thread (and thus cause game slowdowns).
+   * The `cache_mode` parameter defines whether and how the cache should be used or updated when loading the resource.
+   */
+  load_threaded_request(path: string | NodePath, type_hint?: string | NodePath, use_sub_threads?: boolean, cache_mode?: int): int;
+  /** Unregisters the given {@link ResourceFormatLoader}. */
+  remove_resource_format_loader(format_loader: ResourceFormatLoader): void;
+  /** Changes the behavior on missing sub-resources. The default behavior is to abort loading. */
+  set_abort_on_missing_resources(abort: boolean): void;
+
+  // enum ThreadLoadStatus
+  /** The resource is invalid, or has not been loaded with {@link load_threaded_request}. */
+  readonly THREAD_LOAD_INVALID_RESOURCE: int;
+  /** The resource is still being loaded. */
+  readonly THREAD_LOAD_IN_PROGRESS: int;
+  /** Some error occurred during loading and it failed. */
+  readonly THREAD_LOAD_FAILED: int;
+  /** The resource was loaded successfully and can be accessed via {@link load_threaded_get}. */
+  readonly THREAD_LOAD_LOADED: int;
+  // enum CacheMode
+  /**
+   * Neither the main resource (the one requested to be loaded) nor any of its subresources are retrieved from cache nor stored into it. Dependencies (external resources) are loaded with {@link CACHE_MODE_REUSE}.
+   */
+  readonly CACHE_MODE_IGNORE: int;
+  /**
+   * The main resource (the one requested to be loaded), its subresources, and its dependencies (external resources) are retrieved from cache if present, instead of loaded. Those not cached are loaded and then stored into the cache. The same rules are propagated recursively down the tree of dependencies (external resources).
+   */
+  readonly CACHE_MODE_REUSE: int;
+  /**
+   * Like {@link CACHE_MODE_REUSE}, but the cache is checked for the main resource (the one requested to be loaded) as well as for each of its subresources. Those already in the cache, as long as the loaded and cached types match, have their data refreshed from storage into the already existing instances. Otherwise, they are recreated as completely new objects.
+   */
+  readonly CACHE_MODE_REPLACE: int;
+  /**
+   * Like {@link CACHE_MODE_IGNORE}, but propagated recursively down the tree of dependencies (external resources).
+   */
+  readonly CACHE_MODE_IGNORE_DEEP: int;
+  /**
+   * Like {@link CACHE_MODE_REPLACE}, but propagated recursively down the tree of dependencies (external resources).
+   */
+  readonly CACHE_MODE_REPLACE_DEEP: int;
+}
+declare const ResourceLoader: ResourceLoader;
+

package/typings/classes/ResourcePreloader.d.ts

@@ -0,0 +1,20 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node used to preload sub-resources inside a scene. */
+declare class ResourcePreloader extends Node {
+  /**
+   * Adds a resource to the preloader with the given `name`. If a resource with the given `name` already exists, the new resource will be renamed to "`name` N" where N is an incrementing number starting from 2.
+   */
+  add_resource(name: string, resource: Resource): void;
+  /** Returns the resource associated to `name`. */
+  get_resource(name: string): Resource | null;
+  /** Returns the list of resources inside the preloader. */
+  get_resource_list(): PackedStringArray;
+  /** Returns `true` if the preloader contains a resource associated to `name`. */
+  has_resource(name: string): boolean;
+  /** Removes the resource associated to `name` from the preloader. */
+  remove_resource(name: string): void;
+  /** Renames a resource inside the preloader from `name` to `newname`. */
+  rename_resource(name: string, newname: string): void;
+}

package/typings/classes/ResourceSaver.d.ts

@@ -0,0 +1,53 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A singleton for saving {@link Resource}s to the filesystem. */
+declare interface ResourceSaver extends GodotObject {
+  /**
+   * Registers a new {@link ResourceFormatSaver}. The ResourceSaver will use the ResourceFormatSaver as described in {@link save}.
+   * This method is performed implicitly for ResourceFormatSavers written in GDScript (see {@link ResourceFormatSaver} for more information).
+   */
+  add_resource_format_saver(format_saver: ResourceFormatSaver, at_front?: boolean): void;
+  /** Returns the list of extensions available for saving a resource of a given type. */
+  get_recognized_extensions(type_: Resource): PackedStringArray;
+  /**
+   * Returns the resource ID for the given path. If `generate` is `true`, a new resource ID will be generated if one for the path is not found. If `generate` is `false` and the path is not found, {@link ResourceUID.INVALID_ID} is returned.
+   */
+  get_resource_id_for_path(path: string | NodePath, generate?: boolean): int;
+  /** Unregisters the given {@link ResourceFormatSaver}. */
+  remove_resource_format_saver(format_saver: ResourceFormatSaver): void;
+  /**
+   * Saves a resource to disk to the given path, using a {@link ResourceFormatSaver} that recognizes the resource object. If `path` is empty, {@link ResourceSaver} will try to use {@link Resource.resource_path}.
+   * The `flags` bitmask can be specified to customize the save behavior.
+   * Returns {@link OK} on success.
+   * **Note:** When the project is running, any generated UID associated with the resource will not be saved as the required code is only executed in editor mode.
+   */
+  save(resource: Resource, path?: string | NodePath, flags?: int): int;
+  /**
+   * Sets the UID of the given `resource` path to `uid`. You can generate a new UID using {@link ResourceUID.create_id}.
+   * Since resources will normally get a UID automatically, this method is only useful in very specific cases.
+   */
+  set_uid(resource: string | NodePath, uid: int): int;
+
+  // enum SaverFlags
+  /** No resource saving option. */
+  readonly FLAG_NONE: int;
+  /** Save the resource with a path relative to the scene which uses it. */
+  readonly FLAG_RELATIVE_PATHS: int;
+  /** Bundles external resources. */
+  readonly FLAG_BUNDLE_RESOURCES: int;
+  /** Changes the {@link Resource.resource_path} of the saved resource to match its new location. */
+  readonly FLAG_CHANGE_PATH: int;
+  /** Do not save editor-specific metadata (identified by their `__editor` prefix). */
+  readonly FLAG_OMIT_EDITOR_PROPERTIES: int;
+  /** Save as big endian (see {@link FileAccess.big_endian}). */
+  readonly FLAG_SAVE_BIG_ENDIAN: int;
+  /**
+   * Compress the resource on save using {@link FileAccess.COMPRESSION_ZSTD}. Only available for binary resource types.
+   */
+  readonly FLAG_COMPRESS: int;
+  /** Take over the paths of the saved subresources (see {@link Resource.take_over_path}). */
+  readonly FLAG_REPLACE_SUBRESOURCE_PATHS: int;
+}
+declare const ResourceSaver: ResourceSaver;
+