@ringozz/godot 0.1.0

package/gen/classes/GLTFDocument.ts

@@ -0,0 +1,202 @@
+// 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 { Error } from '../global-enums.ts';
+import type { NodePath, PackedByteArray, PackedStringArray } from '../heap-types/index.ts';
+import type { GLTFDocumentExtension } from './GLTFDocumentExtension.ts';
+import type { GLTFObjectModelProperty } from './GLTFObjectModelProperty.ts';
+import type { GLTFState } from './GLTFState.ts';
+import type { Node } from './Node.ts';
+
+/**
+ * GLTFDocument supports reading data from a glTF file, buffer, or Godot scene. This data can then be written to the filesystem, buffer, or used to create a Godot scene.
+ * All of the data in a glTF scene is stored in the {@link GLTFState} class. GLTFDocument processes state objects, but does not contain any scene data itself. GLTFDocument has member variables to store export configuration settings such as the image format, but is otherwise stateless. Multiple scenes can be processed with the same settings using the same GLTFDocument object and different {@link GLTFState} objects.
+ * GLTFDocument can be extended with arbitrary functionality by extending the {@link GLTFDocumentExtension} class and registering it with GLTFDocument via {@link registerGltfDocumentExtension}. This allows for custom data to be imported and exported.
+ */
+export class GLTFDocument extends Resource {
+    constructor(name = 283) { super(name); }
+
+    /**
+     * Takes a path to a glTF file and imports the data at that file path to the given {@link GLTFState} object through the `state` parameter.
+     * **Note:** The `basePath` tells {@link appendFromFile} where to find dependencies and can be empty.
+     */
+    appendFromFile(path: string, state: GLTFState, flags?: number /* = 0,  uint32 */, basePath?: string /* = "" */): Error { return _C(this, 1519, path, state, flags, basePath) as Error; }
+
+    /**
+     * Takes a {@link PackedByteArray} defining a glTF and imports the data to the given {@link GLTFState} object through the `state` parameter.
+     * **Note:** The `basePath` tells {@link appendFromBuffer} where to find dependencies and can be empty.
+     */
+    appendFromBuffer(bytes: PackedByteArray, basePath: string, state: GLTFState, flags?: number /* = 0,  uint32 */): Error { return _C(this, 1518, bytes, basePath, state, flags) as Error; }
+
+    /**
+     * Takes a Godot Engine scene node and exports it and its descendants to the given {@link GLTFState} object through the `state` parameter.
+     */
+    appendFromScene(node: Node, state: GLTFState, flags?: number /* = 0,  uint32 */): Error { return _C(this, 1520, node, state, flags) as Error; }
+
+    /**
+     * Takes a {@link GLTFState} object through the `state` parameter and returns a Godot Engine scene node.
+     * The `bakeFps` parameter overrides the bake_fps in `state`.
+     */
+    generateScene(state: GLTFState, bakeFps?: number /* = 30 */, trimming?: boolean /* = false */, removeImmutableTracks?: boolean /* = true */): Node { return _C(this, 3638, state, bakeFps, trimming, removeImmutableTracks) as Node; }
+
+    /**
+     * Takes a {@link GLTFState} object through the `state` parameter and returns a glTF {@link PackedByteArray}.
+     */
+    generateBuffer(state: GLTFState): PackedByteArray { return _C(this, 3628, state) as PackedByteArray; }
+
+    /**
+     * Takes a {@link GLTFState} object through the `state` parameter and writes a glTF file to the filesystem.
+     * **Note:** The extension of the glTF file determines if it is a .glb binary file or a .gltf text file.
+     */
+    writeToFilesystem(state: GLTFState, path: string): Error { return _C(this, 14940, state, path) as Error; }
+
+    /**
+     * Determines a mapping between the given glTF Object Model `jsonPointer` and the corresponding Godot node path(s) in the generated Godot scene. The details of this mapping are returned in a {@link GLTFObjectModelProperty} object. Additional mappings can be supplied via the {@link GLTFDocumentExtension.ExportObjectModelProperty} callback method.
+     */
+    static importObjectModelProperty(state: GLTFState, jsonPointer: string): GLTFObjectModelProperty { return _C(283, 7577, state, jsonPointer) as GLTFObjectModelProperty; }
+
+    /**
+     * Determines a mapping between the given Godot `nodePath` and the corresponding glTF Object Model JSON pointer(s) in the generated glTF file. The details of this mapping are returned in a {@link GLTFObjectModelProperty} object. Additional mappings can be supplied via the {@link GLTFDocumentExtension.ImportObjectModelProperty} callback method.
+     */
+    static exportObjectModelProperty(state: GLTFState, nodePath: NodePath, godotNode: Node, gltfNodeIndex: number): GLTFObjectModelProperty { return _C(283, 3199, state, nodePath, godotNode, gltfNodeIndex) as GLTFObjectModelProperty; }
+
+    /**
+     * Registers the given {@link GLTFDocumentExtension} instance with GLTFDocument. If `firstPriority` is `true`, this extension will be run first. Otherwise, it will be run last.
+     * **Note:** Like GLTFDocument itself, all GLTFDocumentExtension classes must be stateless in order to function properly. If you need to store data, use the `set_additional_data` and `get_additional_data` methods in {@link GLTFState} or {@link GLTFNode}.
+     */
+    static registerGltfDocumentExtension(extension: GLTFDocumentExtension, firstPriority?: boolean /* = false */): void { _C(283, 9846, extension, firstPriority); }
+
+    /**
+     * Unregisters the given {@link GLTFDocumentExtension} instance.
+     */
+    static unregisterGltfDocumentExtension(extension: GLTFDocumentExtension): void { _C(283, 14490, extension); }
+
+    /**
+     * Returns a list of all support glTF extensions, including extensions supported directly by the engine, and extensions supported by user plugins registering {@link GLTFDocumentExtension} classes.
+     * **Note:** If this method is run before a GLTFDocumentExtension is registered, its extensions won't be included in the list. Be sure to only run this method after all extensions are registered. If you run this when the engine starts, consider waiting a frame before calling this method to ensure all extensions are registered.
+     */
+    static getSupportedGltfExtensions(): PackedStringArray { return _C(283, 6619) as PackedStringArray; }
+
+    /**
+     * The user-friendly name of the export image format. This is used when exporting the glTF file, including writing to a file and writing to a byte array.
+     * By default, Godot allows the following options: "None", "PNG", "JPEG", "Lossless WebP", and "Lossy WebP". Support for more image formats can be added in {@link GLTFDocumentExtension} classes. A single extension class can provide multiple options for the specific format to use, or even an option that uses multiple formats at once.
+     */
+    get imageFormat(): string { return _C(this, 5073) as string; }
+    set imageFormat(v: string) { _C(this, 11671, v); }
+
+    /**
+     * If {@link imageFormat} is a lossy image format, this determines the lossy quality of the image. On a range of `0.0` to `1.0`, where `0.0` is the lowest quality and `1.0` is the highest quality. A lossy quality of `1.0` is not the same as lossless.
+     */
+    get lossyQuality(): number { return _C(this, 5423) as number; }
+    set lossyQuality(v: number) { _C(this, 11955, v); }
+
+    /**
+     * The user-friendly name of the fallback image format. This is used when exporting the glTF file, including writing to a file and writing to a byte array.
+     * This property may only be one of "None", "PNG", or "JPEG", and is only used when the {@link imageFormat} is not one of "None", "PNG", or "JPEG". If having multiple extension image formats is desired, that can be done using a {@link GLTFDocumentExtension} class - this property only covers the use case of providing a base glTF fallback image when using a custom image format.
+     */
+    get fallbackImageFormat(): string { return _C(this, 4753) as string; }
+    set fallbackImageFormat(v: string) { _C(this, 11364, v); }
+
+    /**
+     * The quality of the fallback image, if any. For PNG files, this downscales the image on both dimensions by this factor. For JPEG files, this is the lossy quality of the image. A low value is recommended, since including multiple high quality images in a glTF file defeats the file size gains of using a more efficient image format.
+     */
+    get fallbackImageQuality(): number { return _C(this, 4754) as number; }
+    set fallbackImageQuality(v: number) { _C(this, 11365, v); }
+
+    /**
+     * How to process the root node during export. The default and recommended value is {@link ROOT_NODE_MODE_SINGLE_ROOT}.
+     * **Note:** Regardless of how the glTF file is exported, when importing, the root node type and name can be overridden in the scene import settings tab.
+     */
+    get rootNodeMode(): RootNodeMode { return _C(this, 6199) as RootNodeMode; }
+    set rootNodeMode(v: RootNodeMode) { _C(this, 12571, v); }
+
+    /**
+     * How to handle texture maps during import. The default and recommended value is {@link TEXTURE_MAP_MODE_REMAP_TO_STANDARD_MATERIAL}, which automatically remaps from glTF's flexible texture map system to the more specific texture map slots in Godot's {@link StandardMaterial3D} class. Alternatively, {@link TEXTURE_MAP_MODE_DO_NOT_REMAP} can be used to preserve the original texture maps from the glTF file, which may be desirable if using the glTF file with custom shaders, but may not display correctly with Godot's built-in materials.
+     */
+    get textureMapMode(): TextureMapMode { return _C(this, 6735) as TextureMapMode; }
+    set textureMapMode(v: TextureMapMode) { _C(this, 13031, v); }
+
+    /**
+     * How to deal with node visibility during export. This setting does nothing if all nodes are visible. The default and recommended value is {@link VISIBILITY_MODE_INCLUDE_REQUIRED}, which uses the `KHR_node_visibility` extension.
+     */
+    get visibilityMode(): VisibilityMode { return _C(this, 7093) as VisibilityMode; }
+    set visibilityMode(v: VisibilityMode) { _C(this, 13321, v); }
+
+    static readonly name = _R(283, GLTFDocument);
+}
+
+export const RootNodeMode = {
+    /**
+     * Treat the Godot scene's root node as the root node of the glTF file, and mark it as the single root node via the `GODOT_single_root` glTF extension. This will be parsed the same as {@link ROOT_NODE_MODE_KEEP_ROOT} if the implementation does not support `GODOT_single_root`.
+     */
+    ROOT_NODE_MODE_SINGLE_ROOT: 0,
+    /**
+     * Treat the Godot scene's root node as the root node of the glTF file, but do not mark it as anything special. An extra root node will be generated when importing into Godot. This uses only vanilla glTF features. This is equivalent to the behavior in Godot 4.1 and earlier.
+     */
+    ROOT_NODE_MODE_KEEP_ROOT: 1,
+    /**
+     * Treat the Godot scene's root node as the name of the glTF scene, and add all of its children as root nodes of the glTF file. This uses only vanilla glTF features. This avoids an extra root node, but only the name of the Godot scene's root node will be preserved, as it will not be saved as a node.
+     */
+    ROOT_NODE_MODE_MULTI_ROOT: 2,
+} as const;
+
+export type RootNodeMode = (typeof RootNodeMode)[keyof typeof RootNodeMode];
+
+export const TextureMapMode = {
+    /**
+     * Import the texture maps in the glTF file as they are, without trying to fit them into specific texture slots suitable for Godot's built-in materials. This may be desirable if using the glTF file with custom shaders, but may not display correctly with Godot's built-in materials. This is equivalent to the behavior in Godot 4.6 and earlier.
+     */
+    TEXTURE_MAP_MODE_DO_NOT_REMAP: 0,
+    /**
+     * Import the texture maps in the glTF file remapped to the most suitable texture slots based on Godot's {@link StandardMaterial3D} class. This is the default behavior.
+     */
+    TEXTURE_MAP_MODE_REMAP_TO_STANDARD_MATERIAL: 1,
+} as const;
+
+export type TextureMapMode = (typeof TextureMapMode)[keyof typeof TextureMapMode];
+
+export const VisibilityMode = {
+    /**
+     * If the scene contains any non-visible nodes, include them, mark them as non-visible with `KHR_node_visibility`, and require that importers respect their non-visibility. Downside: If the importer does not support `KHR_node_visibility`, the file cannot be imported.
+     */
+    VISIBILITY_MODE_INCLUDE_REQUIRED: 0,
+    /**
+     * If the scene contains any non-visible nodes, include them, mark them as non-visible with `KHR_node_visibility`, and do not impose any requirements on importers. Downside: If the importer does not support `KHR_node_visibility`, invisible objects will be visible.
+     */
+    VISIBILITY_MODE_INCLUDE_OPTIONAL: 1,
+    /**
+     * If the scene contains any non-visible nodes, do not include them in the export. This is the same as the behavior in Godot 4.4 and earlier. Downside: Invisible nodes will not exist in the exported file.
+     */
+    VISIBILITY_MODE_EXCLUDE: 2,
+} as const;
+
+export type VisibilityMode = (typeof VisibilityMode)[keyof typeof VisibilityMode];
+
+export const ImportFlags = {
+    /**
+     * If `true`, generate vertex tangents using [Mikktspace](http://www.mikktspace.com/) if the input meshes don't have tangent data. When possible, it's recommended to let the 3D modeling software generate tangents on export instead of relying on this option. Tangents are required for correct display of normal and height maps, along with any material/shader features that require tangents.
+     * If you don't need material features that require tangents, disabling this can reduce output file size and speed up importing if the source 3D file doesn't contain tangents.
+     */
+    IMPORT_FLAG_GENERATE_TANGENT_ARRAYS: 8,
+    /**
+     * If checked, use named {@link Skin}s for animation. The {@link MeshInstance3D} node contains 3 properties of relevance here: a skeleton {@link NodePath} pointing to the {@link Skeleton3D} node (usually `..`), a mesh, and a skin:
+     * - The {@link Skeleton3D} node contains a list of bones with names, their pose and rest, a name, and a parent bone.
+     * - The mesh is all of the raw vertex data needed to display a mesh. In terms of the mesh, it knows how vertices are weight-painted and uses some internal numbering often imported from 3D modeling software.
+     * - The skin contains the information necessary to bind this mesh onto this Skeleton3D. For each of the internal bone IDs chosen by the 3D modeling software, it contains two things. Firstly, a matrix known as the Bind Pose Matrix, Inverse Bind Matrix, or IBM for short. Secondly, the {@link Skin} contains each bone's name (if this flag is enabled), or the bone's index within the {@link Skeleton3D} list (if this flag is disabled).
+     * Together, this information is enough to tell Godot how to use the bone poses in the {@link Skeleton3D} node to render the mesh from each {@link MeshInstance3D}. Note that each {@link MeshInstance3D} may share binds, as is common in models exported from Blender, or each {@link MeshInstance3D} may use a separate {@link Skin} object, as is common in models exported from other tools such as Maya.
+     */
+    IMPORT_FLAG_USE_NAMED_SKIN_BINDS: 16,
+    /**
+     * Ignore meshes and materials on import. When importing a scene as an {@link AnimationLibrary}, this flag is always enabled.
+     */
+    IMPORT_FLAG_DISCARD_MESHES_AND_MATERIALS: 32,
+    /**
+     * If `true`, mesh compression will not be used. Consider enabling if you notice blocky artifacts in your mesh normals or UVs, or if you have meshes that are larger than a few thousand meters in each direction.
+     */
+    IMPORT_FLAG_FORCE_DISABLE_MESH_COMPRESSION: 64,
+} as const;
+
+export type ImportFlags = (typeof ImportFlags)[keyof typeof ImportFlags];
+

