@ringozz/godot 0.1.0

package/gen/classes/GLTFPhysicsBody.ts

@@ -0,0 +1,89 @@
+// 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 } from '../heap-types/index.ts';
+import type { Basis, Quaternion, Vector3 } from '../value-types/index.ts';
+import type { CollisionObject3D } from './CollisionObject3D.ts';
+
+/**
+ * Represents a physics body as an intermediary between the `OMI_physics_body` glTF data and Godot's nodes, and it's abstracted in a way that allows adding support for different glTF physics extensions in the future.
+ */
+export class GLTFPhysicsBody extends Resource {
+    constructor(name = 290) { super(name); }
+
+    /**
+     * Creates a new GLTFPhysicsBody instance from the given Godot {@link CollisionObject3D} node.
+     */
+    static fromNode(bodyNode: CollisionObject3D): GLTFPhysicsBody { return _C(290, 3599, bodyNode) as GLTFPhysicsBody; }
+
+    /**
+     * Converts this GLTFPhysicsBody instance into a Godot {@link CollisionObject3D} node.
+     */
+    toNode(): CollisionObject3D { return _C(this, 14306) as CollisionObject3D; }
+
+    /**
+     * Creates a new GLTFPhysicsBody instance by parsing the given {@link Dictionary} in the `OMI_physics_body` glTF extension format.
+     */
+    static fromDictionary(dictionary: GodotDictionary): GLTFPhysicsBody { return _C(290, 3594, dictionary) as GLTFPhysicsBody; }
+
+    /**
+     * Serializes this GLTFPhysicsBody instance into a {@link Dictionary}. It will be in the format expected by the `OMI_physics_body` glTF extension.
+     */
+    toDictionary(): GodotDictionary { return _C(this, 14292) as GodotDictionary; }
+
+    /**
+     * The type of the body.
+     * When importing, this controls what type of {@link CollisionObject3D} node Godot should generate. Valid values are `"static"`, `"animatable"`, `"character"`, `"rigid"`, `"vehicle"`, and `"trigger"`.
+     * When exporting, this will be squashed down to one of `"static"`, `"kinematic"`, or `"dynamic"` motion types, or the `"trigger"` property.
+     */
+    get bodyType(): string { return _C(this, 3951) as string; }
+    set bodyType(v: string) { _C(this, 10696, v); }
+
+    /**
+     * The mass of the physics body, in kilograms. This is only used when the body type is "rigid" or "vehicle".
+     */
+    get mass(): number { return _C(this, 5451) as number; }
+    set mass(v: number) { _C(this, 11977, v); }
+
+    /**
+     * The linear velocity of the physics body, in meters per second. This is only used when the body type is "rigid" or "vehicle".
+     */
+    get linearVelocity(): Vector3 { return _C(this, 5386) as Vector3; }
+    set linearVelocity(v: Vector3) { _C(this, 11935, v); }
+
+    /**
+     * The angular velocity of the physics body, in radians per second. This is only used when the body type is "rigid" or "vehicle".
+     */
+    get angularVelocity(): Vector3 { return _C(this, 3757) as Vector3; }
+    set angularVelocity(v: Vector3) { _C(this, 10500, v); }
+
+    /**
+     * The center of mass of the body, in meters. This is in local space relative to the body. By default, the center of the mass is the body's origin.
+     */
+    get centerOfMass(): Vector3 { return _C(this, 4126) as Vector3; }
+    set centerOfMass(v: Vector3) { _C(this, 10840, v); }
+
+    /**
+     * The inertia strength of the physics body, in kilogram meter squared (kg⋅m²). This represents the inertia around the principle axes, the diagonal of the inertia tensor matrix. This is only used when the body type is "rigid" or "vehicle".
+     * When converted to a Godot {@link RigidBody3D} node, if this value is zero, then the inertia will be calculated automatically.
+     */
+    get inertiaDiagonal(): Vector3 { return _C(this, 5093) as Vector3; }
+    set inertiaDiagonal(v: Vector3) { _C(this, 11695, v); }
+
+    /**
+     * The inertia orientation of the physics body. This defines the rotation of the inertia's principle axes relative to the object's local axes. This is only used when the body type is "rigid" or "vehicle" and {@link inertiaDiagonal} is set to a non-zero value.
+     */
+    get inertiaOrientation(): Quaternion { return _C(this, 5094) as Quaternion; }
+    set inertiaOrientation(v: Quaternion) { _C(this, 11696, v); }
+
+    /**
+     * The inertia tensor of the physics body, in kilogram meter squared (kg⋅m²). This is only used when the body type is "rigid" or "vehicle".
+     * When converted to a Godot {@link RigidBody3D} node, if this value is zero, then the inertia will be calculated automatically.
+     */
+    get inertiaTensor(): Basis { return _C(this, 5095) as Basis; }
+    set inertiaTensor(v: Basis) { _C(this, 11697, v); }
+
+    static readonly name = _R(290, GLTFPhysicsBody);
+}

