typescript-to-gdscript 0.1.0

package/typings/classes/Mesh.d.ts

@@ -0,0 +1,255 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A {@link Resource} that contains vertex array-based geometry. */
+declare class Mesh extends Resource {
+  /** Sets a hint to be used for lightmap resolution. */
+  lightmap_size_hint: Vector2i;
+  set_lightmap_size_hint(value: Vector2i | Vector2): void;
+  get_lightmap_size_hint(): Vector2i;
+
+  /** Virtual method to override the {@link AABB} for a custom class extending {@link Mesh}. */
+  _get_aabb(): AABB;
+  /** Virtual method to override the number of blend shapes for a custom class extending {@link Mesh}. */
+  _get_blend_shape_count(): int;
+  /**
+   * Virtual method to override the retrieval of blend shape names for a custom class extending {@link Mesh}.
+   */
+  _get_blend_shape_name(index: int): string;
+  /** Virtual method to override the surface count for a custom class extending {@link Mesh}. */
+  _get_surface_count(): int;
+  /** Virtual method to override the names of blend shapes for a custom class extending {@link Mesh}. */
+  _set_blend_shape_name(index: int, name: string): void;
+  /**
+   * Virtual method to override the surface array index length for a custom class extending {@link Mesh}.
+   */
+  _surface_get_array_index_len(index: int): int;
+  /** Virtual method to override the surface array length for a custom class extending {@link Mesh}. */
+  _surface_get_array_len(index: int): int;
+  /** Virtual method to override the surface arrays for a custom class extending {@link Mesh}. */
+  _surface_get_arrays(index: int): Array<unknown>;
+  /** Virtual method to override the blend shape arrays for a custom class extending {@link Mesh}. */
+  _surface_get_blend_shape_arrays(index: int): Array<Array<unknown>>;
+  /** Virtual method to override the surface format for a custom class extending {@link Mesh}. */
+  _surface_get_format(index: int): int;
+  /** Virtual method to override the surface LODs for a custom class extending {@link Mesh}. */
+  _surface_get_lods(index: int): Dictionary;
+  /** Virtual method to override the surface material for a custom class extending {@link Mesh}. */
+  _surface_get_material(index: int): Material | null;
+  /** Virtual method to override the surface primitive type for a custom class extending {@link Mesh}. */
+  _surface_get_primitive_type(index: int): int;
+  /**
+   * Virtual method to override the setting of a `material` at the given `index` for a custom class extending {@link Mesh}.
+   */
+  _surface_set_material(index: int, material: Material): void;
+  /**
+   * Calculate a {@link ConvexPolygonShape3D} from the mesh.
+   * 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.
+   */
+  create_convex_shape(clean?: boolean, simplify?: boolean): ConvexPolygonShape3D;
+  /**
+   * Calculate an outline mesh at a defined offset (margin) from the original mesh.
+   * **Note:** This method typically returns the vertices in reverse order (e.g. clockwise to counterclockwise).
+   */
+  create_outline(margin: float): Mesh | null;
+  /** Creates a placeholder version of this resource ({@link PlaceholderMesh}). */
+  create_placeholder(): Resource;
+  /** Calculate a {@link ConcavePolygonShape3D} from the mesh. */
+  create_trimesh_shape(): ConcavePolygonShape3D;
+  /**
+   * Generate a {@link TriangleMesh} from the mesh. Considers only surfaces using one of these primitive types: {@link PRIMITIVE_TRIANGLES}, {@link PRIMITIVE_TRIANGLE_STRIP}.
+   */
+  generate_triangle_mesh(): TriangleMesh | null;
+  /**
+   * Returns the smallest {@link AABB} enclosing this mesh in local space. Not affected by `custom_aabb`.
+   * **Note:** This is only implemented for {@link ArrayMesh} and {@link PrimitiveMesh}.
+   */
+  get_aabb(): AABB;
+  /**
+   * Returns all the vertices that make up the faces of the mesh. Each three vertices represent one triangle.
+   */
+  get_faces(): PackedVector3Array;
+  /**
+   * Returns the number of surfaces that the {@link Mesh} holds. This is equivalent to {@link MeshInstance3D.get_surface_override_material_count}.
+   */
+  get_surface_count(): int;
+  /**
+   * Returns the arrays for the vertices, normals, UVs, etc. that make up the requested surface (see {@link ArrayMesh.add_surface_from_arrays}).
+   */
+  surface_get_arrays(surf_idx: int): Array<unknown>;
+  /** Returns the blend shape arrays for the requested surface. */
+  surface_get_blend_shape_arrays(surf_idx: int): Array<Array<unknown>>;
+  /**
+   * Returns a {@link Material} in a given surface. Surface is rendered using this material.
+   * **Note:** This returns the material within the {@link Mesh} resource, not the {@link Material} associated to the {@link MeshInstance3D}'s Surface Material Override properties. To get the {@link Material} associated to the {@link MeshInstance3D}'s Surface Material Override properties, use {@link MeshInstance3D.get_surface_override_material} instead.
+   */
+  surface_get_material(surf_idx: int): Material | null;
+  /**
+   * Sets a {@link Material} for a given surface. Surface will be rendered using this material.
+   * **Note:** This assigns the material within the {@link Mesh} resource, not the {@link Material} associated to the {@link MeshInstance3D}'s Surface Material Override properties. To set the {@link Material} associated to the {@link MeshInstance3D}'s Surface Material Override properties, use {@link MeshInstance3D.set_surface_override_material} instead.
+   */
+  surface_set_material(surf_idx: int, material: Material): void;
+
+  // enum PrimitiveType
+  /** Render array as points (one vertex equals one point). */
+  static readonly PRIMITIVE_POINTS: int;
+  /** Render array as lines (every two vertices a line is created). */
+  static readonly PRIMITIVE_LINES: int;
+  /** Render array as line strip. */
+  static readonly PRIMITIVE_LINE_STRIP: int;
+  /** Render array as triangles (every three vertices a triangle is created). */
+  static readonly PRIMITIVE_TRIANGLES: int;
+  /** Render array as triangle strips. */
+  static readonly PRIMITIVE_TRIANGLE_STRIP: int;
+  // enum ArrayType
+  /** {@link PackedVector3Array}, {@link PackedVector2Array}, or {@link Array} of vertex positions. */
+  static readonly ARRAY_VERTEX: int;
+  /**
+   * {@link PackedVector3Array} of vertex normals.
+   * **Note:** The array has to consist of normal vectors, otherwise they will be normalized by the engine, potentially causing visual discrepancies.
+   */
+  static readonly ARRAY_NORMAL: int;
+  /**
+   * {@link PackedFloat32Array} of vertex tangents. Each element in groups of 4 floats, first 3 floats determine the tangent, and the last the binormal direction as -1 or 1.
+   */
+  static readonly ARRAY_TANGENT: int;
+  /** {@link PackedColorArray} of vertex colors. */
+  static readonly ARRAY_COLOR: int;
+  /** {@link PackedVector2Array} for UV coordinates. */
+  static readonly ARRAY_TEX_UV: int;
+  /** {@link PackedVector2Array} for second UV coordinates. */
+  static readonly ARRAY_TEX_UV2: int;
+  /**
+   * Contains custom color channel 0. {@link PackedByteArray} if `(format >> Mesh.ARRAY_FORMAT_CUSTOM0_SHIFT) & Mesh.ARRAY_FORMAT_CUSTOM_MASK` is {@link ARRAY_CUSTOM_RGBA8_UNORM}, {@link ARRAY_CUSTOM_RGBA8_SNORM}, {@link ARRAY_CUSTOM_RG_HALF}, or {@link ARRAY_CUSTOM_RGBA_HALF}. {@link PackedFloat32Array} otherwise.
+   */
+  static readonly ARRAY_CUSTOM0: int;
+  /**
+   * Contains custom color channel 1. {@link PackedByteArray} if `(format >> Mesh.ARRAY_FORMAT_CUSTOM1_SHIFT) & Mesh.ARRAY_FORMAT_CUSTOM_MASK` is {@link ARRAY_CUSTOM_RGBA8_UNORM}, {@link ARRAY_CUSTOM_RGBA8_SNORM}, {@link ARRAY_CUSTOM_RG_HALF}, or {@link ARRAY_CUSTOM_RGBA_HALF}. {@link PackedFloat32Array} otherwise.
+   */
+  static readonly ARRAY_CUSTOM1: int;
+  /**
+   * Contains custom color channel 2. {@link PackedByteArray} if `(format >> Mesh.ARRAY_FORMAT_CUSTOM2_SHIFT) & Mesh.ARRAY_FORMAT_CUSTOM_MASK` is {@link ARRAY_CUSTOM_RGBA8_UNORM}, {@link ARRAY_CUSTOM_RGBA8_SNORM}, {@link ARRAY_CUSTOM_RG_HALF}, or {@link ARRAY_CUSTOM_RGBA_HALF}. {@link PackedFloat32Array} otherwise.
+   */
+  static readonly ARRAY_CUSTOM2: int;
+  /**
+   * Contains custom color channel 3. {@link PackedByteArray} if `(format >> Mesh.ARRAY_FORMAT_CUSTOM3_SHIFT) & Mesh.ARRAY_FORMAT_CUSTOM_MASK` is {@link ARRAY_CUSTOM_RGBA8_UNORM}, {@link ARRAY_CUSTOM_RGBA8_SNORM}, {@link ARRAY_CUSTOM_RG_HALF}, or {@link ARRAY_CUSTOM_RGBA_HALF}. {@link PackedFloat32Array} otherwise.
+   */
+  static readonly ARRAY_CUSTOM3: int;
+  /**
+   * {@link PackedFloat32Array} or {@link PackedInt32Array} of bone indices. Contains either 4 or 8 numbers per vertex depending on the presence of the {@link ARRAY_FLAG_USE_8_BONE_WEIGHTS} flag.
+   */
+  static readonly ARRAY_BONES: int;
+  /**
+   * {@link PackedFloat32Array} or {@link PackedFloat64Array} of bone weights in the range `0.0` to `1.0` (inclusive). Contains either 4 or 8 numbers per vertex depending on the presence of the {@link ARRAY_FLAG_USE_8_BONE_WEIGHTS} flag.
+   */
+  static readonly ARRAY_WEIGHTS: int;
+  /**
+   * {@link PackedInt32Array} of integers used as indices referencing vertices, colors, normals, tangents, and textures. All of those arrays must have the same number of elements as the vertex array. No index can be beyond the vertex array size. When this index array is present, it puts the function into "index mode," where the index selects the *i*'th vertex, normal, tangent, color, UV, etc. This means if you want to have different normals or colors along an edge, you have to duplicate the vertices.
+   * For triangles, the index array is interpreted as triples, referring to the vertices of each triangle. For lines, the index array is in pairs indicating the start and end of each line.
+   */
+  static readonly ARRAY_INDEX: int;
+  /** Represents the size of the {@link ArrayType} enum. */
+  static readonly ARRAY_MAX: int;
+  // enum ArrayCustomFormat
+  /**
+   * Indicates this custom channel contains unsigned normalized byte colors from 0 to 1, encoded as {@link PackedByteArray}.
+   */
+  static readonly ARRAY_CUSTOM_RGBA8_UNORM: int;
+  /**
+   * Indicates this custom channel contains signed normalized byte colors from -1 to 1, encoded as {@link PackedByteArray}.
+   */
+  static readonly ARRAY_CUSTOM_RGBA8_SNORM: int;
+  /**
+   * Indicates this custom channel contains half precision float colors, encoded as {@link PackedByteArray}. Only red and green channels are used.
+   */
+  static readonly ARRAY_CUSTOM_RG_HALF: int;
+  /**
+   * Indicates this custom channel contains half precision float colors, encoded as {@link PackedByteArray}.
+   */
+  static readonly ARRAY_CUSTOM_RGBA_HALF: int;
+  /**
+   * Indicates this custom channel contains full float colors, in a {@link PackedFloat32Array}. Only the red channel is used.
+   */
+  static readonly ARRAY_CUSTOM_R_FLOAT: int;
+  /**
+   * Indicates this custom channel contains full float colors, in a {@link PackedFloat32Array}. Only red and green channels are used.
+   */
+  static readonly ARRAY_CUSTOM_RG_FLOAT: int;
+  /**
+   * Indicates this custom channel contains full float colors, in a {@link PackedFloat32Array}. Only red, green and blue channels are used.
+   */
+  static readonly ARRAY_CUSTOM_RGB_FLOAT: int;
+  /** Indicates this custom channel contains full float colors, in a {@link PackedFloat32Array}. */
+  static readonly ARRAY_CUSTOM_RGBA_FLOAT: int;
+  /** Represents the size of the {@link ArrayCustomFormat} enum. */
+  static readonly ARRAY_CUSTOM_MAX: int;
+  // enum ArrayFormat
+  /** Mesh array contains vertices. All meshes require a vertex array so this should always be present. */
+  static readonly ARRAY_FORMAT_VERTEX: int;
+  /** Mesh array contains normals. */
+  static readonly ARRAY_FORMAT_NORMAL: int;
+  /** Mesh array contains tangents. */
+  static readonly ARRAY_FORMAT_TANGENT: int;
+  /** Mesh array contains colors. */
+  static readonly ARRAY_FORMAT_COLOR: int;
+  /** Mesh array contains UVs. */
+  static readonly ARRAY_FORMAT_TEX_UV: int;
+  /** Mesh array contains second UV. */
+  static readonly ARRAY_FORMAT_TEX_UV2: int;
+  /** Mesh array contains custom channel index 0. */
+  static readonly ARRAY_FORMAT_CUSTOM0: int;
+  /** Mesh array contains custom channel index 1. */
+  static readonly ARRAY_FORMAT_CUSTOM1: int;
+  /** Mesh array contains custom channel index 2. */
+  static readonly ARRAY_FORMAT_CUSTOM2: int;
+  /** Mesh array contains custom channel index 3. */
+  static readonly ARRAY_FORMAT_CUSTOM3: int;
+  /** Mesh array contains bones. */
+  static readonly ARRAY_FORMAT_BONES: int;
+  /** Mesh array contains bone weights. */
+  static readonly ARRAY_FORMAT_WEIGHTS: int;
+  /** Mesh array uses indices. */
+  static readonly ARRAY_FORMAT_INDEX: int;
+  /** Mask of mesh channels permitted in blend shapes. */
+  static readonly ARRAY_FORMAT_BLEND_SHAPE_MASK: int;
+  /** Shift of first custom channel. */
+  static readonly ARRAY_FORMAT_CUSTOM_BASE: int;
+  /** Number of format bits per custom channel. See {@link ArrayCustomFormat}. */
+  static readonly ARRAY_FORMAT_CUSTOM_BITS: int;
+  /** Amount to shift {@link ArrayCustomFormat} for custom channel index 0. */
+  static readonly ARRAY_FORMAT_CUSTOM0_SHIFT: int;
+  /** Amount to shift {@link ArrayCustomFormat} for custom channel index 1. */
+  static readonly ARRAY_FORMAT_CUSTOM1_SHIFT: int;
+  /** Amount to shift {@link ArrayCustomFormat} for custom channel index 2. */
+  static readonly ARRAY_FORMAT_CUSTOM2_SHIFT: int;
+  /** Amount to shift {@link ArrayCustomFormat} for custom channel index 3. */
+  static readonly ARRAY_FORMAT_CUSTOM3_SHIFT: int;
+  /**
+   * Mask of custom format bits per custom channel. Must be shifted by one of the SHIFT constants. See {@link ArrayCustomFormat}.
+   */
+  static readonly ARRAY_FORMAT_CUSTOM_MASK: int;
+  /**
+   * Shift of first compress flag. Compress flags should be passed to {@link ArrayMesh.add_surface_from_arrays} and {@link SurfaceTool.commit}.
+   */
+  static readonly ARRAY_COMPRESS_FLAGS_BASE: int;
+  /** Flag used to mark that the array contains 2D vertices. */
+  static readonly ARRAY_FLAG_USE_2D_VERTICES: int;
+  /** Flag used to mark that the mesh data will use `GL_DYNAMIC_DRAW` on GLES. Unused on Vulkan. */
+  static readonly ARRAY_FLAG_USE_DYNAMIC_UPDATE: int;
+  /**
+   * Flag used to mark that the mesh contains up to 8 bone influences per vertex. This flag indicates that {@link ARRAY_BONES} and {@link ARRAY_WEIGHTS} elements will have double length.
+   */
+  static readonly ARRAY_FLAG_USE_8_BONE_WEIGHTS: int;
+  /** Flag used to mark that the mesh intentionally contains no vertex array. */
+  static readonly ARRAY_FLAG_USES_EMPTY_VERTEX_ARRAY: int;
+  /**
+   * Flag used to mark that a mesh is using compressed attributes (vertices, normals, tangents, UVs). When this form of compression is enabled, vertex positions will be packed into an RGBA16UNORM attribute and scaled in the vertex shader. The normal and tangent will be packed into an RG16UNORM representing an axis, and a 16-bit float stored in the A-channel of the vertex. UVs will use 16-bit normalized floats instead of full 32-bit signed floats. When using this compression mode you must use either vertices, normals, and tangents or only vertices. You cannot use normals without tangents. Importers will automatically enable this compression if they can.
+   */
+  static readonly ARRAY_FLAG_COMPRESS_ATTRIBUTES: int;
+  // enum BlendShapeMode
+  /** Blend shapes are normalized. */
+  static readonly BLEND_SHAPE_MODE_NORMALIZED: int;
+  /** Blend shapes are relative to base weight. */
+  static readonly BLEND_SHAPE_MODE_RELATIVE: int;
+}

