@ringozz/godot 0.1.0

package/gen/classes/ImageFormatLoader.ts

@@ -0,0 +1,31 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+
+/**
+ * The engine supports multiple image formats out of the box (PNG, SVG, JPEG, WebP to name a few), but you can choose to implement support for additional image formats by extending {@link ImageFormatLoaderExtension}.
+ */
+export class ImageFormatLoader extends RefCounted {
+
+    static readonly name = _R(339, ImageFormatLoader);
+}
+
+export const LoaderFlags = {
+    /**
+     * Default loading behavior. No processing is applied to the image.
+     */
+    FLAG_NONE: 0,
+    /**
+     * If set, the image is converted from sRGB to linear encoding.
+     */
+    FLAG_FORCE_LINEAR: 1,
+    /**
+     * If set, a predefined color map is applied to the image. Used when {@link ResourceImporterTexture.editor/convertColorsWithEditorTheme} is `true`.
+     */
+    FLAG_CONVERT_COLORS: 2,
+} as const;
+
+export type LoaderFlags = (typeof LoaderFlags)[keyof typeof LoaderFlags];
+

package/gen/classes/ImageFormatLoaderExtension.ts

@@ -0,0 +1,30 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { ImageFormatLoader } from './ImageFormatLoader.ts';
+import type { Error } from '../global-enums.ts';
+import type { PackedStringArray } from '../heap-types/index.ts';
+import type { FileAccess } from './FileAccess.ts';
+import type { Image } from './Image.ts';
+import type { LoaderFlags } from './ImageFormatLoader.ts';
+
+/**
+ * The engine supports multiple image formats out of the box (PNG, SVG, JPEG, WebP to name a few), but you can choose to implement support for additional image formats by extending this class.
+ * Be sure to respect the documented return types and values. You should create an instance of it, and call {@link addFormatLoader} to register that loader during the initialization phase.
+ */
+export class ImageFormatLoaderExtension extends ImageFormatLoader {
+    constructor(name = 340) { super(name); }
+
+    /**
+     * Add this format loader to the engine, allowing it to recognize the file extensions returned by {@link _getRecognizedExtensions}.
+     */
+    addFormatLoader(): void { _C(this, 1221); }
+
+    /**
+     * Remove this format loader from the engine.
+     */
+    removeFormatLoader(): void { _C(this, 9913); }
+
+    static readonly name = _R(340, ImageFormatLoaderExtension);
+}

package/gen/classes/ImageTexture.ts

