@ringozz/godot 0.1.0

package/gen/classes/MeshDataTool.ts

@@ -0,0 +1,251 @@
+// 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';
+import type { Error } from '../global-enums.ts';
+import type { PackedFloat32Array, PackedInt32Array, Variant } from '../heap-types/index.ts';
+import type { Color, Plane, Vector2, Vector3 } from '../value-types/index.ts';
+import type { ArrayMesh } from './ArrayMesh.ts';
+import type { Material } from './Material.ts';
+
+/**
+ * MeshDataTool provides access to individual vertices in a {@link Mesh}. It allows users to read and edit vertex data of meshes. It also creates an array of faces and edges.
+ * To use MeshDataTool, load a mesh with {@link createFromSurface}. When you are finished editing the data commit the data to a mesh with {@link commitToSurface}.
+ * Below is an example of how MeshDataTool may be used.
+ *
+ *
+ * ```gdscript
+ *
+ * var mesh = ArrayMesh.new()
+ * mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, BoxMesh.new().get_mesh_arrays())
+ * var mdt = MeshDataTool.new()
+ * mdt.create_from_surface(mesh, 0)
+ * for i in range(mdt.get_vertex_count()):
+ * 	var vertex = mdt.get_vertex(i)
+ * 	# In this example we extend the mesh by one unit, which results in separated faces as it is flat shaded.
+ * 	vertex += mdt.get_vertex_normal(i)
+ * 	# Save your change.
+ * 	mdt.set_vertex(i, vertex)
+ * mesh.clear_surfaces()
+ * mdt.commit_to_surface(mesh)
+ * var mi = MeshInstance.new()
+ * mi.mesh = mesh
+ * add_child(mi)
+ *
+ * ```
+ *
+ *
+ *
+ * See also {@link ArrayMesh}, {@link ImmediateMesh} and {@link SurfaceTool} for procedural geometry generation.
+ * **Note:** Godot uses clockwise [winding order](https://learnopengl.com/Advanced-OpenGL/Face-culling) for front faces of triangle primitive modes.
+ */
+export class MeshDataTool extends RefCounted {
+    constructor(name = 412) { super(name); }
+
+    /**
+     * Clears all data currently in MeshDataTool.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Uses specified surface of given {@link Mesh} to populate data for MeshDataTool.
+     * Requires {@link Mesh} with primitive type {@link Mesh.PRIMITIVE_TRIANGLES}.
+     */
+    createFromSurface(mesh: ArrayMesh, surface: number): Error { return _C(this, 2538, mesh, surface) as Error; }
+
+    /**
+     * Adds a new surface to specified {@link Mesh} with edited data.
+     */
+    commitToSurface(mesh: ArrayMesh, compressionFlags?: number /* = 0,  uint64 */): Error { return _C(this, 2385, mesh, compressionFlags) as Error; }
+
+    /**
+     * Returns the {@link Mesh}'s format as a combination of the {@link Mesh.ArrayFormat} flags. For example, a mesh containing both vertices and normals would return a format of `3` because {@link Mesh.ARRAY_FORMAT_VERTEX} is `1` and {@link Mesh.ARRAY_FORMAT_NORMAL} is `2`.
+     */
+    getFormat(): number { return _C(this, 4861) as number; }
+
+    /**
+     * Returns the total number of vertices in {@link Mesh}.
+     */
+    getVertexCount(): number { return _C(this, 7051) as number; }
+
+    /**
+     * Returns the number of edges in this {@link Mesh}.
+     */
+    getEdgeCount(): number { return _C(this, 4593) as number; }
+
+    /**
+     * Returns the number of faces in this {@link Mesh}.
+     */
+    getFaceCount(): number { return _C(this, 4729) as number; }
+
+    /**
+     * Sets the position of the given vertex.
+     */
+    setVertex(idx: number, vertex: Vector3): void { _C(this, 13286, idx, vertex); }
+
+    /**
+     * Returns the position of the given vertex.
+     */
+    getVertex(idx: number): Vector3 { return _C(this, 7045, idx) as Vector3; }
+
+    /**
+     * Sets the normal of the given vertex.
+     */
+    setVertexNormal(idx: number, normal: Vector3): void { _C(this, 13295, idx, normal); }
+
+    /**
+     * Returns the normal of the given vertex.
+     */
+    getVertexNormal(idx: number): Vector3 { return _C(this, 7056, idx) as Vector3; }
+
+    /**
+     * Sets the tangent of the given 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}.
+     */
+    setVertexTangent(idx: number, tangent: Plane): void { _C(this, 13298, idx, tangent); }
+
+    /**
+     * Returns the tangent of the given vertex.
+     */
+    getVertexTangent(idx: number): Plane { return _C(this, 7059, idx) as Plane; }
+
+    /**
+     * Sets the UV of the given vertex.
+     */
+    setVertexUv(idx: number, uv: Vector2): void { _C(this, 13299, idx, uv); }
+
+    /**
+     * Returns the UV of the given vertex.
+     */
+    getVertexUv(idx: number): Vector2 { return _C(this, 7060, idx) as Vector2; }
+
+    /**
+     * Sets the UV2 of the given vertex.
+     */
+    setVertexUv2(idx: number, uv2: Vector2): void { _C(this, 13300, idx, uv2); }
+
+    /**
+     * Returns the UV2 of the given vertex.
+     */
+    getVertexUv2(idx: number): Vector2 { return _C(this, 7061, idx) as Vector2; }
+
+    /**
+     * Sets the color of the given vertex.
+     */
+    setVertexColor(idx: number, color: Color): void { _C(this, 13290, idx, color); }
+
+    /**
+     * Returns the color of the given vertex.
+     */
+    getVertexColor(idx: number): Color { return _C(this, 7049, idx) as Color; }
+
+    /**
+     * Sets the bones of the given vertex.
+     */
+    setVertexBones(idx: number, bones: PackedInt32Array): void { _C(this, 13288, idx, bones); }
+
+    /**
+     * Returns the bones of the given vertex.
+     */
+    getVertexBones(idx: number): PackedInt32Array { return _C(this, 7047, idx) as PackedInt32Array; }
+
+    /**
+     * Sets the bone weights of the given vertex.
+     */
+    setVertexWeights(idx: number, weights: PackedFloat32Array): void { _C(this, 13301, idx, weights); }
+
+    /**
+     * Returns bone weights of the given vertex.
+     */
+    getVertexWeights(idx: number): PackedFloat32Array { return _C(this, 7062, idx) as PackedFloat32Array; }
+
+    /**
+     * Sets the metadata associated with the given vertex.
+     */
+    setVertexMeta(idx: number, meta: Variant): void { _C(this, 13294, idx, meta); }
+
+    /**
+     * Returns the metadata associated with the given vertex.
+     */
+    getVertexMeta(idx: number): Variant { return _C(this, 7055, idx) as Variant; }
+
+    /**
+     * Returns an array of edges that share the given vertex.
+     */
+    getVertexEdges(idx: number): PackedInt32Array { return _C(this, 7052, idx) as PackedInt32Array; }
+
+    /**
+     * Returns an array of faces that share the given vertex.
+     */
+    getVertexFaces(idx: number): PackedInt32Array { return _C(this, 7053, idx) as PackedInt32Array; }
+
+    /**
+     * Returns the index of the specified `vertex` connected to the edge at index `idx`.
+     * `vertex` can only be `0` or `1`, as edges are composed of two vertices.
+     */
+    getEdgeVertex(idx: number, vertex: number): number { return _C(this, 4599, idx, vertex) as number; }
+
+    /**
+     * Returns array of faces that touch given edge.
+     */
+    getEdgeFaces(idx: number): PackedInt32Array { return _C(this, 4594, idx) as PackedInt32Array; }
+
+    /**
+     * Sets the metadata of the given edge.
+     */
+    setEdgeMeta(idx: number, meta: Variant): void { _C(this, 11212, idx, meta); }
+
+    /**
+     * Returns meta information assigned to given edge.
+     */
+    getEdgeMeta(idx: number): Variant { return _C(this, 4598, idx) as Variant; }
+
+    /**
+     * Returns the specified vertex index of the given face.
+     * `vertex` must be either `0`, `1`, or `2` because faces contain three vertices.
+     *
+     *
+     * ```gdscript
+     *
+     * var index = mesh_data_tool.get_face_vertex(0, 1) # Gets the index of the second vertex of the first face.
+     * var position = mesh_data_tool.get_vertex(index)
+     * var normal = mesh_data_tool.get_vertex_normal(index)
+     *
+     * ```
+     */
+    getFaceVertex(idx: number, vertex: number): number { return _C(this, 4735, idx, vertex) as number; }
+
+    /**
+     * Returns the edge associated with the face at index `idx`.
+     * `edge` argument must be either `0`, `1`, or `2` because a face only has three edges.
+     */
+    getFaceEdge(idx: number, edge: number): number { return _C(this, 4730, idx, edge) as number; }
+
+    /**
+     * Sets the metadata of the given face.
+     */
+    setFaceMeta(idx: number, meta: Variant): void { _C(this, 11350, idx, meta); }
+
+    /**
+     * Returns the metadata associated with the given face.
+     */
+    getFaceMeta(idx: number): Variant { return _C(this, 4732, idx) as Variant; }
+
+    /**
+     * Calculates and returns the face normal of the given face.
+     */
+    getFaceNormal(idx: number): Vector3 { return _C(this, 4733, idx) as Vector3; }
+
+    /**
+     * Sets the material to be used by newly-constructed {@link Mesh}.
+     */
+    setMaterial(material: Material): void { _C(this, 11978, material); }
+
+    /**
+     * Returns the material assigned to the {@link Mesh}.
+     */
+    getMaterial(): Material { return _C(this, 5452) as Material; }
+
+    static readonly name = _R(412, MeshDataTool);
+}

