@ringozz/godot 0.1.0

package/gen/classes/MenuBar.ts

@@ -0,0 +1,114 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Control } from './Control.ts';
+import type { TextDirection } from './Control.ts';
+import type { PopupMenu } from './PopupMenu.ts';
+
+/**
+ * A horizontal menu bar that creates a menu for each {@link PopupMenu} child. New items are created by adding {@link PopupMenu}s to this node. Item title is determined by {@link Window.title}, or node name if {@link Window.title} is empty. Item title can be overridden using {@link setMenuTitle}.
+ */
+export class MenuBar extends Control {
+    constructor(name = 408) { super(name); }
+
+    /**
+     * If `true`, shortcuts are disabled and cannot be used to trigger the button.
+     */
+    setDisableShortcuts(disabled: boolean): void { _C(this, 11121, disabled); }
+
+    /**
+     * Returns `true` if the current system's global menu is supported and used by this {@link MenuBar}.
+     */
+    isNativeMenu(): boolean { return _C(this, 8126) as boolean; }
+
+    /**
+     * Returns number of menu items.
+     */
+    getMenuCount(): number { return _C(this, 5506) as number; }
+
+    /**
+     * Sets menu item title.
+     */
+    setMenuTitle(menu: number, title: string): void { _C(this, 12022, menu, title); }
+
+    /**
+     * Returns menu item title.
+     */
+    getMenuTitle(menu: number): string { return _C(this, 5509, menu) as string; }
+
+    /**
+     * Sets menu item tooltip.
+     */
+    setMenuTooltip(menu: number, tooltip: string): void { _C(this, 12023, menu, tooltip); }
+
+    /**
+     * Returns menu item tooltip.
+     */
+    getMenuTooltip(menu: number): string { return _C(this, 5510, menu) as string; }
+
+    /**
+     * If `true`, menu item is disabled.
+     */
+    setMenuDisabled(menu: number, disabled: boolean): void { _C(this, 12020, menu, disabled); }
+
+    /**
+     * Returns `true` if the menu item is disabled.
+     */
+    isMenuDisabled(menu: number): boolean { return _C(this, 8099, menu) as boolean; }
+
+    /**
+     * If `true`, menu item is hidden.
+     */
+    setMenuHidden(menu: number, hidden: boolean): void { _C(this, 12021, menu, hidden); }
+
+    /**
+     * Returns `true` if the menu item is hidden.
+     */
+    isMenuHidden(menu: number): boolean { return _C(this, 8100, menu) as boolean; }
+
+    /**
+     * Returns {@link PopupMenu} associated with menu item.
+     */
+    getMenuPopup(menu: number): PopupMenu { return _C(this, 5508, menu) as PopupMenu; }
+
+    /**
+     * Flat {@link MenuBar} don't display item decoration.
+     */
+    get flat(): boolean { return _C(this, 7956) as boolean; }
+    set flat(v: boolean) { _C(this, 11413, v); }
+
+    /**
+     * Position order in the global menu to insert {@link MenuBar} items at. All menu items in the {@link MenuBar} are always inserted as a continuous range. Menus with lower {@link startIndex} are inserted first. Menus with {@link startIndex} equal to `-1` are inserted last.
+     */
+    get startIndex(): number { return _C(this, 6534) as number; }
+    set startIndex(v: number) { _C(this, 12879, v); }
+
+    /**
+     * If `true`, when the cursor hovers above menu item, it will close the current {@link PopupMenu} and open the other one.
+     */
+    get switchOnHover(): boolean { return _C(this, 8350) as boolean; }
+    set switchOnHover(v: boolean) { _C(this, 12949, v); }
+
+    /**
+     * If `true`, {@link MenuBar} will use system global menu when supported.
+     * **Note:** If `true` and global menu is supported, this node is not displayed, has zero size, and all its child nodes except {@link PopupMenu}s are inaccessible.
+     * **Note:** This property overrides the value of the {@link PopupMenu.preferNativeMenu} property of the child nodes.
+     */
+    get preferGlobalMenu(): boolean { return _C(this, 8197) as boolean; }
+    set preferGlobalMenu(v: boolean) { _C(this, 12396, v); }
+
+    /**
+     * Base text writing direction.
+     */
+    get textDirection(): TextDirection { return _C(this, 6720) as TextDirection; }
+    set textDirection(v: TextDirection) { _C(this, 13022, v); }
+
+    /**
+     * Language code used for line-breaking and text shaping algorithms. If left empty, the current locale is used instead.
+     */
+    get language(): string { return _C(this, 5299) as string; }
+    set language(v: string) { _C(this, 11871, v); }
+
+    static readonly name = _R(408, MenuBar);
+}