package/gen/classes/GLTFPhysicsShape.ts

@@ -0,0 +1,92 @@
+// 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 } from '../heap-types/index.ts';
+import type { Vector3 } from '../value-types/index.ts';
+import type { CollisionShape3D } from './CollisionShape3D.ts';
+import type { ImporterMesh } from './ImporterMesh.ts';
+import type { Shape3D } from './Shape3D.ts';
+
+/**
+ * Represents a physics shape as defined by the `OMI_physics_shape` or `OMI_collider` glTF extensions. This class is an intermediary between the glTF data and Godot's nodes, and it's abstracted in a way that allows adding support for different glTF physics extensions in the future.
+ */
+export class GLTFPhysicsShape extends Resource {
+    constructor(name = 291) { super(name); }
+
+    /**
+     * Creates a new GLTFPhysicsShape instance from the given Godot {@link CollisionShape3D} node.
+     */
+    static fromNode(shapeNode: CollisionShape3D): GLTFPhysicsShape { return _C(291, 3599, shapeNode) as GLTFPhysicsShape; }
+
+    /**
+     * Converts this GLTFPhysicsShape instance into a Godot {@link CollisionShape3D} node.
+     */
+    toNode(cacheShapes?: boolean /* = false */): CollisionShape3D { return _C(this, 14306, cacheShapes) as CollisionShape3D; }
+
+    /**
+     * Creates a new GLTFPhysicsShape instance from the given Godot {@link Shape3D} resource.
+     */
+    static fromResource(shapeResource: Shape3D): GLTFPhysicsShape { return _C(291, 3601, shapeResource) as GLTFPhysicsShape; }
+
+    /**
+     * Converts this GLTFPhysicsShape instance into a Godot {@link Shape3D} resource.
+     */
+    toResource(cacheShapes?: boolean /* = false */): Shape3D { return _C(this, 14308, cacheShapes) as Shape3D; }
+
+    /**
+     * Creates a new GLTFPhysicsShape instance by parsing the given {@link Dictionary}.
+     */
+    static fromDictionary(dictionary: GodotDictionary): GLTFPhysicsShape { return _C(291, 3594, dictionary) as GLTFPhysicsShape; }
+
+    /**
+     * Serializes this GLTFPhysicsShape instance into a {@link Dictionary} in the format defined by `OMI_physics_shape`.
+     */
+    toDictionary(): GodotDictionary { return _C(this, 14292) as GodotDictionary; }
+
+    /**
+     * The type of shape this shape represents. Valid values are `"box"`, `"capsule"`, `"cylinder"`, `"sphere"`, `"hull"`, and `"trimesh"`.
+     */
+    get shapeType(): string { return _C(this, 6375) as string; }
+    set shapeType(v: string) { _C(this, 12720, v); }
+
+    /**
+     * The size of the shape, in meters. This is only used when the shape type is `"box"`, and it represents the `"diameter"` of the box. This value should not be negative.
+     */
+    get size(): Vector3 { return _C(this, 6399) as Vector3; }
+    set size(v: Vector3) { _C(this, 12752, v); }
+
+    /**
+     * The radius of the shape, in meters. This is only used when the shape type is `"capsule"`, `"cylinder"`, or `"sphere"`. This value should not be negative.
+     */
+    get radius(): number { return _C(this, 6068) as number; }
+    set radius(v: number) { _C(this, 12467, v); }
+
+    /**
+     * The height of the shape, in meters. This is only used when the shape type is `"capsule"` or `"cylinder"`. This value should not be negative, and for `"capsule"` it should be at least twice the radius.
+     */
+    get height(): number { return _C(this, 5024) as number; }
+    set height(v: number) { _C(this, 11609, v); }
+
+    /**
+     * If `true`, indicates that this shape is a trigger. For Godot, this means that the shape should be a child of an {@link Area3D} node.
+     * This is the only variable not used in the {@link toNode} method, it's intended to be used alongside when deciding where to add the generated node as a child.
+     */
+    get isTrigger(): boolean { return _C(this, 5175) as boolean; }
+    set isTrigger(v: boolean) { _C(this, 11757, v); }
+
+    /**
+     * The index of the shape's mesh in the glTF file. This is only used when the shape type is `"hull"` (convex hull) or `"trimesh"` (concave trimesh).
+     */
+    get meshIndex(): number { return _C(this, 5513) as number; }
+    set meshIndex(v: number) { _C(this, 12026, v); }
+
+    /**
+     * The {@link ImporterMesh} resource of the shape. This is only used when the shape type is `"hull"` (convex hull) or `"trimesh"` (concave trimesh).
+     */
+    get importerMesh(): ImporterMesh { return _C(this, 5077) as ImporterMesh; }
+    set importerMesh(v: ImporterMesh) { _C(this, 11677, v); }
+
+    static readonly name = _R(291, GLTFPhysicsShape);
+}