@@ -0,0 +1,73 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture2D } from './Texture2D.ts';
+import type { Vector2i } from '../value-types/index.ts';
+import type { Image } from './Image.ts';
+
+/**
+ * A {@link Texture2D} based on an {@link Image}. For an image to be displayed, an {@link ImageTexture} has to be created from it using the {@link createFromImage} method:
+ *
+ * ```text
+ *
+ * var image = Image.load_from_file("res://icon.svg")
+ * var texture = ImageTexture.create_from_image(image)
+ * $Sprite2D.texture = texture
+ *
+ * ```
+ *
+ * This way, textures can be created at run-time by loading images both from within the editor and externally.
+ * **Warning:** Prefer to load imported textures with `@GDScript.load` over loading them from within the filesystem dynamically with {@link Image.load}, as it may not work in exported projects:
+ *
+ * ```text
+ *
+ * var texture = load("res://icon.svg")
+ * $Sprite2D.texture = texture
+ *
+ * ```
+ *
+ * This is because images have to be imported as a {@link CompressedTexture2D} first to be loaded with `@GDScript.load`. If you'd still like to load an image file just like any other {@link Resource}, import it as an {@link Image} resource instead, and then load it normally using the `@GDScript.load` method.
+ * **Note:** The image can be retrieved from an imported texture using the {@link Texture2D.getImage} method, which returns a copy of the image:
+ *
+ * ```text
+ *
+ * var texture = load("res://icon.svg")
+ * var image = texture.get_image()
+ *
+ * ```
+ *
+ * An {@link ImageTexture} is not meant to be operated from within the editor interface directly, and is mostly useful for rendering images on screen dynamically via code. If you need to generate images procedurally from within the editor, consider saving and importing images as custom texture resources implementing a new {@link EditorImportPlugin}.
+ * **Note:** The maximum texture size is 16384×16384 pixels due to graphics hardware limitations.
+ */
+export class ImageTexture extends Texture2D {
+    constructor(name = 341) { super(name); }
+
+    /**
+     * Creates a new {@link ImageTexture} and initializes it by allocating and setting the data from an {@link Image}.
+     */
+    static createFromImage(image: Image): ImageTexture { return _C(341, 2533, image) as ImageTexture; }
+
+    /**
+     * Replaces the texture's data with a new {@link Image}. This will re-allocate new memory for the texture.
+     * If you want to update the image, but don't need to change its parameters (format, size), use {@link update} instead for better performance.
+     */
+    setImage(image: Image): void { _C(this, 11670, image); }
+
+    /**
+     * Replaces the texture's data with a new {@link Image}.
+     * **Note:** The texture has to be created using {@link createFromImage} or initialized first with the {@link setImage} method before it can be updated. The new image dimensions, format, and mipmaps configuration should match the existing texture's image configuration.
+     * Use this method over {@link setImage} if you need to update the texture frequently, which is faster than allocating additional memory for a new texture each time.
+     */
+    update(image: Image): void { _C(this, 14502, image); }
+
+    /**
+     * Resizes the texture to the specified dimensions.
+     */
+    setSizeOverride(size: Vector2i): void { _C(this, 12756, size); }
+
+    get image(): Image { return _C(this, 5071) as Image; }
+    set image(v: Image) { _C(this, 1029, v); }
+
+    static readonly name = _R(341, ImageTexture);
+}

package/gen/classes/ImageTexture3D.ts

@@ -0,0 +1,29 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture3D } from './Texture3D.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray } from '../heap-types/index.ts';
+import type { Format } from './AudioStreamWAV.ts';
+import type { Image } from './Image.ts';
+
+/**
+ * {@link ImageTexture3D} is a 3-dimensional {@link ImageTexture} that has a width, height, and depth. See also {@link ImageTextureLayered}.
+ * 3D textures are typically used to store density maps for {@link FogMaterial}, color correction LUTs for {@link Environment}, vector fields for {@link GPUParticlesAttractorVectorField3D} and collision maps for {@link GPUParticlesCollisionSDF3D}. 3D textures can also be used in custom shaders.
+ */
+export class ImageTexture3D extends Texture3D {
+    constructor(name = 342) { super(name); }
+
+    /**
+     * Creates the {@link ImageTexture3D} with specified `format`, `width`, `height`, and `depth`. If `useMipmaps` is `true`, generates mipmaps for the {@link ImageTexture3D}.
+     */
+    create(format: Format, width: number, height: number, depth: number, useMipmaps: boolean, data: GodotArray<Image>): Error { return _C(this, 2506, format, width, height, depth, useMipmaps, data) as Error; }
+
+    /**
+     * Replaces the texture's existing data with the layers specified in `data`. The size of `data` must match the parameters that were used for {@link create}. In other words, the texture cannot be resized or have its format changed by calling {@link update}.
+     */
+    update(data: GodotArray<Image>): void { _C(this, 14502, data); }
+
+    static readonly name = _R(342, ImageTexture3D);
+}

package/gen/classes/ImageTextureLayered.ts