package/gen/classes/MeshInstance2D.ts

@@ -0,0 +1,37 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { Signal } from '../heap-types/index.ts';
+import type { Mesh } from './Mesh.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * Node used for displaying a {@link Mesh} in 2D. This can be faster to render compared to displaying a {@link Sprite2D} node with large transparent areas, especially if the node takes up a lot of space on screen at high viewport resolutions. This is because using a mesh designed to fit the sprite's opaque areas will reduce GPU fill rate utilization (at the cost of increased vertex processing utilization).
+ * When a {@link Mesh} has to be instantiated more than thousands of times close to each other, consider using a {@link MultiMesh} in a {@link MultiMeshInstance2D} instead.
+ * A {@link MeshInstance2D} can be created from an existing {@link Sprite2D} via a tool in the editor toolbar. Select the {@link Sprite2D} node, then choose **Sprite2D > Convert to MeshInstance2D** at the top of the 2D editor viewport.
+ */
+export class MeshInstance2D extends Node2D {
+    constructor(name = 413) { super(name); }
+
+    /**
+     * The {@link Mesh} that will be drawn by the {@link MeshInstance2D}.
+     */
+    get mesh(): Mesh { return _C(this, 5511) as Mesh; }
+    set mesh(v: Mesh) { _C(this, 12024, v); }
+
+    /**
+     * The {@link Texture2D} that will be used if using the default {@link CanvasItemMaterial}. Can be accessed as `TEXTURE` in CanvasItem shader.
+     */
+    get texture(): Texture2D { return _C(this, 6726) as Texture2D; }
+    set texture(v: Texture2D) { _C(this, 13024, v); }
+
+    /**
+     * Emitted when the {@link texture} is changed.
+     */
+    get textureChanged(): Signal<() => void> { return _G(this, 14175) as Signal<() => void>; }
+    set textureChanged(v: (() => void) | null) { _G(this, 14175, v); }
+
+    static readonly name = _R(413, MeshInstance2D);
+}