package/gen/classes/GLTFSkeleton.ts

@@ -0,0 +1,32 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { GodotArray, GodotDictionary, PackedInt32Array } from '../heap-types/index.ts';
+import type { BoneAttachment3D } from './BoneAttachment3D.ts';
+import type { Skeleton3D } from './Skeleton3D.ts';
+
+export class GLTFSkeleton extends Resource {
+    constructor(name = 292) { super(name); }
+
+    getGodotSkeleton(): Skeleton3D { return _C(this, 4965) as Skeleton3D; }
+
+    getBoneAttachmentCount(): number { return _C(this, 3959) as number; }
+
+    getBoneAttachment(idx: number): BoneAttachment3D { return _C(this, 3958, idx) as BoneAttachment3D; }
+
+    get joints(): PackedInt32Array { return _C(this, 5261) as PackedInt32Array; }
+    set joints(v: PackedInt32Array) { _C(this, 11843, v); }
+
+    get roots(): PackedInt32Array { return _C(this, 6203) as PackedInt32Array; }
+    set roots(v: PackedInt32Array) { _C(this, 12575, v); }
+
+    get uniqueNames(): GodotArray<string> { return _C(this, 6952) as GodotArray<string>; }
+    set uniqueNames(v: GodotArray<string>) { _C(this, 13173, v); }
+
+    get godotBoneNode(): GodotDictionary { return _C(this, 4964) as GodotDictionary; }
+    set godotBoneNode(v: GodotDictionary) { _C(this, 11547, v); }
+
+    static readonly name = _R(292, GLTFSkeleton);
+}

package/gen/classes/GLTFSkin.ts

@@ -0,0 +1,44 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { GodotArray, GodotDictionary, PackedInt32Array } from '../heap-types/index.ts';
+import type { Transform3D } from '../value-types/index.ts';
+import type { Skin } from './Skin.ts';
+
+export class GLTFSkin extends Resource {
+    constructor(name = 293) { super(name); }
+
+    get skinRoot(): number { return _C(this, 6415) as number; }
+    set skinRoot(v: number) { _C(this, 12764, v); }
+
+    get jointsOriginal(): PackedInt32Array { return _C(this, 5262) as PackedInt32Array; }
+    set jointsOriginal(v: PackedInt32Array) { _C(this, 11844, v); }
+
+    get inverseBinds(): GodotArray<Transform3D> { return _C(this, 5160) as GodotArray<Transform3D>; }
+    set inverseBinds(v: GodotArray<Transform3D>) { _C(this, 11746, v); }
+
+    get joints(): PackedInt32Array { return _C(this, 5261) as PackedInt32Array; }
+    set joints(v: PackedInt32Array) { _C(this, 11843, v); }
+
+    get nonJoints(): PackedInt32Array { return _C(this, 5672) as PackedInt32Array; }
+    set nonJoints(v: PackedInt32Array) { _C(this, 12143, v); }
+
+    get roots(): PackedInt32Array { return _C(this, 6203) as PackedInt32Array; }
+    set roots(v: PackedInt32Array) { _C(this, 12575, v); }
+
+    get skeleton(): number { return _C(this, 6405) as number; }
+    set skeleton(v: number) { _C(this, 12757, v); }
+
+    get jointIToBoneI(): GodotDictionary { return _C(this, 5241) as GodotDictionary; }
+    set jointIToBoneI(v: GodotDictionary) { _C(this, 11823, v); }
+
+    get jointIToName(): GodotDictionary { return _C(this, 5242) as GodotDictionary; }
+    set jointIToName(v: GodotDictionary) { _C(this, 11824, v); }
+
+    get godotSkin(): Skin { return _C(this, 4966) as Skin; }
+    set godotSkin(v: Skin) { _C(this, 11548, v); }
+
+    static readonly name = _R(293, GLTFSkin);
+}