package/typings/classes/MeshConvexDecompositionSettings.d.ts

@@ -0,0 +1,68 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Parameters to be used with a {@link Mesh} convex decomposition operation. */
+declare class MeshConvexDecompositionSettings extends RefCounted {
+  /** If `true`, uses approximation for computing convex hulls. */
+  convex_hull_approximation: boolean;
+  /**
+   * Controls the precision of the convex-hull generation process during the clipping plane selection stage. Ranges from `1` to `16`.
+   */
+  convex_hull_downsampling: int;
+  /** Maximum concavity. Ranges from `0.0` to `1.0`. */
+  max_concavity: float;
+  /** The maximum number of convex hulls to produce from the merge operation. */
+  max_convex_hulls: int;
+  /** Controls the maximum number of triangles per convex-hull. Ranges from `4` to `1024`. */
+  max_num_vertices_per_convex_hull: int;
+  /** Controls the adaptive sampling of the generated convex-hulls. Ranges from `0.0` to `0.01`. */
+  min_volume_per_convex_hull: float;
+  /** Mode for the approximate convex decomposition. */
+  mode: int;
+  /** If `true`, normalizes the mesh before applying the convex decomposition. */
+  normalize_mesh: boolean;
+  /** Controls the granularity of the search for the "best" clipping plane. Ranges from `1` to `16`. */
+  plane_downsampling: int;
+  /**
+   * If `true`, projects output convex hull vertices onto the original source mesh to increase floating-point accuracy of the results.
+   */
+  project_hull_vertices: boolean;
+  /** Maximum number of voxels generated during the voxelization stage. */
+  resolution: int;
+  /** Controls the bias toward clipping along revolution axes. Ranges from `0.0` to `1.0`. */
+  revolution_axes_clipping_bias: float;
+  /** Controls the bias toward clipping along symmetry planes. Ranges from `0.0` to `1.0`. */
+  symmetry_planes_clipping_bias: float;
+  set_convex_hull_approximation(value: boolean): void;
+  get_convex_hull_approximation(): boolean;
+  set_convex_hull_downsampling(value: int): void;
+  get_convex_hull_downsampling(): int;
+  set_max_concavity(value: float): void;
+  get_max_concavity(): float;
+  set_max_convex_hulls(value: int): void;
+  get_max_convex_hulls(): int;
+  set_max_num_vertices_per_convex_hull(value: int): void;
+  get_max_num_vertices_per_convex_hull(): int;
+  set_min_volume_per_convex_hull(value: float): void;
+  get_min_volume_per_convex_hull(): float;
+  set_mode(value: int): void;
+  get_mode(): int;
+  set_normalize_mesh(value: boolean): void;
+  get_normalize_mesh(): boolean;
+  set_plane_downsampling(value: int): void;
+  get_plane_downsampling(): int;
+  set_project_hull_vertices(value: boolean): void;
+  get_project_hull_vertices(): boolean;
+  set_resolution(value: int): void;
+  get_resolution(): int;
+  set_revolution_axes_clipping_bias(value: float): void;
+  get_revolution_axes_clipping_bias(): float;
+  set_symmetry_planes_clipping_bias(value: float): void;
+  get_symmetry_planes_clipping_bias(): float;
+
+  // enum Mode
+  /** Constant for voxel-based approximate convex decomposition. */
+  static readonly CONVEX_DECOMPOSITION_MODE_VOXEL: int;
+  /** Constant for tetrahedron-based approximate convex decomposition. */
+  static readonly CONVEX_DECOMPOSITION_MODE_TETRAHEDRON: int;
+}