package/gen/classes/MenuButton.ts

@@ -0,0 +1,51 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Button } from './Button.ts';
+import type { Signal } from '../heap-types/index.ts';
+import type { PopupMenu } from './PopupMenu.ts';
+
+/**
+ * A button that brings up a {@link PopupMenu} when clicked. To create new items inside this {@link PopupMenu}, use `get_popup().add_item("My Item Name")`. You can also create them directly from Godot editor's inspector.
+ * See also {@link BaseButton} which contains common properties and methods associated with this node.
+ */
+export class MenuButton extends Button {
+    constructor(name = 409) { super(name); }
+
+    /**
+     * Returns the {@link PopupMenu} contained in this button.
+     * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to hide it or any of its children, use their {@link Window.visible} property.
+     */
+    getPopup(): PopupMenu { return _C(this, 5966) as PopupMenu; }
+
+    /**
+     * Adjusts popup position and sizing for the {@link MenuButton}, then shows the {@link PopupMenu}. Prefer this over using `get_popup().popup()`.
+     */
+    showPopup(): void { _C(this, 13583); }
+
+    /**
+     * If `true`, shortcuts are disabled and cannot be used to trigger the button.
+     */
+    setDisableShortcuts(disabled: boolean): void { _C(this, 11121, disabled); }
+
+    /**
+     * If `true`, when the cursor hovers above another {@link MenuButton} within the same parent which also has {@link switchOnHover} enabled, it will close the current {@link MenuButton} and open the other one.
+     */
+    get switchOnHover(): boolean { return _C(this, 8350) as boolean; }
+    set switchOnHover(v: boolean) { _C(this, 12949, v); }
+
+    /**
+     * The number of items currently in the list.
+     */
+    get itemCount(): number { return _C(this, 5181) as number; }
+    set itemCount(v: number) { _C(this, 11766, v); }
+
+    /**
+     * Emitted when the {@link PopupMenu} of this MenuButton is about to show.
+     */
+    get aboutToPopup(): Signal<() => void> { return _G(this, 1052) as Signal<() => void>; }
+    set aboutToPopup(v: (() => void) | null) { _G(this, 1052, v); }
+
+    static readonly name = _R(409, MenuButton);
+}

package/gen/classes/Mesh.ts