package/gen/classes/GLTFSpecGloss.ts

@@ -0,0 +1,46 @@
+// 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 { Color } from '../value-types/index.ts';
+import type { Image } from './Image.ts';
+
+/**
+ * KHR_materials_pbrSpecularGlossiness is an archived glTF extension. This means that it is deprecated and not recommended for new files. However, it is still supported for loading old files.
+ */
+export class GLTFSpecGloss extends Resource {
+    constructor(name = 294) { super(name); }
+
+    /**
+     * The diffuse texture.
+     */
+    get diffuseImg(): Image { return _C(this, 4502) as Image; }
+    set diffuseImg(v: Image) { _C(this, 11109, v); }
+
+    /**
+     * The reflected diffuse factor of the material.
+     */
+    get diffuseFactor(): Color { return _C(this, 4501) as Color; }
+    set diffuseFactor(v: Color) { _C(this, 11108, v); }
+
+    /**
+     * The glossiness or smoothness of the material.
+     */
+    get glossFactor(): number { return _C(this, 4942) as number; }
+    set glossFactor(v: number) { _C(this, 11524, v); }
+
+    /**
+     * The specular RGB color of the material. The alpha channel is unused.
+     */
+    get specularFactor(): Color { return _C(this, 6491) as Color; }
+    set specularFactor(v: Color) { _C(this, 12835, v); }
+
+    /**
+     * The specular-glossiness texture.
+     */
+    get specGlossImg(): Image { return _C(this, 6487) as Image; }
+    set specGlossImg(v: Image) { _C(this, 12831, v); }
+
+    static readonly name = _R(294, GLTFSpecGloss);
+}

package/gen/classes/GLTFState.ts