package/gen/classes/MeshInstance3D.ts

@@ -0,0 +1,122 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { GeometryInstance3D } from './GeometryInstance3D.ts';
+import type { NodePath, StringName } from '../heap-types/index.ts';
+import type { ArrayMesh } from './ArrayMesh.ts';
+import type { Material } from './Material.ts';
+import type { Mesh } from './Mesh.ts';
+import type { MeshConvexDecompositionSettings } from './MeshConvexDecompositionSettings.ts';
+import type { Skin } from './Skin.ts';
+import type { SkinReference } from './SkinReference.ts';
+
+/**
+ * MeshInstance3D is a node that takes a {@link Mesh} resource and adds it to the current scenario by creating an instance of it. This is the class most often used to render 3D geometry and can be used to instance a single {@link Mesh} in many places. This allows reusing geometry, which can save on resources. When a {@link Mesh} has to be instantiated more than thousands of times at close proximity, consider using a {@link MultiMesh} in a {@link MultiMeshInstance3D} instead.
+ */
+export class MeshInstance3D extends GeometryInstance3D {
+    constructor(name = 414) { super(name); }
+
+    /**
+     * Returns the internal {@link SkinReference} containing the skeleton's {@link RID} attached to this RID. See also {@link Resource.getRid}, {@link SkinReference.getSkeleton}, and {@link RenderingServer.instanceAttachSkeleton}.
+     */
+    getSkinReference(): SkinReference { return _C(this, 6414) as SkinReference; }
+
+    /**
+     * Returns the number of surface override materials. This is equivalent to {@link Mesh.getSurfaceCount}. See also {@link getSurfaceOverrideMaterial}.
+     */
+    getSurfaceOverrideMaterialCount(): number { return _C(this, 6634) as number; }
+
+    /**
+     * Sets the override `material` for the specified `surface` of the {@link Mesh} resource. This material is associated with this {@link MeshInstance3D} rather than with {@link mesh}.
+     * **Note:** This assigns the {@link Material} associated to the {@link MeshInstance3D}'s Surface Material Override properties, not the material within the {@link Mesh} resource. To set the material within the {@link Mesh} resource, use {@link Mesh.surfaceSetMaterial} instead.
+     */
+    setSurfaceOverrideMaterial(surface: number, material: Material): void { _C(this, 12941, surface, material); }
+
+    /**
+     * Returns the override {@link Material} for the specified `surface` of the {@link Mesh} resource. See also {@link getSurfaceOverrideMaterialCount}.
+     * **Note:** This returns the {@link Material} associated to the {@link MeshInstance3D}'s Surface Material Override properties, not the material within the {@link Mesh} resource. To get the material within the {@link Mesh} resource, use {@link Mesh.surfaceGetMaterial} instead.
+     */
+    getSurfaceOverrideMaterial(surface: number): Material { return _C(this, 6633, surface) as Material; }
+
+    /**
+     * Returns the {@link Material} that will be used by the {@link Mesh} when drawing. This can return the {@link GeometryInstance3D.materialOverride}, the surface override {@link Material} defined in this {@link MeshInstance3D}, or the surface {@link Material} defined in the {@link mesh}. For example, if {@link GeometryInstance3D.materialOverride} is used, all surfaces will return the override material.
+     * Returns `null` if no material is active, including when {@link mesh} is `null`.
+     */
+    getActiveMaterial(surface: number): Material | null { return _C(this, 3692, surface) as Material | null; }
+
+    /**
+     * This helper creates a {@link StaticBody3D} child node with a {@link ConcavePolygonShape3D} collision shape calculated from the mesh geometry. It's mainly used for testing.
+     */
+    createTrimeshCollision(): void { _C(this, 2582); }
+
+    /**
+     * This helper creates a {@link StaticBody3D} child node with a {@link ConvexPolygonShape3D} collision shape calculated from the mesh geometry. It's mainly used for testing.
+     * If `clean` is `true` (default), duplicate and interior vertices are removed automatically. You can set it to `false` to make the process faster if not needed.
+     * If `simplify` is `true`, the geometry can be further simplified to reduce the number of vertices. Disabled by default.
+     */
+    createConvexCollision(clean?: boolean /* = true */, simplify?: boolean /* = false */): void { _C(this, 2514, clean, simplify); }
+
+    /**
+     * This helper creates a {@link StaticBody3D} child node with multiple {@link ConvexPolygonShape3D} collision shapes calculated from the mesh geometry via convex decomposition. The convex decomposition operation can be controlled with parameters from the optional `settings`.
+     */
+    createMultipleConvexCollisions(settings?: MeshConvexDecompositionSettings /* = null */): void { _C(this, 2553, settings); }
+
+    /**
+     * Returns the number of blend shapes available. Produces an error if {@link mesh} is `null`.
+     */
+    getBlendShapeCount(): number { return _C(this, 3938) as number; }
+
+    /**
+     * Returns the index of the blend shape with the given `name`. Returns `-1` if no blend shape with this name exists, including when {@link mesh} is `null`.
+     */
+    findBlendShapeByName(name: StringName): number { return _C(this, 3282, name) as number; }
+
+    /**
+     * Returns the value of the blend shape at the given `blendShapeIdx`. Returns `0.0` and produces an error if {@link mesh} is `null` or doesn't have a blend shape at that index.
+     */
+    getBlendShapeValue(blendShapeIdx: number): number { return _C(this, 3941, blendShapeIdx) as number; }
+
+    /**
+     * Sets the value of the blend shape at `blendShapeIdx` to `value`. Produces an error if {@link mesh} is `null` or doesn't have a blend shape at that index.
+     */
+    setBlendShapeValue(blendShapeIdx: number, value: number): void { _C(this, 10684, blendShapeIdx, value); }
+
+    /**
+     * This helper creates a {@link MeshInstance3D} child node with gizmos at every vertex calculated from the mesh geometry. It's mainly used for testing.
+     */
+    createDebugTangents(): void { _C(this, 2517); }
+
+    /**
+     * Takes a snapshot from the current {@link ArrayMesh} with all blend shapes applied according to their current weights and bakes it to the provided `existing` mesh. If no `existing` mesh is provided a new {@link ArrayMesh} is created, baked and returned. Mesh surface materials are not copied.
+     * **Performance:** {@link Mesh} data needs to be received from the GPU, stalling the {@link RenderingServer} in the process.
+     */
+    bakeMeshFromCurrentBlendShapeMix(existing?: ArrayMesh /* = null */): ArrayMesh { return _C(this, 1716, existing) as ArrayMesh; }
+
+    /**
+     * Takes a snapshot of the current animated skeleton pose of the skinned mesh and bakes it to the provided `existing` mesh. If no `existing` mesh is provided a new {@link ArrayMesh} is created, baked, and returned. Requires a skeleton with a registered skin to work. Blendshapes are ignored. Mesh surface materials are not copied.
+     * **Performance:** {@link Mesh} data needs to be retrieved from the GPU, stalling the {@link RenderingServer} in the process.
+     */
+    bakeMeshFromCurrentSkeletonPose(existing?: ArrayMesh /* = null */): ArrayMesh { return _C(this, 1717, existing) as ArrayMesh; }
+
+    /**
+     * The {@link Mesh} resource for the instance.
+     */
+    get mesh(): Mesh { return _C(this, 5511) as Mesh; }
+    set mesh(v: Mesh) { _C(this, 12024, v); }
+
+    /**
+     * The {@link Skin} to be used by this instance.
+     */
+    get skin(): Skin { return _C(this, 6413) as Skin; }
+    set skin(v: Skin) { _C(this, 12763, v); }
+
+    /**
+     * {@link NodePath} to the {@link Skeleton3D} associated with the instance.
+     * **Note:** The default value of this property has changed in Godot 4.6. Enable {@link ProjectSettings.animation/compatibility/defaultParentSkeletonInMeshInstance3d} if the old behavior is needed for compatibility.
+     */
+    get skeleton(): NodePath { return _C(this, 6407) as NodePath; }
+    set skeleton(v: NodePath) { _C(this, 12759, v); }
+
+    static readonly name = _R(414, MeshInstance3D);
+}