package/gen/classes/GLTFDocumentExtension.ts

@@ -0,0 +1,26 @@
+// 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 { Error } from '../global-enums.ts';
+import type { GodotArray, GodotDictionary, NodePath, PackedByteArray, PackedStringArray } from '../heap-types/index.ts';
+import type { GLTFNode } from './GLTFNode.ts';
+import type { GLTFObjectModelProperty } from './GLTFObjectModelProperty.ts';
+import type { GLTFState } from './GLTFState.ts';
+import type { GLTFTexture } from './GLTFTexture.ts';
+import type { Image } from './Image.ts';
+import type { Node } from './Node.ts';
+import type { Node3D } from './Node3D.ts';
+import type { Object } from './Object.ts';
+
+/**
+ * Extends the functionality of the {@link GLTFDocument} class by allowing you to run arbitrary code at various stages of glTF import or export.
+ * To use, make a new class extending GLTFDocumentExtension, override any methods you need, make an instance of your class, and register it using {@link GLTFDocument.registerGltfDocumentExtension}.
+ * **Note:** All GLTFDocumentExtension classes are duplicated when beginning the import or export process. Except for configuration values, these classes must be stateless in order to function properly. If you need to store data, use the `set_additional_data` and `get_additional_data` methods in {@link GLTFState} or {@link GLTFNode}.
+ */
+export class GLTFDocumentExtension extends Resource {
+    constructor(name = 284) { super(name); }
+
+    static readonly name = _R(284, GLTFDocumentExtension);
+}