@@ -0,0 +1,250 @@
+// 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, PackedByteArray, PackedInt32Array, StringName, Variant } from '../heap-types/index.ts';
+import type { AnimationPlayer } from './AnimationPlayer.ts';
+import type { GLTFAccessor } from './GLTFAccessor.ts';
+import type { GLTFAnimation } from './GLTFAnimation.ts';
+import type { GLTFBufferView } from './GLTFBufferView.ts';
+import type { GLTFCamera } from './GLTFCamera.ts';
+import type { GLTFLight } from './GLTFLight.ts';
+import type { GLTFMesh } from './GLTFMesh.ts';
+import type { GLTFNode } from './GLTFNode.ts';
+import type { GLTFSkeleton } from './GLTFSkeleton.ts';
+import type { GLTFSkin } from './GLTFSkin.ts';
+import type { GLTFTexture } from './GLTFTexture.ts';
+import type { GLTFTextureSampler } from './GLTFTextureSampler.ts';
+import type { Material } from './Material.ts';
+import type { Node } from './Node.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * Contains all nodes and resources of a glTF file. This is used by {@link GLTFDocument} as data storage, which allows {@link GLTFDocument} and all {@link GLTFDocumentExtension} classes to remain stateless.
+ * GLTFState can be populated by {@link GLTFDocument} reading a file or by converting a Godot scene. Then the data can either be used to create a Godot scene or save to a glTF file. The code that converts to/from a Godot scene can be intercepted at arbitrary points by {@link GLTFDocumentExtension} classes. This allows for custom data to be stored in the glTF file or for custom data to be converted to/from Godot nodes.
+ */
+export class GLTFState extends Resource {
+    constructor(name = 295) { super(name); }
+
+    /**
+     * Appends an extension to the list of extensions used by this glTF file during serialization. If `required` is `true`, the extension will also be added to the list of required extensions. Do not run this in {@link GLTFDocumentExtension.ExportPost}, as that stage is too late to add extensions. The final list is sorted alphabetically.
+     */
+    addUsedExtension(extensionName: string, required: boolean): void { _C(this, 1327, extensionName, required); }
+
+    /**
+     * Appends the given byte array `data` to the buffers and creates a {@link GLTFBufferView} for it. The index of the destination {@link GLTFBufferView} is returned. If `deduplication` is `true`, the buffers are first searched for duplicate data, otherwise new bytes are always appended.
+     */
+    appendDataToBuffers(data: PackedByteArray, deduplication: boolean): number { return _C(this, 1516, data, deduplication) as number; }
+
+    /**
+     * Appends the given {@link GLTFNode} to the state, and returns its new index. This can be used to export one Godot node as multiple glTF nodes, or inject new glTF nodes at import time. On import, this must be called before {@link GLTFDocumentExtension.GenerateSceneNode} finishes for the parent node. On export, this must be called before {@link GLTFDocumentExtension.ExportNode} runs for the parent node.
+     * The `godotSceneNode` parameter is the Godot scene node that corresponds to this glTF node. This is highly recommended to be set to a valid node, but may be `null` if there is no corresponding Godot scene node. One Godot scene node may be used for multiple glTF nodes, so if exporting multiple glTF nodes for one Godot scene node, use the same Godot scene node for each.
+     * The `parentNodeIndex` parameter is the index of the parent {@link GLTFNode} in the state. If `-1`, the node will be a root node, otherwise the new node will be added to the parent's list of children. The index will also be written to the {@link GLTFNode.parent} property of the new node.
+     */
+    appendGltfNode(gltfNode: GLTFNode, godotSceneNode: Node, parentNodeIndex: number): number { return _C(this, 1521, gltfNode, godotSceneNode, parentNodeIndex) as number; }
+
+    /**
+     * Returns the number of {@link AnimationPlayer} nodes in this {@link GLTFState}. These nodes are only used during the export process when converting Godot {@link AnimationPlayer} nodes to glTF animations.
+     */
+    getAnimationPlayersCount(animPlayerIndex: number): number { return _C(this, 3769, animPlayerIndex) as number; }
+
+    /**
+     * Returns the {@link AnimationPlayer} node with the given index. These nodes are only used during the export process when converting Godot {@link AnimationPlayer} nodes to glTF animations.
+     */
+    getAnimationPlayer(animPlayerIndex: number): AnimationPlayer { return _C(this, 3768, animPlayerIndex) as AnimationPlayer; }
+
+    /**
+     * Returns the Godot scene node that corresponds to the same index as the {@link GLTFNode} it was generated from. This is the inverse of {@link getNodeIndex}. Useful during the import process.
+     * **Note:** Not every {@link GLTFNode} will have a scene node generated, and not every generated scene node will have a corresponding {@link GLTFNode}. If there is no scene node for this {@link GLTFNode} index, `null` is returned.
+     */
+    getSceneNode(gltfNodeIndex: number): Node { return _C(this, 6250, gltfNodeIndex) as Node; }
+
+    /**
+     * Returns the index of the {@link GLTFNode} corresponding to this Godot scene node. This is the inverse of {@link getSceneNode}. Useful during the export process.
+     * **Note:** Not every Godot scene node will have a corresponding {@link GLTFNode}, and not every {@link GLTFNode} will have a scene node generated. If there is no {@link GLTFNode} index for this scene node, `-1` is returned.
+     */
+    getNodeIndex(sceneNode: Node): number { return _C(this, 5647, sceneNode) as number; }
+
+    /**
+     * Gets additional arbitrary data in this {@link GLTFState} instance. This can be used to keep per-file 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 GLTFState} instance. This can be used to keep per-file 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 raw JSON document corresponding to this GLTFState.
+     */
+    get json(): GodotDictionary { return _C(this, 5277) as GodotDictionary; }
+    set json(v: GodotDictionary) { _C(this, 11850, v); }
+
+    get majorVersion(): number { return _C(this, 5434) as number; }
+    set majorVersion(v: number) { _C(this, 11963, v); }
+
+    get minorVersion(): number { return _C(this, 5556) as number; }
+    set minorVersion(v: number) { _C(this, 12063, v); }
+
+    /**
+     * The copyright string in the asset header of the glTF file. This is set during import if present and export if non-empty. See the glTF asset header documentation for more information.
+     */
+    get copyright(): string { return _C(this, 4328) as string; }
+    set copyright(v: string) { _C(this, 10971, v); }
+
+    /**
+     * The binary buffer attached to a .glb file.
+     */
+    get glbData(): PackedByteArray { return _C(this, 4922) as PackedByteArray; }
+    set glbData(v: PackedByteArray) { _C(this, 11513, v); }
+
+    get useNamedSkinBinds(): boolean { return _C(this, 6983) as boolean; }
+    set useNamedSkinBinds(v: boolean) { _C(this, 13228, v); }
+
+    get nodes(): GodotArray<GLTFNode> { return _C(this, 5663) as GodotArray<GLTFNode>; }
+    set nodes(v: GodotArray<GLTFNode>) { _C(this, 12140, v); }
+
+    get buffers(): GodotArray<PackedByteArray> { return _C(this, 4010) as GodotArray<PackedByteArray>; }
+    set buffers(v: GodotArray<PackedByteArray>) { _C(this, 10746, v); }
+
+    get bufferViews(): GodotArray<GLTFBufferView> { return _C(this, 4007) as GodotArray<GLTFBufferView>; }
+    set bufferViews(v: GodotArray<GLTFBufferView>) { _C(this, 10744, v); }
+
+    get accessors(): GodotArray<GLTFAccessor> { return _C(this, 3675) as GodotArray<GLTFAccessor>; }
+    set accessors(v: GodotArray<GLTFAccessor>) { _C(this, 10414, v); }
+
+    get meshes(): GodotArray<GLTFMesh> { return _C(this, 5517) as GodotArray<GLTFMesh>; }
+    set meshes(v: GodotArray<GLTFMesh>) { _C(this, 12029, v); }
+
+    get materials(): GodotArray<Material> { return _C(this, 5455) as GodotArray<Material>; }
+    set materials(v: GodotArray<Material>) { _C(this, 11981, v); }
+
+    /**
+     * The name of the scene. When importing, if not specified, this will be the file name. When exporting, if specified, the scene name will be saved to the glTF file.
+     */
+    get sceneName(): string { return _C(this, 6249) as string; }
+    set sceneName(v: string) { _C(this, 12621, v); }
+
+    /**
+     * The folder path associated with this glTF data. This is used to find other files the glTF file references, like images or binary buffers. This will be set during import when appending from a file, and will be set during export when writing to a file.
+     */
+    get basePath(): string { return _C(this, 3897) as string; }
+    set basePath(v: string) { _C(this, 10643, v); }
+
+    /**
+     * The file name associated with this glTF data. If it ends with `.gltf`, this is text-based glTF, otherwise this is binary GLB. This will be set during import when appending from a file, and will be set during export when writing to a file. If writing to a buffer, this will be an empty string.
+     */
+    get filename(): string { return _C(this, 4774) as string; }
+    set filename(v: string) { _C(this, 11380, v); }
+
+    /**
+     * The root nodes of the glTF file. Typically, a glTF file will only have one scene, and therefore one root node. However, a glTF file may have multiple scenes and therefore multiple root nodes, which will be generated as siblings of each other and as children of the root node of the generated Godot scene.
+     */
+    get rootNodes(): PackedInt32Array { return _C(this, 6200) as PackedInt32Array; }
+    set rootNodes(v: PackedInt32Array) { _C(this, 12572, v); }
+
+    get textures(): GodotArray<GLTFTexture> { return _C(this, 6758) as GodotArray<GLTFTexture>; }
+    set textures(v: GodotArray<GLTFTexture>) { _C(this, 13050, v); }
+
+    get textureSamplers(): GodotArray<GLTFTextureSampler> { return _C(this, 6749) as GodotArray<GLTFTextureSampler>; }
+    set textureSamplers(v: GodotArray<GLTFTextureSampler>) { _C(this, 13046, v); }
+
+    get images(): GodotArray<Texture2D> { return _C(this, 5075) as GodotArray<Texture2D>; }
+    set images(v: GodotArray<Texture2D>) { _C(this, 11673, v); }
+
+    get skins(): GodotArray<GLTFSkin> { return _C(this, 6417) as GodotArray<GLTFSkin>; }
+    set skins(v: GodotArray<GLTFSkin>) { _C(this, 12766, v); }
+
+    get cameras(): GodotArray<GLTFCamera> { return _C(this, 4068) as GodotArray<GLTFCamera>; }
+    set cameras(v: GodotArray<GLTFCamera>) { _C(this, 10788, v); }
+
+    get lights(): GodotArray<GLTFLight> { return _C(this, 5347) as GodotArray<GLTFLight>; }
+    set lights(v: GodotArray<GLTFLight>) { _C(this, 11904, v); }
+
+    get uniqueNames(): GodotArray<string> { return _C(this, 6952) as GodotArray<string>; }
+    set uniqueNames(v: GodotArray<string>) { _C(this, 13173, v); }
+
+    get uniqueAnimationNames(): GodotArray<string> { return _C(this, 6950) as GodotArray<string>; }
+    set uniqueAnimationNames(v: GodotArray<string>) { _C(this, 13171, v); }
+
+    get skeletons(): GodotArray<GLTFSkeleton> { return _C(this, 6410) as GodotArray<GLTFSkeleton>; }
+    set skeletons(v: GodotArray<GLTFSkeleton>) { _C(this, 12761, v); }
+
+    get createAnimations(): boolean { return _C(this, 4335) as boolean; }
+    set createAnimations(v: boolean) { _C(this, 10977, v); }
+
+    /**
+     * If `true`, forces all GLTFNodes in the document to be bones of a single {@link Skeleton3D} Godot node.
+     */
+    get importAsSkeletonBones(): boolean { return _C(this, 5076) as boolean; }
+    set importAsSkeletonBones(v: boolean) { _C(this, 11676, v); }
+
+    get animations(): GodotArray<GLTFAnimation> { return _C(this, 3771) as GodotArray<GLTFAnimation>; }
+    set animations(v: GodotArray<GLTFAnimation>) { _C(this, 10508, v); }
+
+    /**
+     * When importing a glTF file with unimported raw binary images embedded inside of binary blob buffers, in data URIs, or separate files not imported by Godot, this controls how the images are handled. Images can be discarded, saved as separate files, or embedded in the scene lossily or losslessly. See {@link HandleBinaryImageMode} for options.
+     * This property does nothing for image files in the `res://` folder imported by Godot, as those are handled by Godot's image importer directly, and then the Godot scene generated from the glTF file will use the images as Godot imported them.
+     */
+    get handleBinaryImageMode(): HandleBinaryImageMode { return _C(this, 5018) as HandleBinaryImageMode; }
+    set handleBinaryImageMode(v: HandleBinaryImageMode) { _C(this, 11600, v); }
+
+    /**
+     * The baking fps of the animation for either import or export.
+     */
+    get bakeFps(): number { return _C(this, 3873) as number; }
+    set bakeFps(v: number) { _C(this, 10627, v); }
+
+    get handleBinaryImage(): number { return _C(this, 5017) as number; }
+    set handleBinaryImage(v: number) { _C(this, 11599, v); }
+
+    /**
+     * Discards all embedded textures and uses untextured materials.
+     */
+    static readonly HANDLE_BINARY_DISCARD_TEXTURES = 0;
+
+    /**
+     * Extracts embedded textures to be reimported and compressed. Editor only. Acts as uncompressed at runtime.
+     */
+    static readonly HANDLE_BINARY_EXTRACT_TEXTURES = 1;
+
+    /**
+     * Embeds textures VRAM compressed with Basis Universal into the generated scene.
+     */
+    static readonly HANDLE_BINARY_EMBED_AS_BASISU = 2;
+
+    /**
+     * Embeds textures compressed losslessly into the generated scene, matching old behavior.
+     */
+    static readonly HANDLE_BINARY_EMBED_AS_UNCOMPRESSED = 3;
+
+    static readonly name = _R(295, GLTFState);
+}
+
+export const HandleBinaryImageMode = {
+    /**
+     * When importing a glTF file with embedded binary images, discards all images and uses untextured materials in their place. Images stored as separate files in the `res://` folder are not affected by this; those will be used as Godot imported them.
+     */
+    HANDLE_BINARY_IMAGE_MODE_DISCARD_TEXTURES: 0,
+    /**
+     * When importing a glTF file with embedded binary images, extracts them and saves them to their own files. This allows the image to be imported by Godot's image importer, which can then have their import options customized by the user, including optionally compressing the image to VRAM texture formats.
+     * This will save the images's bytes exactly as-is, without recompression. For image formats supplied by glTF extensions, the file will have a filename ending with the file extension supplied by {@link GLTFDocumentExtension.GetImageFileExtension} of the extension class.
+     * **Note:** This option is editor-only. At runtime, this acts the same as {@link HANDLE_BINARY_IMAGE_MODE_EMBED_AS_UNCOMPRESSED}.
+     */
+    HANDLE_BINARY_IMAGE_MODE_EXTRACT_TEXTURES: 1,
+    /**
+     * When importing a glTF file with embedded binary images, embeds textures VRAM compressed with Basis Universal into the generated scene. Images stored as separate files in the `res://` folder are not affected by this; those will be used as Godot imported them.
+     */
+    HANDLE_BINARY_IMAGE_MODE_EMBED_AS_BASISU: 2,
+    /**
+     * When importing a glTF file with embedded binary images, embeds textures compressed losslessly into the generated scene. Images stored as separate files in the `res://` folder are not affected by this; those will be used as Godot imported them.
+     */
+    HANDLE_BINARY_IMAGE_MODE_EMBED_AS_UNCOMPRESSED: 3,
+} as const;
+
+export type HandleBinaryImageMode = (typeof HandleBinaryImageMode)[keyof typeof HandleBinaryImageMode];
+