@@ -0,0 +1,66 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { TextureLayered } from './TextureLayered.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray } from '../heap-types/index.ts';
+import type { Image } from './Image.ts';
+
+/**
+ * Base class for {@link Texture2DArray}, {@link Cubemap} and {@link CubemapArray}. Cannot be used directly, but contains all the functions necessary for accessing the derived resource types. See also {@link Texture3D}.
+ */
+export class ImageTextureLayered extends TextureLayered {
+
+    /**
+     * Creates an {@link ImageTextureLayered} from an array of {@link Image}s. See {@link Image.create} for the expected data format. The first image decides the width, height, image format and mipmapping setting. The other images *must* have the same width, height, image format and mipmapping setting.
+     * Each {@link Image} represents one `layer`.
+     *
+     * ```text
+     *
+     * # Fill in an array of Images with different colors.
+     * var images = []
+     * const LAYERS = 6
+     * for i in LAYERS:
+     * 	var image = Image.create_empty(128, 128, false, Image.FORMAT_RGB8)
+     * 	if i % 3 == 0:
+     * 		image.fill(Color.RED)
+     * 	elif i % 3 == 1:
+     * 		image.fill(Color.GREEN)
+     * 	else:
+     * 		image.fill(Color.BLUE)
+     * 	images.push_back(image)
+     *
+     * # Create and save a 2D texture array. The array of images must have at least 1 Image.
+     * var texture_2d_array = Texture2DArray.new()
+     * texture_2d_array.create_from_images(images)
+     * ResourceSaver.save(texture_2d_array, "res://texture_2d_array.res", ResourceSaver.FLAG_COMPRESS)
+     *
+     * # Create and save a cubemap. The array of images must have exactly 6 Images.
+     * # The cubemap's images are specified in this order: X+, X-, Y+, Y-, Z+, Z-
+     * # (in Godot's coordinate system, so Y+ is "up" and Z- is "forward").
+     * var cubemap = Cubemap.new()
+     * cubemap.create_from_images(images)
+     * ResourceSaver.save(cubemap, "res://cubemap.res", ResourceSaver.FLAG_COMPRESS)
+     *
+     * # Create and save a cubemap array. The array of images must have a multiple of 6 Images.
+     * # Each cubemap's images are specified in this order: X+, X-, Y+, Y-, Z+, Z-
+     * # (in Godot's coordinate system, so Y+ is "up" and Z- is "forward").
+     * var cubemap_array = CubemapArray.new()
+     * cubemap_array.create_from_images(images)
+     * ResourceSaver.save(cubemap_array, "res://cubemap_array.res", ResourceSaver.FLAG_COMPRESS)
+     *
+     * ```
+     */
+    createFromImages(images: GodotArray<Image>): Error { return _C(this, 2535, images) as Error; }
+
+    /**
+     * Replaces the existing {@link Image} data at the given `layer` with this new image.
+     * The given {@link Image} must have the same width, height, image format, and mipmapping flag as the rest of the referenced images.
+     * If the image format is unsupported, it will be decompressed and converted to a similar and supported {@link Image.Format}.
+     * The update is immediate: it's synchronized with drawing.
+     */
+    updateLayer(image: Image, layer: number): void { _C(this, 14518, image, layer); }
+
+    static readonly name = _R(343, ImageTextureLayered);
+}

package/gen/classes/ImmediateMesh.ts