package/typings/classes/MeshDataTool.d.ts

@@ -0,0 +1,99 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Helper tool to access and edit {@link Mesh} data. */
+declare class MeshDataTool extends RefCounted {
+  /** Clears all data currently in MeshDataTool. */
+  clear(): void;
+  /** Adds a new surface to specified {@link Mesh} with edited data. */
+  commit_to_surface(mesh: ArrayMesh, compression_flags?: int): int;
+  /**
+   * Uses specified surface of given {@link Mesh} to populate data for MeshDataTool.
+   * Requires {@link Mesh} with primitive type {@link Mesh.PRIMITIVE_TRIANGLES}.
+   */
+  create_from_surface(mesh: ArrayMesh, surface: int): int;
+  /** Returns the number of edges in this {@link Mesh}. */
+  get_edge_count(): int;
+  /** Returns array of faces that touch given edge. */
+  get_edge_faces(idx: int): PackedInt32Array;
+  /** Returns meta information assigned to given edge. */
+  get_edge_meta(idx: int): unknown;
+  /**
+   * 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.
+   */
+  get_edge_vertex(idx: int, vertex: int): int;
+  /** Returns the number of faces in this {@link Mesh}. */
+  get_face_count(): int;
+  /**
+   * 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.
+   */
+  get_face_edge(idx: int, edge: int): int;
+  /** Returns the metadata associated with the given face. */
+  get_face_meta(idx: int): unknown;
+  /** Calculates and returns the face normal of the given face. */
+  get_face_normal(idx: int): Vector3;
+  /**
+   * Returns the specified vertex index of the given face.
+   * `vertex` must be either `0`, `1`, or `2` because faces contain three vertices.
+   */
+  get_face_vertex(idx: int, vertex: int): int;
+  /**
+   * 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`.
+   */
+  get_format(): int;
+  /** Returns the material assigned to the {@link Mesh}. */
+  get_material(): Material | null;
+  /** Returns the position of the given vertex. */
+  get_vertex(idx: int): Vector3;
+  /** Returns the bones of the given vertex. */
+  get_vertex_bones(idx: int): PackedInt32Array;
+  /** Returns the color of the given vertex. */
+  get_vertex_color(idx: int): Color;
+  /** Returns the total number of vertices in {@link Mesh}. */
+  get_vertex_count(): int;
+  /** Returns an array of edges that share the given vertex. */
+  get_vertex_edges(idx: int): PackedInt32Array;
+  /** Returns an array of faces that share the given vertex. */
+  get_vertex_faces(idx: int): PackedInt32Array;
+  /** Returns the metadata associated with the given vertex. */
+  get_vertex_meta(idx: int): unknown;
+  /** Returns the normal of the given vertex. */
+  get_vertex_normal(idx: int): Vector3;
+  /** Returns the tangent of the given vertex. */
+  get_vertex_tangent(idx: int): Plane;
+  /** Returns the UV of the given vertex. */
+  get_vertex_uv(idx: int): Vector2;
+  /** Returns the UV2 of the given vertex. */
+  get_vertex_uv2(idx: int): Vector2;
+  /** Returns bone weights of the given vertex. */
+  get_vertex_weights(idx: int): PackedFloat32Array;
+  /** Sets the metadata of the given edge. */
+  set_edge_meta(idx: int, meta: unknown): void;
+  /** Sets the metadata of the given face. */
+  set_face_meta(idx: int, meta: unknown): void;
+  /** Sets the material to be used by newly-constructed {@link Mesh}. */
+  set_material(material: Material): void;
+  /** Sets the position of the given vertex. */
+  set_vertex(idx: int, vertex: Vector3 | Vector3i): void;
+  /** Sets the bones of the given vertex. */
+  set_vertex_bones(idx: int, bones: PackedInt32Array | Array<unknown>): void;
+  /** Sets the color of the given vertex. */
+  set_vertex_color(idx: int, color: Color): void;
+  /** Sets the metadata associated with the given vertex. */
+  set_vertex_meta(idx: int, meta: unknown): void;
+  /** Sets the normal of the given vertex. */
+  set_vertex_normal(idx: int, normal: Vector3 | Vector3i): void;
+  /**
+   * 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}.
+   */
+  set_vertex_tangent(idx: int, tangent: Plane): void;
+  /** Sets the UV of the given vertex. */
+  set_vertex_uv(idx: int, uv: Vector2 | Vector2i): void;
+  /** Sets the UV2 of the given vertex. */
+  set_vertex_uv2(idx: int, uv2: Vector2 | Vector2i): void;
+  /** Sets the bone weights of the given vertex. */
+  set_vertex_weights(idx: int, weights: PackedFloat32Array | Array<unknown>): void;
+}