package/gen/classes/MeshLibrary.ts

@@ -0,0 +1,149 @@
+// 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, PackedInt32Array } from '../heap-types/index.ts';
+import type { Transform3D } from '../value-types/index.ts';
+import type { ShadowCastingSetting } from './GeometryInstance3D.ts';
+import type { Mesh } from './Mesh.ts';
+import type { NavigationMesh } from './NavigationMesh.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * A library of meshes. Contains a list of {@link Mesh} resources, each with a name and ID. Each item can also include collision and navigation shapes. This resource is used in {@link GridMap}.
+ */
+export class MeshLibrary extends Resource {
+    constructor(name = 415) { super(name); }
+
+    /**
+     * Creates a new item in the library with the given ID.
+     * You can get an unused ID from {@link getLastUnusedItemId}.
+     */
+    createItem(id: number): void { _C(this, 2546, id); }
+
+    /**
+     * Sets the item's name.
+     * This name is shown in the editor. It can also be used to look up the item later using {@link findItemByName}.
+     */
+    setItemName(id: number, name: string): void { _C(this, 11791, id, name); }
+
+    /**
+     * Sets the item's mesh.
+     */
+    setItemMesh(id: number, mesh: Mesh): void { _C(this, 11785, id, mesh); }
+
+    /**
+     * Sets the transform to apply to the item's mesh.
+     */
+    setItemMeshTransform(id: number, meshTransform: Transform3D): void { _C(this, 11787, id, meshTransform); }
+
+    /**
+     * Sets the item's shadow casting mode to `shadowCastingSetting`.
+     */
+    setItemMeshCastShadow(id: number, shadowCastingSetting: ShadowCastingSetting): void { _C(this, 11786, id, shadowCastingSetting); }
+
+    /**
+     * Sets the item's navigation mesh.
+     */
+    setItemNavigationMesh(id: number, navigationMesh: NavigationMesh): void { _C(this, 11793, id, navigationMesh); }
+
+    /**
+     * Sets the transform to apply to the item's navigation mesh.
+     */
+    setItemNavigationMeshTransform(id: number, navigationMesh: Transform3D): void { _C(this, 11794, id, navigationMesh); }
+
+    /**
+     * Sets the item's navigation layers bitmask.
+     */
+    setItemNavigationLayers(id: number, navigationLayers: number /* uint32 */): void { _C(this, 11792, id, navigationLayers); }
+
+    /**
+     * Sets an item's collision shapes.
+     * The array should consist of {@link Shape3D} objects, each followed by a {@link Transform3D} that will be applied to it. For shapes that should not have a transform, use {@link Transform3D.IDENTITY}.
+     */
+    setItemShapes(id: number, shapes: GodotArray): void { _C(this, 11799, id, shapes); }
+
+    /**
+     * Sets a texture to use as the item's preview icon in the editor.
+     */
+    setItemPreview(id: number, texture: Texture2D): void { _C(this, 11795, id, texture); }
+
+    /**
+     * Returns the item's name.
+     */
+    getItemName(id: number): string { return _C(this, 5203, id) as string; }
+
+    /**
+     * Returns the item's mesh.
+     */
+    getItemMesh(id: number): Mesh { return _C(this, 5197, id) as Mesh; }
+
+    /**
+     * Returns the transform applied to the item's mesh.
+     */
+    getItemMeshTransform(id: number): Transform3D { return _C(this, 5199, id) as Transform3D; }
+
+    /**
+     * Returns the item's shadow casting mode.
+     */
+    getItemMeshCastShadow(id: number): ShadowCastingSetting { return _C(this, 5198, id) as ShadowCastingSetting; }
+
+    /**
+     * Returns the item's navigation mesh.
+     */
+    getItemNavigationMesh(id: number): NavigationMesh { return _C(this, 5205, id) as NavigationMesh; }
+
+    /**
+     * Returns the transform applied to the item's navigation mesh.
+     */
+    getItemNavigationMeshTransform(id: number): Transform3D { return _C(this, 5206, id) as Transform3D; }
+
+    /**
+     * Returns the item's navigation layers bitmask.
+     */
+    getItemNavigationLayers(id: number): number { return _C(this, 5204, id) as number; }
+
+    /**
+     * Returns an item's collision shapes.
+     * The array consists of each {@link Shape3D} followed by its {@link Transform3D}.
+     */
+    getItemShapes(id: number): GodotArray { return _C(this, 5210, id) as GodotArray; }
+
+    /**
+     * When running in the editor, returns a generated item preview (a 3D rendering in isometric perspective). When used in a running project, returns the manually-defined item preview which can be set using {@link setItemPreview}. Returns an empty {@link Texture2D} if no preview was manually set in a running project.
+     */
+    getItemPreview(id: number): Texture2D { return _C(this, 5207, id) as Texture2D; }
+
+    /**
+     * Removes the item.
+     */
+    removeItem(id: number): void { _C(this, 9924, id); }
+
+    /**
+     * Returns the first item with the given name, or `-1` if no item is found.
+     */
+    findItemByName(name: string): number { return _C(this, 3290, name) as number; }
+
+    /**
+     * Clears the library.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Returns the list of item IDs in use.
+     */
+    getItemList(): PackedInt32Array { return _C(this, 5195) as PackedInt32Array; }
+
+    /**
+     * Returns the number of items present in the library.
+     */
+    getItemCount(): number { return _C(this, 5181) as number; }
+
+    /**
+     * Gets an unused ID for a new item.
+     */
+    getLastUnusedItemId(): number { return _C(this, 5311) as number; }
+
+    static readonly name = _R(415, MeshLibrary);
+}