@@ -0,0 +1,85 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Mesh } from './Mesh.ts';
+import type { Color, Plane, Vector2, Vector3 } from '../value-types/index.ts';
+import type { Material } from './Material.ts';
+import type { PrimitiveType } from './Mesh.ts';
+
+/**
+ * A mesh type optimized for creating geometry manually, similar to OpenGL 1.x immediate mode.
+ * Here's a sample on how to generate a triangular face:
+ *
+ *
+ * ```gdscript
+ *
+ * var mesh = ImmediateMesh.new()
+ * mesh.surface_begin(Mesh.PRIMITIVE_TRIANGLES)
+ * mesh.surface_add_vertex(Vector3.LEFT)
+ * mesh.surface_add_vertex(Vector3.FORWARD)
+ * mesh.surface_add_vertex(Vector3.ZERO)
+ * mesh.surface_end()
+ *
+ * ```
+ *
+ *
+ *
+ * **Note:** Generating complex geometries with {@link ImmediateMesh} is highly inefficient. Instead, it is designed to generate simple geometry that changes often.
+ */
+export class ImmediateMesh extends Mesh {
+    constructor(name = 344) { super(name); }
+
+    /**
+     * Begin a new surface.
+     */
+    surfaceBegin(primitive: PrimitiveType, material?: Material /* = null */): void { _C(this, 14025, primitive, material); }
+
+    /**
+     * Set the color attribute that will be pushed with the next vertex.
+     */
+    surfaceSetColor(color: Color): void { _C(this, 14038, color); }
+
+    /**
+     * Set the normal attribute that will be pushed with the next vertex.
+     */
+    surfaceSetNormal(normal: Vector3): void { _C(this, 14041, normal); }
+
+    /**
+     * Set the tangent attribute that will be pushed with the next vertex.
+     * **Note:** Even though `tangent` is a {@link Plane}, it does not directly represent the tangent plane. Its {@link Plane.x}, {@link Plane.y}, and {@link Plane.z} represent the tangent vector and {@link Plane.d} should be either `-1` or `1`. See also {@link Mesh.ARRAY_TANGENT}.
+     */
+    surfaceSetTangent(tangent: Plane): void { _C(this, 14042, tangent); }
+
+    /**
+     * Set the UV attribute that will be pushed with the next vertex.
+     */
+    surfaceSetUv(uv: Vector2): void { _C(this, 14043, uv); }
+
+    /**
+     * Set the UV2 attribute that will be pushed with the next vertex.
+     */
+    surfaceSetUv2(uv2: Vector2): void { _C(this, 14044, uv2); }
+
+    /**
+     * Add a 3D vertex using the current attributes previously set.
+     */
+    surfaceAddVertex(vertex: Vector3): void { _C(this, 14023, vertex); }
+
+    /**
+     * Add a 2D vertex using the current attributes previously set.
+     */
+    surfaceAddVertex2d(vertex: Vector2): void { _C(this, 14024, vertex); }
+
+    /**
+     * End and commit current surface. Note that surface being created will not be visible until this function is called.
+     */
+    surfaceEnd(): void { _C(this, 14026); }
+
+    /**
+     * Clear all surfaces.
+     */
+    clearSurfaces(): void { _C(this, 2300); }
+
+    static readonly name = _R(344, ImmediateMesh);
+}

package/gen/classes/ImporterMesh.ts