package/gen/classes/GLTFDocumentExtensionConvertImporterMesh.ts

@@ -0,0 +1,11 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { GLTFDocumentExtension } from './GLTFDocumentExtension.ts';
+
+export class GLTFDocumentExtensionConvertImporterMesh extends GLTFDocumentExtension {
+    constructor(name = 285) { super(name); }
+
+    static readonly name = _R(285, GLTFDocumentExtensionConvertImporterMesh);
+}

package/gen/classes/GLTFLight.ts

@@ -0,0 +1,80 @@
+// 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 { GodotDictionary, StringName, Variant } from '../heap-types/index.ts';
+import type { Color } from '../value-types/index.ts';
+import type { Light3D } from './Light3D.ts';
+
+/**
+ * Represents a light as defined by the `KHR_lights_punctual` glTF extension.
+ */
+export class GLTFLight extends Resource {
+    constructor(name = 286) { super(name); }
+
+    /**
+     * Create a new GLTFLight instance from the given Godot {@link Light3D} node.
+     */
+    static fromNode(lightNode: Light3D): GLTFLight { return _C(286, 3599, lightNode) as GLTFLight; }
+
+    /**
+     * Converts this GLTFLight instance into a Godot {@link Light3D} node.
+     */
+    toNode(): Light3D { return _C(this, 14306) as Light3D; }
+
+    /**
+     * Creates a new GLTFLight instance by parsing the given {@link Dictionary}.
+     */
+    static fromDictionary(dictionary: GodotDictionary): GLTFLight { return _C(286, 3594, dictionary) as GLTFLight; }
+
+    /**
+     * Serializes this GLTFLight instance into a {@link Dictionary}.
+     */
+    toDictionary(): GodotDictionary { return _C(this, 14292) as GodotDictionary; }
+
+    getAdditionalData(extensionName: StringName): Variant { return _C(this, 3694, extensionName) as Variant; }
+
+    setAdditionalData(extensionName: StringName, additionalData: Variant): void { _C(this, 10428, extensionName, additionalData); }
+
+    /**
+     * The {@link Color} of the light in linear space. Defaults to white. A black color causes the light to have no effect.
+     * This value is linear to match glTF, but will be converted to nonlinear sRGB when creating a Godot {@link Light3D} node upon import, or converted to linear when exporting a Godot {@link Light3D} to glTF.
+     */
+    get color(): Color { return _C(this, 4219) as Color; }
+    set color(v: Color) { _C(this, 10905, v); }
+
+    /**
+     * The intensity of the light. This is expressed in candelas (lumens per steradian) for point and spot lights, and lux (lumens per m²) for directional lights. When creating a Godot light, this value is converted to a unitless multiplier.
+     */
+    get intensity(): number { return _C(this, 5142) as number; }
+    set intensity(v: number) { _C(this, 11733, v); }
+
+    /**
+     * The type of the light. The values accepted by Godot are "point", "spot", and "directional", which correspond to Godot's {@link OmniLight3D}, {@link SpotLight3D}, and {@link DirectionalLight3D} respectively.
+     */
+    get lightType(): string { return _C(this, 5342) as string; }
+    set lightType(v: string) { _C(this, 11899, v); }
+
+    /**
+     * The range of the light, beyond which the light has no effect. glTF lights with no range defined behave like physical lights (which have infinite range). When creating a Godot light, the range is clamped to `4096.0`.
+     */
+    get range(): number { return _C(this, 6074) as number; }
+    set range(v: number) { _C(this, 12473, v); }
+
+    /**
+     * The inner angle of the cone in a spotlight. Must be less than or equal to the outer cone angle.
+     * Within this angle, the light is at full brightness. Between the inner and outer cone angles, there is a transition from full brightness to zero brightness. When creating a Godot {@link SpotLight3D}, the ratio between the inner and outer cone angles is used to calculate the attenuation of the light.
+     */
+    get innerConeAngle(): number { return _C(this, 5104) as number; }
+    set innerConeAngle(v: number) { _C(this, 11705, v); }
+
+    /**
+     * The outer angle of the cone in a spotlight. Must be greater than or equal to the inner angle.
+     * At this angle, the light drops off to zero brightness. Between the inner and outer cone angles, there is a transition from full brightness to zero brightness. If this angle is a half turn, then the spotlight emits in all directions. When creating a Godot {@link SpotLight3D}, the outer cone angle is used as the angle of the spotlight.
+     */
+    get outerConeAngle(): number { return _C(this, 5753) as number; }
+    set outerConeAngle(v: number) { _C(this, 12212, v); }
+
+    static readonly name = _R(286, GLTFLight);
+}