@@ -0,0 +1,348 @@
+// 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, PackedVector3Array, StringName } from '../heap-types/index.ts';
+import type { AABB, Vector2i } from '../value-types/index.ts';
+import type { ConcavePolygonShape3D } from './ConcavePolygonShape3D.ts';
+import type { ConvexPolygonShape3D } from './ConvexPolygonShape3D.ts';
+import type { Material } from './Material.ts';
+import type { TriangleMesh } from './TriangleMesh.ts';
+
+/**
+ * Mesh is a type of {@link Resource} that 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. The maximum number of surfaces per mesh is {@link RenderingServer.MAX_MESH_SURFACES}.
+ */
+export class Mesh extends Resource {
+    constructor(name = 410) { super(name); }
+
+    /**
+     * 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}.
+     */
+    getAabb(): AABB { return _C(this, 3659) as AABB; }
+
+    /**
+     * Returns all the vertices that make up the faces of the mesh. Each three vertices represent one triangle.
+     */
+    getFaces(): PackedVector3Array { return _C(this, 4736) as PackedVector3Array; }
+
+    /**
+     * Returns the number of surfaces that the {@link Mesh} holds. This is equivalent to {@link MeshInstance3D.getSurfaceOverrideMaterialCount}.
+     */
+    getSurfaceCount(): number { return _C(this, 6625) as number; }
+
+    /**
+     * Returns the arrays for the vertices, normals, UVs, etc. that make up the requested surface (see {@link ArrayMesh.addSurfaceFromArrays}).
+     */
+    surfaceGetArrays(surfIdx: number): GodotArray { return _C(this, 14030, surfIdx) as GodotArray; }
+
+    /**
+     * Returns the blend shape arrays for the requested surface.
+     */
+    surfaceGetBlendShapeArrays(surfIdx: number): GodotArray<GodotArray> { return _C(this, 14031, surfIdx) as GodotArray<GodotArray>; }
+
+    /**
+     * 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.setSurfaceOverrideMaterial} instead.
+     */
+    surfaceSetMaterial(surfIdx: number, material: Material): void { _C(this, 14039, surfIdx, material); }
+
+    /**
+     * 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.getSurfaceOverrideMaterial} instead.
+     */
+    surfaceGetMaterial(surfIdx: number): Material { return _C(this, 14033, surfIdx) as Material; }
+
+    /**
+     * Creates a placeholder version of this resource ({@link PlaceholderMesh}).
+     */
+    createPlaceholder(): Resource { return _C(this, 2563) as Resource; }
+
+    /**
+     * Calculate a {@link ConcavePolygonShape3D} from the mesh.
+     */
+    createTrimeshShape(): ConcavePolygonShape3D { return _C(this, 2583) as ConcavePolygonShape3D; }
+
+    /**
+     * 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.
+     */
+    createConvexShape(clean?: boolean /* = true */, simplify?: boolean /* = false */): ConvexPolygonShape3D { return _C(this, 2515, clean, simplify) as 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).
+     */
+    createOutline(margin: number): Mesh { return _C(this, 2559, margin) as Mesh; }
+
+    /**
+     * Generate a {@link TriangleMesh} from the mesh. Considers only surfaces using one of these primitive types: {@link PRIMITIVE_TRIANGLES}, {@link PRIMITIVE_TRIANGLE_STRIP}.
+     */
+    generateTriangleMesh(): TriangleMesh { return _C(this, 3642) as TriangleMesh; }
+
+    /**
+     * Sets a hint to be used for lightmap resolution.
+     */
+    get lightmapSizeHint(): Vector2i { return _C(this, 5344) as Vector2i; }
+    set lightmapSizeHint(v: Vector2i) { _C(this, 11901, v); }
+
+    static readonly name = _R(410, Mesh);
+}
+
+export const PrimitiveType = {
+    /**
+     * Render array as points (one vertex equals one point).
+     */
+    PRIMITIVE_POINTS: 0,
+    /**
+     * Render array as lines (every two vertices a line is created).
+     */
+    PRIMITIVE_LINES: 1,
+    /**
+     * Render array as line strip.
+     */
+    PRIMITIVE_LINE_STRIP: 2,
+    /**
+     * Render array as triangles (every three vertices a triangle is created).
+     */
+    PRIMITIVE_TRIANGLES: 3,
+    /**
+     * Render array as triangle strips.
+     */
+    PRIMITIVE_TRIANGLE_STRIP: 4,
+} as const;
+
+export type PrimitiveType = (typeof PrimitiveType)[keyof typeof PrimitiveType];
+
+export const ArrayType = {
+    /**
+     * {@link PackedVector3Array}, {@link PackedVector2Array}, or {@link Array} of vertex positions.
+     */
+    ARRAY_VERTEX: 0,
+    /**
+     * {@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.
+     */
+    ARRAY_NORMAL: 1,
+    /**
+     * {@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.
+     */
+    ARRAY_TANGENT: 2,
+    /**
+     * {@link PackedColorArray} of vertex colors.
+     */
+    ARRAY_COLOR: 3,
+    /**
+     * {@link PackedVector2Array} for UV coordinates.
+     */
+    ARRAY_TEX_UV: 4,
+    /**
+     * {@link PackedVector2Array} for second UV coordinates.
+     */
+    ARRAY_TEX_UV2: 5,
+    /**
+     * 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.
+     */
+    ARRAY_CUSTOM0: 6,
+    /**
+     * 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.
+     */
+    ARRAY_CUSTOM1: 7,
+    /**
+     * 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.
+     */
+    ARRAY_CUSTOM2: 8,
+    /**
+     * 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.
+     */
+    ARRAY_CUSTOM3: 9,
+    /**
+     * {@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.
+     */
+    ARRAY_BONES: 10,
+    /**
+     * {@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.
+     */
+    ARRAY_WEIGHTS: 11,
+    /**
+     * {@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.
+     */
+    ARRAY_INDEX: 12,
+    /**
+     * Represents the size of the {@link ArrayType} enum.
+     */
+    ARRAY_MAX: 13,
+} as const;
+
+export type ArrayType = (typeof ArrayType)[keyof typeof ArrayType];
+
+export const ArrayCustomFormat = {
+    /**
+     * Indicates this custom channel contains unsigned normalized byte colors from 0 to 1, encoded as {@link PackedByteArray}.
+     */
+    ARRAY_CUSTOM_RGBA8_UNORM: 0,
+    /**
+     * Indicates this custom channel contains signed normalized byte colors from -1 to 1, encoded as {@link PackedByteArray}.
+     */
+    ARRAY_CUSTOM_RGBA8_SNORM: 1,
+    /**
+     * Indicates this custom channel contains half precision float colors, encoded as {@link PackedByteArray}. Only red and green channels are used.
+     */
+    ARRAY_CUSTOM_RG_HALF: 2,
+    /**
+     * Indicates this custom channel contains half precision float colors, encoded as {@link PackedByteArray}.
+     */
+    ARRAY_CUSTOM_RGBA_HALF: 3,
+    /**
+     * Indicates this custom channel contains full float colors, in a {@link PackedFloat32Array}. Only the red channel is used.
+     */
+    ARRAY_CUSTOM_R_FLOAT: 4,
+    /**
+     * Indicates this custom channel contains full float colors, in a {@link PackedFloat32Array}. Only red and green channels are used.
+     */
+    ARRAY_CUSTOM_RG_FLOAT: 5,
+    /**
+     * Indicates this custom channel contains full float colors, in a {@link PackedFloat32Array}. Only red, green and blue channels are used.
+     */
+    ARRAY_CUSTOM_RGB_FLOAT: 6,
+    /**
+     * Indicates this custom channel contains full float colors, in a {@link PackedFloat32Array}.
+     */
+    ARRAY_CUSTOM_RGBA_FLOAT: 7,
+    /**
+     * Represents the size of the {@link ArrayCustomFormat} enum.
+     */
+    ARRAY_CUSTOM_MAX: 8,
+} as const;
+
+export type ArrayCustomFormat = (typeof ArrayCustomFormat)[keyof typeof ArrayCustomFormat];
+
+export const ArrayFormat = {
+    /**
+     * Mesh array contains vertices. All meshes require a vertex array so this should always be present.
+     */
+    ARRAY_FORMAT_VERTEX: 1,
+    /**
+     * Mesh array contains normals.
+     */
+    ARRAY_FORMAT_NORMAL: 2,
+    /**
+     * Mesh array contains tangents.
+     */
+    ARRAY_FORMAT_TANGENT: 4,
+    /**
+     * Mesh array contains colors.
+     */
+    ARRAY_FORMAT_COLOR: 8,
+    /**
+     * Mesh array contains UVs.
+     */
+    ARRAY_FORMAT_TEX_UV: 16,
+    /**
+     * Mesh array contains second UV.
+     */
+    ARRAY_FORMAT_TEX_UV2: 32,
+    /**
+     * Mesh array contains custom channel index 0.
+     */
+    ARRAY_FORMAT_CUSTOM0: 64,
+    /**
+     * Mesh array contains custom channel index 1.
+     */
+    ARRAY_FORMAT_CUSTOM1: 128,
+    /**
+     * Mesh array contains custom channel index 2.
+     */
+    ARRAY_FORMAT_CUSTOM2: 256,
+    /**
+     * Mesh array contains custom channel index 3.
+     */
+    ARRAY_FORMAT_CUSTOM3: 512,
+    /**
+     * Mesh array contains bones.
+     */
+    ARRAY_FORMAT_BONES: 1024,
+    /**
+     * Mesh array contains bone weights.
+     */
+    ARRAY_FORMAT_WEIGHTS: 2048,
+    /**
+     * Mesh array uses indices.
+     */
+    ARRAY_FORMAT_INDEX: 4096,
+    /**
+     * Mask of mesh channels permitted in blend shapes.
+     */
+    ARRAY_FORMAT_BLEND_SHAPE_MASK: 7,
+    /**
+     * Shift of first custom channel.
+     */
+    ARRAY_FORMAT_CUSTOM_BASE: 13,
+    /**
+     * Number of format bits per custom channel. See {@link ArrayCustomFormat}.
+     */
+    ARRAY_FORMAT_CUSTOM_BITS: 3,
+    /**
+     * Amount to shift {@link ArrayCustomFormat} for custom channel index 0.
+     */
+    ARRAY_FORMAT_CUSTOM0_SHIFT: 13,
+    /**
+     * Amount to shift {@link ArrayCustomFormat} for custom channel index 1.
+     */
+    ARRAY_FORMAT_CUSTOM1_SHIFT: 16,
+    /**
+     * Amount to shift {@link ArrayCustomFormat} for custom channel index 2.
+     */
+    ARRAY_FORMAT_CUSTOM2_SHIFT: 19,
+    /**
+     * Amount to shift {@link ArrayCustomFormat} for custom channel index 3.
+     */
+    ARRAY_FORMAT_CUSTOM3_SHIFT: 22,
+    /**
+     * Mask of custom format bits per custom channel. Must be shifted by one of the SHIFT constants. See {@link ArrayCustomFormat}.
+     */
+    ARRAY_FORMAT_CUSTOM_MASK: 7,
+    /**
+     * Shift of first compress flag. Compress flags should be passed to {@link ArrayMesh.addSurfaceFromArrays} and {@link SurfaceTool.commit}.
+     */
+    ARRAY_COMPRESS_FLAGS_BASE: 25,
+    /**
+     * Flag used to mark that the array contains 2D vertices.
+     */
+    ARRAY_FLAG_USE_2D_VERTICES: 33554432,
+    /**
+     * Flag used to mark that the mesh data will use `GL_DYNAMIC_DRAW` on GLES. Unused on Vulkan.
+     */
+    ARRAY_FLAG_USE_DYNAMIC_UPDATE: 67108864,
+    /**
+     * 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.
+     */
+    ARRAY_FLAG_USE_8_BONE_WEIGHTS: 134217728,
+    /**
+     * Flag used to mark that the mesh intentionally contains no vertex array.
+     */
+    ARRAY_FLAG_USES_EMPTY_VERTEX_ARRAY: 268435456,
+    /**
+     * 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.
+     */
+    ARRAY_FLAG_COMPRESS_ATTRIBUTES: 536870912,
+} as const;
+
+export type ArrayFormat = (typeof ArrayFormat)[keyof typeof ArrayFormat];
+
+export const BlendShapeMode = {
+    /**
+     * Blend shapes are normalized.
+     */
+    BLEND_SHAPE_MODE_NORMALIZED: 0,
+    /**
+     * Blend shapes are relative to base weight.
+     */
+    BLEND_SHAPE_MODE_RELATIVE: 1,
+} as const;
+
+export type BlendShapeMode = (typeof BlendShapeMode)[keyof typeof BlendShapeMode];
+