@@ -0,0 +1,159 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { GodotArray, GodotDictionary, PackedInt32Array } from '../heap-types/index.ts';
+import type { Transform3D, Vector2i } from '../value-types/index.ts';
+import type { ArrayMesh } from './ArrayMesh.ts';
+import type { Material } from './Material.ts';
+import type { BlendShapeMode, Mesh, PrimitiveType } from './Mesh.ts';
+
+/**
+ * ImporterMesh is a type of {@link Resource} analogous to {@link ArrayMesh}. It contains vertex array-based geometry, divided in *surfaces*. Each surface contains a completely separate array and a material used to draw it. Design wise, a mesh with multiple surfaces is preferred to a single surface, because objects created in 3D editing software commonly contain multiple materials.
+ * Unlike its runtime counterpart, {@link ImporterMesh} contains mesh data before various import steps, such as LOD and shadow mesh generation, have taken place. Modify surface data by calling {@link clear}, followed by {@link addSurface} for each surface.
+ */
+export class ImporterMesh extends Resource {
+    constructor(name = 345) { super(name); }
+
+    /**
+     * Merges multiple {@link ImporterMesh}es into a single {@link ImporterMesh}. Each input mesh is transformed by the corresponding {@link Transform3D} in the `relativeTransforms` array, which must be the same size as `importerMeshes`. Negative scales are supported, and the winding order in the mesh data will be corrected to account for this.
+     * If `deduplicateSurfaces` is `true` and multiple meshes have surfaces with the same names and formats, the surfaces will be merged together when the meshes are merged, and will use the material from the first matching surface. This is useful for reducing the number of surfaces in the resulting mesh, and avoids duplicating materials. Surfaces with bone weights will never be deduplicated. If `deduplicateSurfaces` is `false`, the surfaces will always be kept separate, and will be given unique names.
+     * **Warning:** Blend shapes and LODs are not supported and will be discarded. Do not use this function to discard blend shapes and LODs, as support for these may be added in the future.
+     */
+    static mergeImporterMeshes(importerMeshes: GodotArray<ImporterMesh>, relativeTransforms: GodotArray<Transform3D>, deduplicateSurfaces?: boolean /* = true */): ImporterMesh { return _C(345, 8852, importerMeshes, relativeTransforms, deduplicateSurfaces) as ImporterMesh; }
+
+    /**
+     * Adds name for a blend shape that will be added with {@link addSurface}. Must be called before surface is added.
+     */
+    addBlendShape(name: string): void { _C(this, 1185, name); }
+
+    /**
+     * Returns the number of blend shapes that the mesh holds.
+     */
+    getBlendShapeCount(): number { return _C(this, 3938) as number; }
+
+    /**
+     * Returns the name of the blend shape at this index.
+     */
+    getBlendShapeName(blendShapeIdx: number): string { return _C(this, 3940, blendShapeIdx) as string; }
+
+    /**
+     * Sets the blend shape mode.
+     */
+    setBlendShapeMode(mode: BlendShapeMode): void { _C(this, 10682, mode); }
+
+    /**
+     * Returns the blend shape mode for this Mesh.
+     */
+    getBlendShapeMode(): BlendShapeMode { return _C(this, 3939) as BlendShapeMode; }
+
+    /**
+     * Creates a new surface. {@link Mesh.getSurfaceCount} will become the `surf_idx` for this new surface.
+     * Surfaces are created to be rendered using a `primitive`, which may be any of the values defined in {@link Mesh.PrimitiveType}.
+     * The `arrays` argument is an array of arrays. Each of the {@link Mesh.ARRAY_MAX} elements contains an array with some of the mesh data for this surface as described by the corresponding member of {@link Mesh.ArrayType} or `null` if it is not used by the surface. For example, `arrays[0]` is the array of vertices. That first vertex sub-array is always required; the others are optional. Adding an index array puts this surface into "index mode" where the vertex and other arrays become the sources of data and the index array defines the vertex order. All sub-arrays must have the same length as the vertex array (or be an exact multiple of the vertex array's length, when multiple elements of a sub-array correspond to a single vertex) or be empty, except for {@link Mesh.ARRAY_INDEX} if it is used.
+     * The `blendShapes` argument is an array of vertex data for each blend shape. Each element is an array of the same structure as `arrays`, but {@link Mesh.ARRAY_VERTEX}, {@link Mesh.ARRAY_NORMAL}, and {@link Mesh.ARRAY_TANGENT} are set if and only if they are set in `arrays` and all other entries are `null`.
+     * The `lods` argument is a dictionary with {@link float} keys and {@link PackedInt32Array} values. Each entry in the dictionary represents an LOD level of the surface, where the value is the {@link Mesh.ARRAY_INDEX} array to use for the LOD level and the key is roughly proportional to the distance at which the LOD stats being used. I.e., increasing the key of an LOD also increases the distance that the objects has to be from the camera before the LOD is used.
+     * The `flags` argument is the bitwise OR of, as required: One value of {@link Mesh.ArrayCustomFormat} left shifted by `ARRAY_FORMAT_CUSTOMn_SHIFT` for each custom channel in use, {@link Mesh.ARRAY_FLAG_USE_DYNAMIC_UPDATE}, {@link Mesh.ARRAY_FLAG_USE_8_BONE_WEIGHTS}, or {@link Mesh.ARRAY_FLAG_USES_EMPTY_VERTEX_ARRAY}.
+     * **Note:** When using indices, it is recommended to only use points, lines, or triangles.
+     */
+    addSurface(primitive: PrimitiveType, arrays: GodotArray, blendShapes?: GodotArray<GodotArray> /* = Array[Array]([]) */, lods?: GodotDictionary /* = {} */, material?: Material /* = null */, name?: string /* = "" */, flags?: number /* = 0,  uint64 */): void { _C(this, 1301, primitive, arrays, blendShapes, lods, material, name, flags); }
+
+    /**
+     * Returns the number of surfaces that the mesh holds.
+     */
+    getSurfaceCount(): number { return _C(this, 6625) as number; }
+
+    /**
+     * Returns the primitive type of the requested surface (see {@link addSurface}).
+     */
+    getSurfacePrimitiveType(surfaceIdx: number): PrimitiveType { return _C(this, 6635, surfaceIdx) as PrimitiveType; }
+
+    /**
+     * Gets the name assigned to this surface.
+     */
+    getSurfaceName(surfaceIdx: number): string { return _C(this, 6632, surfaceIdx) as string; }
+
+    /**
+     * Returns the arrays for the vertices, normals, UVs, etc. that make up the requested surface. See {@link addSurface}.
+     */
+    getSurfaceArrays(surfaceIdx: number): GodotArray { return _C(this, 6623, surfaceIdx) as GodotArray; }
+
+    /**
+     * Returns a single set of blend shape arrays for the requested blend shape index for a surface.
+     */
+    getSurfaceBlendShapeArrays(surfaceIdx: number, blendShapeIdx: number): GodotArray { return _C(this, 6624, surfaceIdx, blendShapeIdx) as GodotArray; }
+
+    /**
+     * Returns the number of lods that the mesh holds on a given surface.
+     */
+    getSurfaceLodCount(surfaceIdx: number): number { return _C(this, 6628, surfaceIdx) as number; }
+
+    /**
+     * Returns the screen ratio which activates a lod for a surface.
+     */
+    getSurfaceLodSize(surfaceIdx: number, lodIdx: number): number { return _C(this, 6630, surfaceIdx, lodIdx) as number; }
+
+    /**
+     * Returns the index buffer of a lod for a surface.
+     */
+    getSurfaceLodIndices(surfaceIdx: number, lodIdx: number): PackedInt32Array { return _C(this, 6629, surfaceIdx, lodIdx) as PackedInt32Array; }
+
+    /**
+     * Returns a {@link Material} in a given surface. Surface is rendered using this material.
+     */
+    getSurfaceMaterial(surfaceIdx: number): Material { return _C(this, 6631, surfaceIdx) as Material; }
+
+    /**
+     * Returns the format of the surface that the mesh holds.
+     */
+    getSurfaceFormat(surfaceIdx: number): number { return _C(this, 6626, surfaceIdx) as number; }
+
+    /**
+     * Sets a name for a given surface.
+     */
+    setSurfaceName(surfaceIdx: number, name: string): void { _C(this, 12940, surfaceIdx, name); }
+
+    /**
+     * Sets a {@link Material} for a given surface. Surface will be rendered using this material.
+     */
+    setSurfaceMaterial(surfaceIdx: number, material: Material): void { _C(this, 12939, surfaceIdx, material); }
+
+    /**
+     * Generates all lods for this ImporterMesh.
+     * `normalMergeAngle` is in degrees and used in the same way as the importer settings in `lods`.
+     * `normalSplitAngle` is not used and only remains for compatibility with older versions of the API.
+     * The number of generated lods can be accessed using {@link getSurfaceLodCount}, and each LOD is available in {@link getSurfaceLodSize} and {@link getSurfaceLodIndices}.
+     * `boneTransformArray` is an {@link Array} which can be either empty or contain {@link Transform3D}s which, for each of the mesh's bone IDs, will apply mesh skinning when generating the LOD mesh variations. This is usually used to account for discrepancies in scale between the mesh itself and its skinning data.
+     */
+    generateLods(normalMergeAngle: number, normalSplitAngle: number, boneTransformArray: GodotArray): void { _C(this, 3631, normalMergeAngle, normalSplitAngle, boneTransformArray); }
+
+    /**
+     * Returns the mesh data represented by this {@link ImporterMesh} as a usable {@link ArrayMesh}.
+     * This method caches the returned mesh, and subsequent calls will return the cached data until {@link clear} is called.
+     * If not yet cached and `baseMesh` is provided, `baseMesh` will be used and mutated.
+     */
+    getMesh(baseMesh?: ArrayMesh /* = null */): ArrayMesh { return _C(this, 5511, baseMesh) as ArrayMesh; }
+
+    /**
+     * Converts the given {@link Mesh} into an {@link ImporterMesh} by copying all its surfaces, blend shapes, materials, and metadata into a new {@link ImporterMesh} object.
+     */
+    static fromMesh(mesh: Mesh): ImporterMesh { return _C(345, 3597, mesh) as ImporterMesh; }
+
+    /**
+     * Removes all surfaces and blend shapes from this {@link ImporterMesh}.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Sets the size hint of this mesh for lightmap-unwrapping in UV-space.
+     */
+    setLightmapSizeHint(size: Vector2i): void { _C(this, 11901, size); }
+
+    /**
+     * Returns the size hint of this mesh for lightmap-unwrapping in UV-space.
+     */
+    getLightmapSizeHint(): Vector2i { return _C(this, 5344) as Vector2i; }
+
+    static readonly name = _R(345, ImporterMesh);
+}