package/gen/classes/GLTFMesh.ts

@@ -0,0 +1,53 @@
+// 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, PackedFloat32Array, StringName, Variant } from '../heap-types/index.ts';
+import type { ImporterMesh } from './ImporterMesh.ts';
+import type { Material } from './Material.ts';
+
+/**
+ * GLTFMesh handles 3D mesh data imported from glTF files. It includes properties for blend channels, blend weights, instance materials, and the mesh itself.
+ */
+export class GLTFMesh extends Resource {
+    constructor(name = 287) { super(name); }
+
+    /**
+     * Gets additional arbitrary data in this {@link GLTFMesh} instance. This can be used to keep per-node state data in {@link GLTFDocumentExtension} classes, which is important because they are stateless.
+     * The argument should be the {@link GLTFDocumentExtension} name (does not have to match the extension name in the glTF file), and the return value can be anything you set. If nothing was set, the return value is `null`.
+     */
+    getAdditionalData(extensionName: StringName): Variant { return _C(this, 3694, extensionName) as Variant; }
+
+    /**
+     * Sets additional arbitrary data in this {@link GLTFMesh} instance. This can be used to keep per-node state data in {@link GLTFDocumentExtension} classes, which is important because they are stateless.
+     * The first argument should be the {@link GLTFDocumentExtension} name (does not have to match the extension name in the glTF file), and the second argument can be anything you want.
+     */
+    setAdditionalData(extensionName: StringName, additionalData: Variant): void { _C(this, 10428, extensionName, additionalData); }
+
+    /**
+     * The original name of the mesh.
+     */
+    get originalName(): string { return _C(this, 5747) as string; }
+    set originalName(v: string) { _C(this, 12208, v); }
+
+    /**
+     * The {@link ImporterMesh} object representing the mesh itself.
+     */
+    get mesh(): ImporterMesh { return _C(this, 5511) as ImporterMesh; }
+    set mesh(v: ImporterMesh) { _C(this, 12024, v); }
+
+    /**
+     * An array of floats representing the blend weights of the mesh.
+     */
+    get blendWeights(): PackedFloat32Array { return _C(this, 3944) as PackedFloat32Array; }
+    set blendWeights(v: PackedFloat32Array) { _C(this, 10688, v); }
+
+    /**
+     * An array of Material objects representing the materials used in the mesh.
+     */
+    get instanceMaterials(): GodotArray<Material> { return _C(this, 5135) as GodotArray<Material>; }
+    set instanceMaterials(v: GodotArray<Material>) { _C(this, 11728, v); }
+
+    static readonly name = _R(287, GLTFMesh);
+}