package/gen/classes/MeshTexture.ts

@@ -0,0 +1,34 @@
+// 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 { Vector2 } from '../value-types/index.ts';
+import type { Mesh } from './Mesh.ts';
+
+/**
+ * Simple texture that uses a mesh to draw itself. It's limited because flags can't be changed and region drawing is not supported.
+ */
+export class MeshTexture extends Texture2D {
+    constructor(name = 416) { super(name); }
+
+    /**
+     * Sets the mesh used to draw. It must be a mesh using 2D vertices.
+     */
+    get mesh(): Mesh { return _C(this, 5511) as Mesh; }
+    set mesh(v: Mesh) { _C(this, 12024, v); }
+
+    /**
+     * Sets the base texture that the Mesh will use to draw.
+     */
+    get baseTexture(): Texture2D { return _C(this, 3901) as Texture2D; }
+    set baseTexture(v: Texture2D) { _C(this, 10645, v); }
+
+    /**
+     * Sets the size of the image, needed for reference.
+     */
+    get imageSize(): Vector2 { return _C(this, 5074) as Vector2; }
+    set imageSize(v: Vector2) { _C(this, 11672, v); }
+
+    static readonly name = _R(416, MeshTexture);
+}

package/gen/classes/MethodTweener.ts

@@ -0,0 +1,32 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Tweener } from './Tweener.ts';
+import type { EaseType, TransitionType } from './Tween.ts';
+
+/**
+ * {@link MethodTweener} is similar to a combination of {@link CallbackTweener} and {@link PropertyTweener}. It calls a method providing an interpolated value as a parameter. See {@link Tween.tweenMethod} for more usage information.
+ * The tweener will finish automatically if the callback's target object is freed.
+ * **Note:** {@link Tween.tweenMethod} is the only correct way to create {@link MethodTweener}. Any {@link MethodTweener} created manually will not function correctly.
+ */
+export class MethodTweener extends Tweener {
+    constructor(name = 417) { super(name); }
+
+    /**
+     * Sets the time in seconds after which the {@link MethodTweener} will start interpolating. By default there's no delay.
+     */
+    setDelay(delay: number /* double */): MethodTweener { return _C(this, 11075, delay) as MethodTweener; }
+
+    /**
+     * Sets the type of used transition from {@link Tween.TransitionType}. If not set, the default transition is used from the {@link Tween} that contains this Tweener.
+     */
+    setTrans(trans: TransitionType): MethodTweener { return _C(this, 13131, trans) as MethodTweener; }
+
+    /**
+     * Sets the type of used easing from {@link Tween.EaseType}. If not set, the default easing is used from the {@link Tween} that contains this Tweener.
+     */
+    setEase(ease: EaseType): MethodTweener { return _C(this, 11206, ease) as MethodTweener; }
+
+    static readonly name = _R(417, MethodTweener);
+}