package/typings/classes/MeshInstance2D.d.ts

@@ -0,0 +1,19 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Node used for displaying a {@link Mesh} in 2D. */
+declare class MeshInstance2D extends Node2D {
+  /** The {@link Mesh} that will be drawn by the {@link MeshInstance2D}. */
+  mesh: Mesh | null;
+  /**
+   * The {@link Texture2D} that will be used if using the default {@link CanvasItemMaterial}. Can be accessed as `TEXTURE` in CanvasItem shader.
+   */
+  texture: Texture2D | null;
+  set_mesh(value: Mesh | null): void;
+  get_mesh(): Mesh | null;
+  set_texture(value: Texture2D | null): void;
+  get_texture(): Texture2D | null;
+
+  /** Emitted when the {@link texture} is changed. */
+  texture_changed: Signal<[]>;
+}

package/typings/classes/MeshInstance3D.d.ts

@@ -0,0 +1,87 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Node that instances meshes into a scenario. */
+declare class MeshInstance3D extends GeometryInstance3D {
+  /** The {@link Mesh} resource for the instance. */
+  mesh: Mesh | null;
+  /**
+   * {@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/default_parent_skeleton_in_mesh_instance_3d} if the old behavior is needed for compatibility.
+   */
+  skeleton: NodePath;
+  /** The {@link Skin} to be used by this instance. */
+  skin: Skin | null;
+  set_mesh(value: Mesh | null): void;
+  get_mesh(): Mesh | null;
+  set_skeleton_path(value: NodePath | string): void;
+  get_skeleton_path(): NodePath;
+  set_skin(value: Skin | null): void;
+  get_skin(): Skin | null;
+
+  /**
+   * 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.
+   */
+  bake_mesh_from_current_blend_shape_mix(existing?: ArrayMesh): ArrayMesh | null;
+  /**
+   * 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.
+   */
+  bake_mesh_from_current_skeleton_pose(existing?: ArrayMesh): ArrayMesh | null;
+  /**
+   * 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.
+   */
+  create_convex_collision(clean?: boolean, simplify?: boolean): void;
+  /**
+   * This helper creates a {@link MeshInstance3D} child node with gizmos at every vertex calculated from the mesh geometry. It's mainly used for testing.
+   */
+  create_debug_tangents(): void;
+  /**
+   * 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`.
+   */
+  create_multiple_convex_collisions(settings?: MeshConvexDecompositionSettings): void;
+  /**
+   * 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.
+   */
+  create_trimesh_collision(): void;
+  /**
+   * 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`.
+   */
+  find_blend_shape_by_name(name: string): int;
+  /**
+   * Returns the {@link Material} that will be used by the {@link Mesh} when drawing. This can return the {@link GeometryInstance3D.material_override}, 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.material_override} is used, all surfaces will return the override material.
+   * Returns `null` if no material is active, including when {@link mesh} is `null`.
+   */
+  get_active_material(surface: int): Material | null;
+  /** Returns the number of blend shapes available. Produces an error if {@link mesh} is `null`. */
+  get_blend_shape_count(): int;
+  /**
+   * Returns the value of the blend shape at the given `blend_shape_idx`. Returns `0.0` and produces an error if {@link mesh} is `null` or doesn't have a blend shape at that index.
+   */
+  get_blend_shape_value(blend_shape_idx: int): float;
+  /**
+   * Returns the internal {@link SkinReference} containing the skeleton's {@link RID} attached to this RID. See also {@link Resource.get_rid}, {@link SkinReference.get_skeleton}, and {@link RenderingServer.instance_attach_skeleton}.
+   */
+  get_skin_reference(): SkinReference | null;
+  /**
+   * Returns the override {@link Material} for the specified `surface` of the {@link Mesh} resource. See also {@link get_surface_override_material_count}.
+   * **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.surface_get_material} instead.
+   */
+  get_surface_override_material(surface: int): Material | null;
+  /**
+   * Returns the number of surface override materials. This is equivalent to {@link Mesh.get_surface_count}. See also {@link get_surface_override_material}.
+   */
+  get_surface_override_material_count(): int;
+  /**
+   * Sets the value of the blend shape at `blend_shape_idx` to `value`. Produces an error if {@link mesh} is `null` or doesn't have a blend shape at that index.
+   */
+  set_blend_shape_value(blend_shape_idx: int, value: float): void;
+  /**
+   * 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.surface_set_material} instead.
+   */
+  set_surface_override_material(surface: int, material: Material): void;
+}