package/gen/classes/GLTFNode.ts

@@ -0,0 +1,125 @@
+// 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 { NodePath, PackedInt32Array, StringName, Variant } from '../heap-types/index.ts';
+import type { Quaternion, Transform3D, Vector3 } from '../value-types/index.ts';
+import type { GLTFState } from './GLTFState.ts';
+
+/**
+ * Represents a glTF node. glTF nodes may have names, transforms, children (other glTF nodes), and more specialized properties (represented by their own classes).
+ * glTF nodes generally exist inside of {@link GLTFState} which represents all data of a glTF file. Most of GLTFNode's properties are indices of other data in the glTF file. You can extend a glTF node with additional properties by using {@link getAdditionalData} and {@link setAdditionalData}.
+ */
+export class GLTFNode extends Resource {
+    constructor(name = 288) { super(name); }
+
+    /**
+     * Appends the given child node index to the {@link children} array.
+     */
+    appendChildIndex(childIndex: number): void { _C(this, 1515, childIndex); }
+
+    /**
+     * Gets additional arbitrary data in this {@link GLTFNode} instance. This can be used to keep per-node state data in {@link GLTFDocumentExtension} classes, which is important because they are stateless.
+     * The argument should be the {@link GLTFDocumentExtension} name (does not have to match the extension name in the glTF file), and the return value can be anything you set. If nothing was set, the return value is `null`.
+     */
+    getAdditionalData(extensionName: StringName): Variant { return _C(this, 3694, extensionName) as Variant; }
+
+    /**
+     * Sets additional arbitrary data in this {@link GLTFNode} instance. This can be used to keep per-node state data in {@link GLTFDocumentExtension} classes, which is important because they are stateless.
+     * The first argument should be the {@link GLTFDocumentExtension} name (does not have to match the extension name in the glTF file), and the second argument can be anything you want.
+     */
+    setAdditionalData(extensionName: StringName, additionalData: Variant): void { _C(this, 10428, extensionName, additionalData); }
+
+    /**
+     * Returns the {@link NodePath} that this GLTF node will have in the Godot scene tree after being imported. This is useful when importing glTF object model pointers with {@link GLTFObjectModelProperty}, for handling extensions such as `KHR_animation_pointer` or `KHR_interactivity`.
+     * If `handleSkeletons` is `true`, paths to skeleton bone glTF nodes will be resolved properly. For example, a path that would be `^"A/B/C/Bone1/Bone2/Bone3"` if `false` will become `^"A/B/C/Skeleton3D:Bone3"`.
+     */
+    getSceneNodePath(gltfState: GLTFState, handleSkeletons?: boolean /* = true */): NodePath { return _C(this, 6251, gltfState, handleSkeletons) as NodePath; }
+
+    /**
+     * The original name of the node.
+     */
+    get originalName(): string { return _C(this, 5747) as string; }
+    set originalName(v: string) { _C(this, 12208, v); }
+
+    /**
+     * The index of the parent node in the {@link GLTFState}. If -1, this node is a root node.
+     */
+    get parent(): number { return _C(this, 5819) as number; }
+    set parent(v: number) { _C(this, 12258, v); }
+
+    /**
+     * How deep into the node hierarchy this node is. A root node will have a height of 0, its children will have a height of 1, and so on. If -1, the height has not been calculated.
+     */
+    get height(): number { return _C(this, 5024) as number; }
+    set height(v: number) { _C(this, 11609, v); }
+
+    /**
+     * The transform of the glTF node relative to its parent. This property is usually unused since the position, rotation, and scale properties are preferred.
+     */
+    get xform(): Transform3D { return _C(this, 7175) as Transform3D; }
+    set xform(v: Transform3D) { _C(this, 13397, v); }
+
+    /**
+     * If this glTF node is a mesh, the index of the {@link GLTFMesh} in the {@link GLTFState} that describes the mesh's properties. If -1, this node is not a mesh.
+     */
+    get mesh(): number { return _C(this, 5511) as number; }
+    set mesh(v: number) { _C(this, 12024, v); }
+
+    /**
+     * If this glTF node is a camera, the index of the {@link GLTFCamera} in the {@link GLTFState} that describes the camera's properties. If `-1`, this node is not a camera.
+     */
+    get camera(): number { return _C(this, 4059) as number; }
+    set camera(v: number) { _C(this, 10783, v); }
+
+    /**
+     * If this glTF node has a skin, the index of the {@link GLTFSkin} in the {@link GLTFState} that describes the skin's properties. If -1, this node does not have a skin.
+     */
+    get skin(): number { return _C(this, 6413) as number; }
+    set skin(v: number) { _C(this, 12763, v); }
+
+    /**
+     * If this glTF node has a skeleton, the index of the {@link GLTFSkeleton} in the {@link GLTFState} that describes the skeleton's properties. If -1, this node does not have a skeleton.
+     */
+    get skeleton(): number { return _C(this, 6405) as number; }
+    set skeleton(v: number) { _C(this, 12757, v); }
+
+    /**
+     * The position of the glTF node relative to its parent.
+     */
+    get position(): Vector3 { return _C(this, 5973) as Vector3; }
+    set position(v: Vector3) { _C(this, 12381, v); }
+
+    /**
+     * The rotation of the glTF node relative to its parent.
+     */
+    get rotation(): Quaternion { return _C(this, 6204) as Quaternion; }
+    set rotation(v: Quaternion) { _C(this, 12577, v); }
+
+    /**
+     * The scale of the glTF node relative to its parent.
+     */
+    get scale(): Vector3 { return _C(this, 6236) as Vector3; }
+    set scale(v: Vector3) { _C(this, 12608, v); }
+
+    /**
+     * The indices of the child nodes in the {@link GLTFState}. If this glTF node has no children, this will be an empty array.
+     */
+    get children(): PackedInt32Array { return _C(this, 4148) as PackedInt32Array; }
+    set children(v: PackedInt32Array) { _C(this, 10853, v); }
+
+    /**
+     * If this glTF node is a light, the index of the {@link GLTFLight} in the {@link GLTFState} that describes the light's properties. If -1, this node is not a light.
+     */
+    get light(): number { return _C(this, 5337) as number; }
+    set light(v: number) { _C(this, 11894, v); }
+
+    /**
+     * If `true`, the GLTF node is visible. If `false`, the GLTF node is not visible. This is converted to the {@link Node3D.visible} property in the Godot scene, and is exported to `KHR_node_visibility` when `false`.
+     */
+    get visible(): boolean { return _C(this, 7103) as boolean; }
+    set visible(v: boolean) { _C(this, 13331, v); }
+
+    static readonly name = _R(288, GLTFNode);
+}