package/gen/classes/GLTFTexture.ts

@@ -0,0 +1,23 @@
+// 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';
+
+export class GLTFTexture extends Resource {
+    constructor(name = 296) { super(name); }
+
+    /**
+     * The index of the image associated with this texture, see {@link GLTFState.getImages}. If -1, then this texture does not have an image assigned.
+     */
+    get srcImage(): number { return _C(this, 6506) as number; }
+    set srcImage(v: number) { _C(this, 12849, v); }
+
+    /**
+     * ID of the texture sampler to use when sampling the image. If -1, then the default texture sampler is used (linear filtering, and repeat wrapping in both axes).
+     */
+    get sampler(): number { return _C(this, 6231) as number; }
+    set sampler(v: number) { _C(this, 12603, v); }
+
+    static readonly name = _R(296, GLTFTexture);
+}

package/gen/classes/GLTFTextureSampler.ts

@@ -0,0 +1,38 @@
+// 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';
+
+/**
+ * Represents a texture sampler as defined by the base glTF spec. Texture samplers in glTF specify how to sample data from the texture's base image, when rendering the texture on an object.
+ */
+export class GLTFTextureSampler extends Resource {
+    constructor(name = 297) { super(name); }
+
+    /**
+     * Texture's magnification filter, used when texture appears larger on screen than the source image.
+     */
+    get magFilter(): number { return _C(this, 5428) as number; }
+    set magFilter(v: number) { _C(this, 11960, v); }
+
+    /**
+     * Texture's minification filter, used when the texture appears smaller on screen than the source image.
+     */
+    get minFilter(): number { return _C(this, 5540) as number; }
+    set minFilter(v: number) { _C(this, 12051, v); }
+
+    /**
+     * Wrapping mode to use for S-axis (horizontal) texture coordinates.
+     */
+    get wrapS(): number { return _C(this, 7164) as number; }
+    set wrapS(v: number) { _C(this, 13385, v); }
+
+    /**
+     * Wrapping mode to use for T-axis (vertical) texture coordinates.
+     */
+    get wrapT(): number { return _C(this, 7165) as number; }
+    set wrapT(v: number) { _C(this, 13386, v); }
+
+    static readonly name = _R(297, GLTFTextureSampler);
+}