package/typings/classes/MeshLibrary.d.ts

@@ -0,0 +1,68 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Library of meshes. */
+declare class MeshLibrary extends Resource {
+  /** Clears the library. */
+  clear(): void;
+  /**
+   * Creates a new item in the library with the given ID.
+   * You can get an unused ID from {@link get_last_unused_item_id}.
+   */
+  create_item(id: int): void;
+  /** Returns the first item with the given name, or `-1` if no item is found. */
+  find_item_by_name(name: string | NodePath): int;
+  /** Returns the list of item IDs in use. */
+  get_item_list(): PackedInt32Array;
+  /** Returns the item's mesh. */
+  get_item_mesh(id: int): Mesh | null;
+  /** Returns the item's shadow casting mode. */
+  get_item_mesh_cast_shadow(id: int): int;
+  /** Returns the transform applied to the item's mesh. */
+  get_item_mesh_transform(id: int): Transform3D;
+  /** Returns the item's name. */
+  get_item_name(id: int): string;
+  /** Returns the item's navigation layers bitmask. */
+  get_item_navigation_layers(id: int): int;
+  /** Returns the item's navigation mesh. */
+  get_item_navigation_mesh(id: int): NavigationMesh | null;
+  /** Returns the transform applied to the item's navigation mesh. */
+  get_item_navigation_mesh_transform(id: int): Transform3D;
+  /**
+   * 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 set_item_preview}. Returns an empty {@link Texture2D} if no preview was manually set in a running project.
+   */
+  get_item_preview(id: int): Texture2D | null;
+  /**
+   * Returns an item's collision shapes.
+   * The array consists of each {@link Shape3D} followed by its {@link Transform3D}.
+   */
+  get_item_shapes(id: int): Array<unknown>;
+  /** Gets an unused ID for a new item. */
+  get_last_unused_item_id(): int;
+  /** Removes the item. */
+  remove_item(id: int): void;
+  /** Sets the item's mesh. */
+  set_item_mesh(id: int, mesh: Mesh): void;
+  /** Sets the item's shadow casting mode to `shadow_casting_setting`. */
+  set_item_mesh_cast_shadow(id: int, shadow_casting_setting: int): void;
+  /** Sets the transform to apply to the item's mesh. */
+  set_item_mesh_transform(id: int, mesh_transform: Transform3D | Projection): void;
+  /**
+   * 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 find_item_by_name}.
+   */
+  set_item_name(id: int, name: string | NodePath): void;
+  /** Sets the item's navigation layers bitmask. */
+  set_item_navigation_layers(id: int, navigation_layers: int): void;
+  /** Sets the item's navigation mesh. */
+  set_item_navigation_mesh(id: int, navigation_mesh: NavigationMesh): void;
+  /** Sets the transform to apply to the item's navigation mesh. */
+  set_item_navigation_mesh_transform(id: int, navigation_mesh: Transform3D | Projection): void;
+  /** Sets a texture to use as the item's preview icon in the editor. */
+  set_item_preview(id: int, texture: Texture2D): void;
+  /**
+   * 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}.
+   */
+  set_item_shapes(id: int, shapes: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): void;
+}