package/gen/classes/GLTFObjectModelProperty.ts

@@ -0,0 +1,136 @@
+// 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 { GodotArray, NodePath, PackedStringArray, StringName } from '../heap-types/index.ts';
+import type { Expression } from './Expression.ts';
+import type { GLTFAccessorType } from './GLTFAccessor.ts';
+
+/**
+ * GLTFObjectModelProperty defines a mapping between a property in the glTF object model and a NodePath in the Godot scene tree. This can be used to animate properties in a glTF file using the `KHR_animation_pointer` extension, or to access them through an engine-agnostic script such as a behavior graph as defined by the `KHR_interactivity` extension.
+ * The glTF property is identified by JSON pointer(s) stored in {@link jsonPointers}, while the Godot property it maps to is defined by {@link nodePaths}. In most cases {@link jsonPointers} and {@link nodePaths} will each only have one item, but in some cases a single glTF JSON pointer will map to multiple Godot properties, or a single Godot property will be mapped to multiple glTF JSON pointers, or it might be a many-to-many relationship.
+ * {@link Expression} objects can be used to define conversions between the data, such as when glTF defines an angle in radians and Godot uses degrees. The {@link objectModelType} property defines the type of data stored in the glTF file as defined by the object model, see {@link GLTFObjectModelType} for possible values.
+ */
+export class GLTFObjectModelProperty extends RefCounted {
+    constructor(name = 289) { super(name); }
+
+    /**
+     * Appends a {@link NodePath} to {@link nodePaths}. This can be used by {@link GLTFDocumentExtension} classes to define how a glTF object model property maps to a Godot property, or multiple Godot properties. Prefer using {@link appendPathToProperty} for simple cases. Be sure to also call {@link setTypes} once (the order does not matter).
+     */
+    appendNodePath(nodePath: NodePath): void { _C(this, 1522, nodePath); }
+
+    /**
+     * High-level wrapper over {@link appendNodePath} that handles the most common cases. It constructs a new {@link NodePath} using `nodePath` as a base and appends `propName` to the subpath. Be sure to also call {@link setTypes} once (the order does not matter).
+     */
+    appendPathToProperty(nodePath: NodePath, propName: StringName): void { _C(this, 1524, nodePath, propName); }
+
+    /**
+     * The GLTF accessor type associated with this property's {@link objectModelType}. See {@link GLTFAccessor.accessorType} for possible values, and see {@link GLTFObjectModelType} for how the object model type maps to accessor types.
+     */
+    getAccessorType(): GLTFAccessorType { return _C(this, 3674) as GLTFAccessorType; }
+
+    /**
+     * Returns `true` if {@link nodePaths} is not empty. This is used during import to determine if a {@link GLTFObjectModelProperty} can handle converting a glTF object model property to a Godot property.
+     */
+    hasNodePaths(): boolean { return _C(this, 7422) as boolean; }
+
+    /**
+     * Returns `true` if {@link jsonPointers} is not empty. This is used during export to determine if a {@link GLTFObjectModelProperty} can handle converting a Godot property to a glTF object model property.
+     */
+    hasJsonPointers(): boolean { return _C(this, 7410) as boolean; }
+
+    /**
+     * Sets the {@link variantType} and {@link objectModelType} properties. This is a convenience method to set both properties at once, since they are almost always known at the same time. This method should be called once. Calling it again with the same values will have no effect.
+     */
+    setTypes(variantType: number, objModelType: GLTFObjectModelType): void { _C(this, 13165, variantType, objModelType); }
+
+    /**
+     * If set, this {@link Expression} will be used to convert the property value from the glTF object model to the value expected by the Godot property. This is useful when the glTF object model uses a different unit system, or when the data needs to be transformed in some way. If `null`, the value will be copied as-is.
+     */
+    get gltfToGodotExpression(): Expression { return _C(this, 4954) as Expression; }
+    set gltfToGodotExpression(v: Expression) { _C(this, 11538, v); }
+
+    /**
+     * If set, this {@link Expression} will be used to convert the property value from the Godot property to the value expected by the glTF object model. This is useful when the glTF object model uses a different unit system, or when the data needs to be transformed in some way. If `null`, the value will be copied as-is.
+     */
+    get godotToGltfExpression(): Expression { return _C(this, 4967) as Expression; }
+    set godotToGltfExpression(v: Expression) { _C(this, 11549, v); }
+
+    /**
+     * An array of {@link NodePath}s that point to a property, or multiple properties, in the Godot scene tree. On import, this will either be set by {@link GLTFDocument}, or by a {@link GLTFDocumentExtension} class. For simple cases, use {@link appendPathToProperty} to add properties to this array.
+     * In most cases {@link nodePaths} will only have one item, but in some cases a single glTF JSON pointer will map to multiple Godot properties. For example, a {@link GLTFCamera} or {@link GLTFLight} used on multiple glTF nodes will be represented by multiple Godot nodes.
+     */
+    get nodePaths(): GodotArray<NodePath> { return _C(this, 5656) as GodotArray<NodePath>; }
+    set nodePaths(v: GodotArray<NodePath>) { _C(this, 12138, v); }
+
+    /**
+     * The type of data stored in the glTF file as defined by the object model. This is a superset of the available accessor types, and determines the accessor type.
+     */
+    get objectModelType(): GLTFObjectModelType { return _C(this, 5685) as GLTFObjectModelType; }
+    set objectModelType(v: GLTFObjectModelType) { _C(this, 12157, v); }
+
+    /**
+     * The glTF object model JSON pointers used to identify the property in the glTF object model. In most cases, there will be only one item in this array, but specific cases may require multiple pointers. The items are themselves arrays which represent the JSON pointer split into its components.
+     */
+    get jsonPointers(): GodotArray<PackedStringArray> { return _C(this, 5278) as GodotArray<PackedStringArray>; }
+    set jsonPointers(v: GodotArray<PackedStringArray>) { _C(this, 11851, v); }
+
+    /**
+     * The type of data stored in the Godot property. This is the type of the property that the {@link nodePaths} point to.
+     */
+    get variantType(): number { return _C(this, 7022) as number; }
+    set variantType(v: number) { _C(this, 13271, v); }
+
+    static readonly name = _R(289, GLTFObjectModelProperty);
+}
+
+export const GLTFObjectModelType = {
+    /**
+     * Unknown or not set object model type. If the object model type is set to this value, the real type still needs to be determined.
+     */
+    GLTF_OBJECT_MODEL_TYPE_UNKNOWN: 0,
+    /**
+     * Object model type "bool". Represented in the glTF JSON as a boolean, and encoded in a {@link GLTFAccessor} as "SCALAR". When encoded in an accessor, a value of `0` is `false`, and any other value is `true`.
+     */
+    GLTF_OBJECT_MODEL_TYPE_BOOL: 1,
+    /**
+     * Object model type "float". Represented in the glTF JSON as a number, and encoded in a {@link GLTFAccessor} as "SCALAR".
+     */
+    GLTF_OBJECT_MODEL_TYPE_FLOAT: 2,
+    /**
+     * Object model type "float{@link lb}{@link rb}". Represented in the glTF JSON as an array of numbers, and encoded in a {@link GLTFAccessor} as "SCALAR".
+     */
+    GLTF_OBJECT_MODEL_TYPE_FLOAT_ARRAY: 3,
+    /**
+     * Object model type "float2". Represented in the glTF JSON as an array of two numbers, and encoded in a {@link GLTFAccessor} as "VEC2".
+     */
+    GLTF_OBJECT_MODEL_TYPE_FLOAT2: 4,
+    /**
+     * Object model type "float3". Represented in the glTF JSON as an array of three numbers, and encoded in a {@link GLTFAccessor} as "VEC3".
+     */
+    GLTF_OBJECT_MODEL_TYPE_FLOAT3: 5,
+    /**
+     * Object model type "float4". Represented in the glTF JSON as an array of four numbers, and encoded in a {@link GLTFAccessor} as "VEC4".
+     */
+    GLTF_OBJECT_MODEL_TYPE_FLOAT4: 6,
+    /**
+     * Object model type "float2x2". Represented in the glTF JSON as an array of four numbers, and encoded in a {@link GLTFAccessor} as "MAT2".
+     */
+    GLTF_OBJECT_MODEL_TYPE_FLOAT2X2: 7,
+    /**
+     * Object model type "float3x3". Represented in the glTF JSON as an array of nine numbers, and encoded in a {@link GLTFAccessor} as "MAT3".
+     */
+    GLTF_OBJECT_MODEL_TYPE_FLOAT3X3: 8,
+    /**
+     * Object model type "float4x4". Represented in the glTF JSON as an array of sixteen numbers, and encoded in a {@link GLTFAccessor} as "MAT4".
+     */
+    GLTF_OBJECT_MODEL_TYPE_FLOAT4X4: 9,
+    /**
+     * Object model type "int". Represented in the glTF JSON as a number, and encoded in a {@link GLTFAccessor} as "SCALAR". The range of values is limited to signed integers. For `KHR_interactivity`, only 32-bit integers are supported.
+     */
+    GLTF_OBJECT_MODEL_TYPE_INT: 10,
+} as const;
+
+export type GLTFObjectModelType = (typeof GLTFObjectModelType)[keyof typeof GLTFObjectModelType];
+