package/gen/classes/MissingNode.ts

@@ -0,0 +1,39 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node } from './Node.ts';
+
+/**
+ * This is an internal editor class intended for keeping data of nodes of unknown type (most likely this type was supplied by an extension that is no longer loaded). It can't be manually instantiated or placed in a scene.
+ * **Warning:** Ignore missing nodes unless you know what you are doing. Existing properties on a missing node can be freely modified in code, regardless of the type they are intended to be.
+ */
+export class MissingNode extends Node {
+    constructor(name = 418) { super(name); }
+
+    /**
+     * The name of the class this node was supposed to be (see {@link Object.getClass}).
+     */
+    get originalClass(): string { return _C(this, 5746) as string; }
+    set originalClass(v: string) { _C(this, 12207, v); }
+
+    /**
+     * Returns the path of the scene this node was instance of originally.
+     */
+    get originalScene(): string { return _C(this, 5748) as string; }
+    set originalScene(v: string) { _C(this, 12209, v); }
+
+    /**
+     * If `true`, allows new properties to be set along with existing ones. If `false`, only existing properties' values can be set, and new properties cannot be added.
+     */
+    get recordingProperties(): boolean { return _C(this, 8230) as boolean; }
+    set recordingProperties(v: boolean) { _C(this, 12486, v); }
+
+    /**
+     * If `true`, allows new signals to be connected to along with existing ones. If `false`, only existing signals can be connected to, and new signals cannot be added.
+     */
+    get recordingSignals(): boolean { return _C(this, 8231) as boolean; }
+    set recordingSignals(v: boolean) { _C(this, 12487, v); }
+
+    static readonly name = _R(418, MissingNode);
+}