package/gen/classes/ImporterMeshInstance3D.ts

@@ -0,0 +1,45 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { NodePath } from '../heap-types/index.ts';
+import type { ShadowCastingSetting, VisibilityRangeFadeMode } from './GeometryInstance3D.ts';
+import type { ImporterMesh } from './ImporterMesh.ts';
+import type { Skin } from './Skin.ts';
+
+export class ImporterMeshInstance3D extends Node3D {
+    constructor(name = 346) { super(name); }
+
+    get mesh(): ImporterMesh { return _C(this, 5511) as ImporterMesh; }
+    set mesh(v: ImporterMesh) { _C(this, 12024, v); }
+
+    get skin(): Skin { return _C(this, 6413) as Skin; }
+    set skin(v: Skin) { _C(this, 12763, v); }
+
+    get skeletonPath(): NodePath { return _C(this, 6407) as NodePath; }
+    set skeletonPath(v: NodePath) { _C(this, 12759, v); }
+
+    get layerMask(): number { return _C(this, 5316) as number; }
+    set layerMask(v: number) { _C(this, 11876, v); }
+
+    get castShadow(): ShadowCastingSetting { return _C(this, 4096) as ShadowCastingSetting; }
+    set castShadow(v: ShadowCastingSetting) { _C(this, 10810, v); }
+
+    get visibilityRangeBegin(): number { return _C(this, 7095) as number; }
+    set visibilityRangeBegin(v: number) { _C(this, 13324, v); }
+
+    get visibilityRangeBeginMargin(): number { return _C(this, 7096) as number; }
+    set visibilityRangeBeginMargin(v: number) { _C(this, 13325, v); }
+
+    get visibilityRangeEnd(): number { return _C(this, 7097) as number; }
+    set visibilityRangeEnd(v: number) { _C(this, 13326, v); }
+
+    get visibilityRangeEndMargin(): number { return _C(this, 7098) as number; }
+    set visibilityRangeEndMargin(v: number) { _C(this, 13327, v); }
+
+    get visibilityRangeFadeMode(): VisibilityRangeFadeMode { return _C(this, 7099) as VisibilityRangeFadeMode; }
+    set visibilityRangeFadeMode(v: VisibilityRangeFadeMode) { _C(this, 13328, v); }
+
+    static readonly name = _R(346, ImporterMeshInstance3D);
+}