package/gen/classes/MeshConvexDecompositionSettings.ts

@@ -0,0 +1,106 @@
+// 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';
+
+/**
+ * Parameters to be used with a {@link Mesh} convex decomposition operation.
+ */
+export class MeshConvexDecompositionSettings extends RefCounted {
+    constructor(name = 411) { super(name); }
+
+    /**
+     * Maximum concavity. Ranges from `0.0` to `1.0`.
+     */
+    get maxConcavity(): number { return _C(this, 5462) as number; }
+    set maxConcavity(v: number) { _C(this, 11987, v); }
+
+    /**
+     * Controls the bias toward clipping along symmetry planes. Ranges from `0.0` to `1.0`.
+     */
+    get symmetryPlanesClippingBias(): number { return _C(this, 6651) as number; }
+    set symmetryPlanesClippingBias(v: number) { _C(this, 12959, v); }
+
+    /**
+     * Controls the bias toward clipping along revolution axes. Ranges from `0.0` to `1.0`.
+     */
+    get revolutionAxesClippingBias(): number { return _C(this, 6176) as number; }
+    set revolutionAxesClippingBias(v: number) { _C(this, 12553, v); }
+
+    /**
+     * Controls the adaptive sampling of the generated convex-hulls. Ranges from `0.0` to `0.01`.
+     */
+    get minVolumePerConvexHull(): number { return _C(this, 5547) as number; }
+    set minVolumePerConvexHull(v: number) { _C(this, 12057, v); }
+
+    /**
+     * Maximum number of voxels generated during the voxelization stage.
+     */
+    get resolution(): number { return _C(this, 6154) as number; }
+    set resolution(v: number) { _C(this, 12540, v); }
+
+    /**
+     * Controls the maximum number of triangles per convex-hull. Ranges from `4` to `1024`.
+     */
+    get maxNumVerticesPerConvexHull(): number { return _C(this, 5476) as number; }
+    set maxNumVerticesPerConvexHull(v: number) { _C(this, 12000, v); }
+
+    /**
+     * Controls the granularity of the search for the "best" clipping plane. Ranges from `1` to `16`.
+     */
+    get planeDownsampling(): number { return _C(this, 5920) as number; }
+    set planeDownsampling(v: number) { _C(this, 12339, v); }
+
+    /**
+     * Controls the precision of the convex-hull generation process during the clipping plane selection stage. Ranges from `1` to `16`.
+     */
+    get convexHullDownsampling(): number { return _C(this, 4323) as number; }
+    set convexHullDownsampling(v: number) { _C(this, 10964, v); }
+
+    /**
+     * If `true`, normalizes the mesh before applying the convex decomposition.
+     */
+    get normalizeMesh(): boolean { return _C(this, 5680) as boolean; }
+    set normalizeMesh(v: boolean) { _C(this, 12151, v); }
+
+    /**
+     * Mode for the approximate convex decomposition.
+     */
+    get mode(): Mode { return _C(this, 5568) as Mode; }
+    set mode(v: Mode) { _C(this, 12073, v); }
+
+    /**
+     * If `true`, uses approximation for computing convex hulls.
+     */
+    get convexHullApproximation(): boolean { return _C(this, 4322) as boolean; }
+    set convexHullApproximation(v: boolean) { _C(this, 10963, v); }
+
+    /**
+     * The maximum number of convex hulls to produce from the merge operation.
+     */
+    get maxConvexHulls(): number { return _C(this, 5464) as number; }
+    set maxConvexHulls(v: number) { _C(this, 11989, v); }
+
+    /**
+     * If `true`, projects output convex hull vertices onto the original source mesh to increase floating-point accuracy of the results.
+     */
+    get projectHullVertices(): boolean { return _C(this, 6040) as boolean; }
+    set projectHullVertices(v: boolean) { _C(this, 12440, v); }
+
+    static readonly name = _R(411, MeshConvexDecompositionSettings);
+}
+
+export const Mode = {
+    /**
+     * Constant for voxel-based approximate convex decomposition.
+     */
+    CONVEX_DECOMPOSITION_MODE_VOXEL: 0,
+    /**
+     * Constant for tetrahedron-based approximate convex decomposition.
+     */
+    CONVEX_DECOMPOSITION_MODE_TETRAHEDRON: 1,
+} as const;
+
+export type Mode = (typeof Mode)[keyof typeof Mode];
+