package/typings/classes/MeshTexture.d.ts

@@ -0,0 +1,19 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Simple texture that uses a mesh to draw itself. */
+declare class MeshTexture extends Texture2D {
+  /** Sets the base texture that the Mesh will use to draw. */
+  base_texture: Texture2D | null;
+  /** Sets the size of the image, needed for reference. */
+  image_size: Vector2;
+  /** Sets the mesh used to draw. It must be a mesh using 2D vertices. */
+  mesh: Mesh | null;
+  resource_local_to_scene: boolean;
+  set_base_texture(value: Texture2D | null): void;
+  get_base_texture(): Texture2D | null;
+  set_image_size(value: Vector2 | Vector2i): void;
+  get_image_size(): Vector2;
+  set_mesh(value: Mesh | null): void;
+  get_mesh(): Mesh | null;
+}

package/typings/classes/MethodTweener.d.ts

@@ -0,0 +1,18 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Interpolates an abstract value and supplies it to a method called over time. */
+declare class MethodTweener extends Tweener {
+  /**
+   * Sets the time in seconds after which the {@link MethodTweener} will start interpolating. By default there's no delay.
+   */
+  set_delay(delay: float): 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.
+   */
+  set_ease(ease: int): 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.
+   */
+  set_trans(trans: int): MethodTweener;
+}