@ringozz/godot 0.1.0

package/gen/classes/GDExtension.ts

@@ -0,0 +1,47 @@
+// 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';
+
+/**
+ * The {@link GDExtension} resource type represents a [shared library](https://en.wikipedia.org/wiki/Shared_library) which can expand the functionality of the engine. The {@link GDExtensionManager} singleton is responsible for loading, reloading, and unloading {@link GDExtension} resources.
+ * **Note:** GDExtension itself is not a scripting language and has no relation to {@link GDScript} resources.
+ */
+export class GDExtension extends Resource {
+    constructor(name = 276) { super(name); }
+
+    /**
+     * Returns `true` if this extension's library has been opened.
+     */
+    isLibraryOpen(): boolean { return _C(this, 8069) as boolean; }
+
+    /**
+     * Returns the lowest level required for this extension to be properly initialized (see the {@link InitializationLevel} enum).
+     */
+    getMinimumLibraryInitializationLevel(): InitializationLevel { return _C(this, 5553) as InitializationLevel; }
+
+    static readonly name = _R(276, GDExtension);
+}
+
+export const InitializationLevel = {
+    /**
+     * The library is initialized at the same time as the core features of the engine.
+     */
+    INITIALIZATION_LEVEL_CORE: 0,
+    /**
+     * The library is initialized at the same time as the engine's servers (such as {@link RenderingServer} or {@link PhysicsServer3D}).
+     */
+    INITIALIZATION_LEVEL_SERVERS: 1,
+    /**
+     * The library is initialized at the same time as the engine's scene-related classes.
+     */
+    INITIALIZATION_LEVEL_SCENE: 2,
+    /**
+     * The library is initialized at the same time as the engine's editor classes. Only happens when loading the GDExtension in the editor.
+     */
+    INITIALIZATION_LEVEL_EDITOR: 3,
+} as const;
+
+export type InitializationLevel = (typeof InitializationLevel)[keyof typeof InitializationLevel];
+

package/gen/classes/GDExtensionManager.ts

@@ -0,0 +1,101 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar, _G } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { PackedStringArray, Signal } from '../heap-types/index.ts';
+import type { GDExtension } from './GDExtension.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 277));
+
+/**
+ * The GDExtensionManager loads, initializes, and keeps track of all available {@link GDExtension} libraries in the project.
+ * **Note:** Do not worry about GDExtension unless you know what you are doing.
+ */
+export class GDExtensionManager extends GodotVar {
+
+    /**
+     * Loads an extension by absolute file path. The `path` needs to point to a valid {@link GDExtension}. Returns {@link LOAD_STATUS_OK} if successful.
+     */
+    static loadExtension(path: string): LoadStatus { return _C($(), 8674, path) as LoadStatus; }
+
+    /**
+     * Loads the extension already in address space via the given path and initialization function. The `path` needs to be unique and start with `"libgodot://"`. Returns {@link LOAD_STATUS_OK} if successful.
+     */
+    static loadExtensionFromFunction(path: string, initFunc: unknown): LoadStatus { return _C($(), 8675, path, initFunc) as LoadStatus; }
+
+    /**
+     * Reloads the extension at the given file path. The `path` needs to point to a valid {@link GDExtension}, otherwise this method may return either {@link LOAD_STATUS_NOT_LOADED} or {@link LOAD_STATUS_FAILED}.
+     * **Note:** You can only reload extensions in the editor. In release builds, this method always fails and returns {@link LOAD_STATUS_FAILED}.
+     */
+    static reloadExtension(path: string): LoadStatus { return _C($(), 9873, path) as LoadStatus; }
+
+    /**
+     * Unloads an extension by file path. The `path` needs to point to an already loaded {@link GDExtension}, otherwise this method returns {@link LOAD_STATUS_NOT_LOADED}.
+     */
+    static unloadExtension(path: string): LoadStatus { return _C($(), 14480, path) as LoadStatus; }
+
+    /**
+     * Returns `true` if the extension at the given file `path` has already been loaded successfully. See also {@link getLoadedExtensions}.
+     */
+    static isExtensionLoaded(path: string): boolean { return _C($(), 7945, path) as boolean; }
+
+    /**
+     * Returns the file paths of all currently loaded extensions.
+     */
+    static getLoadedExtensions(): PackedStringArray { return _C($(), 5392) as PackedStringArray; }
+
+    /**
+     * Returns the {@link GDExtension} at the given file `path`, or `null` if it has not been loaded or does not exist.
+     */
+    static getExtension(path: string): GDExtension | null { return _C($(), 4715, path) as GDExtension | null; }
+
+    /**
+     * Emitted after the editor has finished reloading one or more extensions.
+     */
+    static get extensionsReloaded(): Signal<() => void> { return _G($(), 3208) as Signal<() => void>; }
+    static set extensionsReloaded(v: (() => void) | null) { _G($(), 3208, v); }
+
+    /**
+     * Emitted after the editor has finished loading a new extension.
+     * **Note:** This signal is only emitted in editor builds.
+     */
+    static get extensionLoaded(): Signal<(extension: GDExtension) => void> { return _G($(), 3206) as Signal<(extension: GDExtension) => void>; }
+    static set extensionLoaded(v: ((extension: GDExtension) => void) | null) { _G($(), 3206, v); }
+
+    /**
+     * Emitted before the editor starts unloading an extension.
+     * **Note:** This signal is only emitted in editor builds.
+     */
+    static get extensionUnloading(): Signal<(extension: GDExtension) => void> { return _G($(), 3207) as Signal<(extension: GDExtension) => void>; }
+    static set extensionUnloading(v: ((extension: GDExtension) => void) | null) { _G($(), 3207, v); }
+
+    static readonly name = _R(277, GDExtensionManager);
+}
+
+export const LoadStatus = {
+    /**
+     * The extension has loaded successfully.
+     */
+    LOAD_STATUS_OK: 0,
+    /**
+     * The extension has failed to load, possibly because it does not exist or has missing dependencies.
+     */
+    LOAD_STATUS_FAILED: 1,
+    /**
+     * The extension has already been loaded.
+     */
+    LOAD_STATUS_ALREADY_LOADED: 2,
+    /**
+     * The extension has not been loaded.
+     */
+    LOAD_STATUS_NOT_LOADED: 3,
+    /**
+     * The extension requires the application to restart to fully load.
+     */
+    LOAD_STATUS_NEEDS_RESTART: 4,
+} as const;
+
+export type LoadStatus = (typeof LoadStatus)[keyof typeof LoadStatus];
+

package/gen/classes/GDScript.ts

@@ -0,0 +1,30 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Script } from './Script.ts';
+import type { Variant } from '../heap-types/index.ts';
+
+/**
+ * A script implemented in the GDScript programming language, saved with the `.gd` extension. The script extends the functionality of all objects that instantiate it.
+ * Calling {@link new} creates a new instance of the script. {@link Object.setScript} extends an existing object, if that object's class matches one of the script's base classes.
+ * If you are looking for GDScript's built-in functions, see `@GDScript` instead.
+ */
+export class GDScript extends Script {
+    constructor(name = 278) { super(name); }
+
+    /**
+     * Returns a new instance of the script.
+     *
+     * ```text
+     *
+     * var MyClass = load("myclass.gd")
+     * var instance = MyClass.new()
+     * print(instance.get_script() == MyClass) # Prints true
+     *
+     * ```
+     */
+    _new(...args: any[]): Variant { return _C(this, 9068, ...args) as Variant; }
+
+    static readonly name = _R(278, GDScript);
+}

package/gen/classes/GLTFAccessor.ts

@@ -0,0 +1,203 @@
+// 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, PackedFloat64Array } from '../heap-types/index.ts';
+
+/**
+ * GLTFAccessor is a data structure representing a glTF `accessor` that would be found in the `"accessors"` array. A buffer is a blob of binary data. A buffer view is a slice of a buffer. An accessor is a typed interpretation of the data in a buffer view.
+ * Most custom data stored in glTF does not need accessors, only buffer views (see {@link GLTFBufferView}). Accessors are for more advanced use cases such as interleaved mesh data encoded for the GPU.
+ */
+export class GLTFAccessor extends Resource {
+    constructor(name = 279) { super(name); }
+
+    /**
+     * Creates a new GLTFAccessor instance by parsing the given {@link Dictionary}.
+     */
+    static fromDictionary(dictionary: GodotDictionary): GLTFAccessor { return _C(279, 3594, dictionary) as GLTFAccessor; }
+
+    /**
+     * Serializes this GLTFAccessor instance into a {@link Dictionary}.
+     */
+    toDictionary(): GodotDictionary { return _C(this, 14292) as GodotDictionary; }
+
+    /**
+     * The index of the buffer view this accessor is referencing. If `-1`, this accessor is not referencing any buffer view.
+     */
+    get bufferView(): number { return _C(this, 4006) as number; }
+    set bufferView(v: number) { _C(this, 10743, v); }
+
+    /**
+     * The offset relative to the start of the buffer view in bytes.
+     */
+    get byteOffset(): number { return _C(this, 4040) as number; }
+    set byteOffset(v: number) { _C(this, 10770, v); }
+
+    /**
+     * The glTF component type as an enum. See {@link GLTFComponentType} for possible values. Within the core glTF specification, a value of 5125 or "UNSIGNED_INT" must not be used for any accessor that is not referenced by mesh.primitive.indices.
+     */
+    get componentType(): GLTFComponentType { return _C(this, 4249) as GLTFComponentType; }
+    set componentType(v: GLTFComponentType) { _C(this, 10930, v); }
+
+    /**
+     * Specifies whether integer data values are normalized before usage.
+     */
+    get normalized(): boolean { return _C(this, 5681) as boolean; }
+    set normalized(v: boolean) { _C(this, 12152, v); }
+
+    /**
+     * The number of elements referenced by this accessor.
+     */
+    get count(): number { return _C(this, 4333) as number; }
+    set count(v: number) { _C(this, 10975, v); }
+
+    /**
+     * The glTF accessor type, as an enum.
+     */
+    get accessorType(): GLTFAccessorType { return _C(this, 3674) as GLTFAccessorType; }
+    set accessorType(v: GLTFAccessorType) { _C(this, 10413, v); }
+
+    /**
+     * The glTF accessor type, as an {@link int}. Possible values are `0` for "SCALAR", `1` for "VEC2", `2` for "VEC3", `3` for "VEC4", `4` for "MAT2", `5` for "MAT3", and `6` for "MAT4".
+     */
+    get type(): number { return _C(this, 6921) as number; }
+    set type(v: number) { _C(this, 13162, v); }
+
+    /**
+     * Minimum value of each component in this accessor.
+     */
+    get min(): PackedFloat64Array { return _C(this, 5537) as PackedFloat64Array; }
+    set min(v: PackedFloat64Array) { _C(this, 12048, v); }
+
+    /**
+     * Maximum value of each component in this accessor.
+     */
+    get max(): PackedFloat64Array { return _C(this, 5456) as PackedFloat64Array; }
+    set max(v: PackedFloat64Array) { _C(this, 11982, v); }
+
+    /**
+     * Number of deviating accessor values stored in the sparse array.
+     */
+    get sparseCount(): number { return _C(this, 6467) as number; }
+    set sparseCount(v: number) { _C(this, 12820, v); }
+
+    /**
+     * The index of the buffer view with sparse indices. The referenced buffer view MUST NOT have its target or byteStride properties defined. The buffer view and the optional byteOffset MUST be aligned to the componentType byte length.
+     */
+    get sparseIndicesBufferView(): number { return _C(this, 6468) as number; }
+    set sparseIndicesBufferView(v: number) { _C(this, 12821, v); }
+
+    /**
+     * The offset relative to the start of the buffer view in bytes.
+     */
+    get sparseIndicesByteOffset(): number { return _C(this, 6469) as number; }
+    set sparseIndicesByteOffset(v: number) { _C(this, 12822, v); }
+
+    /**
+     * The indices component data type as an enum. Possible values are 5121 for "UNSIGNED_BYTE", 5123 for "UNSIGNED_SHORT", and 5125 for "UNSIGNED_INT".
+     */
+    get sparseIndicesComponentType(): GLTFComponentType { return _C(this, 6470) as GLTFComponentType; }
+    set sparseIndicesComponentType(v: GLTFComponentType) { _C(this, 12823, v); }
+
+    /**
+     * The index of the bufferView with sparse values. The referenced buffer view MUST NOT have its target or byteStride properties defined.
+     */
+    get sparseValuesBufferView(): number { return _C(this, 6471) as number; }
+    set sparseValuesBufferView(v: number) { _C(this, 12824, v); }
+
+    /**
+     * The offset relative to the start of the bufferView in bytes.
+     */
+    get sparseValuesByteOffset(): number { return _C(this, 6472) as number; }
+    set sparseValuesByteOffset(v: number) { _C(this, 12825, v); }
+
+    static readonly name = _R(279, GLTFAccessor);
+}
+
+export const GLTFAccessorType = {
+    /**
+     * Accessor type "SCALAR". For the glTF object model, this can be used to map to a single float, int, or bool value, or a float array.
+     */
+    TYPE_SCALAR: 0,
+    /**
+     * Accessor type "VEC2". For the glTF object model, this maps to "float2", represented in the glTF JSON as an array of two floats.
+     */
+    TYPE_VEC2: 1,
+    /**
+     * Accessor type "VEC3". For the glTF object model, this maps to "float3", represented in the glTF JSON as an array of three floats.
+     */
+    TYPE_VEC3: 2,
+    /**
+     * Accessor type "VEC4". For the glTF object model, this maps to "float4", represented in the glTF JSON as an array of four floats.
+     */
+    TYPE_VEC4: 3,
+    /**
+     * Accessor type "MAT2". For the glTF object model, this maps to "float2x2", represented in the glTF JSON as an array of four floats.
+     */
+    TYPE_MAT2: 4,
+    /**
+     * Accessor type "MAT3". For the glTF object model, this maps to "float3x3", represented in the glTF JSON as an array of nine floats.
+     */
+    TYPE_MAT3: 5,
+    /**
+     * Accessor type "MAT4". For the glTF object model, this maps to "float4x4", represented in the glTF JSON as an array of sixteen floats.
+     */
+    TYPE_MAT4: 6,
+} as const;
+
+export type GLTFAccessorType = (typeof GLTFAccessorType)[keyof typeof GLTFAccessorType];
+
+export const GLTFComponentType = {
+    /**
+     * Component type "NONE". This is not a valid component type, and is used to indicate that the component type is not set.
+     */
+    COMPONENT_TYPE_NONE: 0,
+    /**
+     * Component type "BYTE". The value is `0x1400` which comes from OpenGL. This indicates data is stored in 1-byte or 8-bit signed integers. This is a core part of the glTF specification.
+     */
+    COMPONENT_TYPE_SIGNED_BYTE: 5120,
+    /**
+     * Component type "UNSIGNED_BYTE". The value is `0x1401` which comes from OpenGL. This indicates data is stored in 1-byte or 8-bit unsigned integers. This is a core part of the glTF specification.
+     */
+    COMPONENT_TYPE_UNSIGNED_BYTE: 5121,
+    /**
+     * Component type "SHORT". The value is `0x1402` which comes from OpenGL. This indicates data is stored in 2-byte or 16-bit signed integers. This is a core part of the glTF specification.
+     */
+    COMPONENT_TYPE_SIGNED_SHORT: 5122,
+    /**
+     * Component type "UNSIGNED_SHORT". The value is `0x1403` which comes from OpenGL. This indicates data is stored in 2-byte or 16-bit unsigned integers. This is a core part of the glTF specification.
+     */
+    COMPONENT_TYPE_UNSIGNED_SHORT: 5123,
+    /**
+     * Component type "INT". The value is `0x1404` which comes from OpenGL. This indicates data is stored in 4-byte or 32-bit signed integers. This is NOT a core part of the glTF specification, and may not be supported by all glTF importers. May be used by some extensions including `KHR_interactivity`.
+     */
+    COMPONENT_TYPE_SIGNED_INT: 5124,
+    /**
+     * Component type "UNSIGNED_INT". The value is `0x1405` which comes from OpenGL. This indicates data is stored in 4-byte or 32-bit unsigned integers. This is a core part of the glTF specification.
+     */
+    COMPONENT_TYPE_UNSIGNED_INT: 5125,
+    /**
+     * Component type "FLOAT". The value is `0x1406` which comes from OpenGL. This indicates data is stored in 4-byte or 32-bit floating-point numbers. This is a core part of the glTF specification.
+     */
+    COMPONENT_TYPE_SINGLE_FLOAT: 5126,
+    /**
+     * Component type "DOUBLE". The value is `0x140A` which comes from OpenGL. This indicates data is stored in 8-byte or 64-bit floating-point numbers. This is NOT a core part of the glTF specification, and may not be supported by all glTF importers. May be used by some extensions including `KHR_interactivity`.
+     */
+    COMPONENT_TYPE_DOUBLE_FLOAT: 5130,
+    /**
+     * Component type "HALF_FLOAT". The value is `0x140B` which comes from OpenGL. This indicates data is stored in 2-byte or 16-bit floating-point numbers. This is NOT a core part of the glTF specification, and may not be supported by all glTF importers. May be used by some extensions including `KHR_interactivity`.
+     */
+    COMPONENT_TYPE_HALF_FLOAT: 5131,
+    /**
+     * Component type "LONG". The value is `0x140E` which comes from OpenGL. This indicates data is stored in 8-byte or 64-bit signed integers. This is NOT a core part of the glTF specification, and may not be supported by all glTF importers. May be used by some extensions including `KHR_interactivity`.
+     */
+    COMPONENT_TYPE_SIGNED_LONG: 5134,
+    /**
+     * Component type "UNSIGNED_LONG". The value is `0x140F` which comes from OpenGL. This indicates data is stored in 8-byte or 64-bit unsigned integers. This is NOT a core part of the glTF specification, and may not be supported by all glTF importers. May be used by some extensions including `KHR_interactivity`.
+     */
+    COMPONENT_TYPE_UNSIGNED_LONG: 5135,
+} as const;
+
+export type GLTFComponentType = (typeof GLTFComponentType)[keyof typeof GLTFComponentType];
+

package/gen/classes/GLTFAnimation.ts

@@ -0,0 +1,33 @@
+// 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 { StringName, Variant } from '../heap-types/index.ts';
+
+export class GLTFAnimation extends Resource {
+    constructor(name = 280) { super(name); }
+
+    /**
+     * Gets additional arbitrary data in this {@link GLTFAnimation} 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 GLTFAnimation} 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 animation.
+     */
+    get originalName(): string { return _C(this, 5747) as string; }
+    set originalName(v: string) { _C(this, 12208, v); }
+
+    get loop(): boolean { return _C(this, 5416) as boolean; }
+    set loop(v: boolean) { _C(this, 11949, v); }
+
+    static readonly name = _R(280, GLTFAnimation);
+}

package/gen/classes/GLTFBufferView.ts

@@ -0,0 +1,68 @@
+// 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, PackedByteArray } from '../heap-types/index.ts';
+import type { GLTFState } from './GLTFState.ts';
+
+/**
+ * GLTFBufferView is a data structure representing a glTF `bufferView` that would be found in the `"bufferViews"` array. A buffer is a blob of binary data. A buffer view is a slice of a buffer that can be used to identify and extract data from the buffer.
+ * Most custom uses of buffers only need to use the {@link buffer}, {@link byteLength}, and {@link byteOffset}. The {@link byteStride} and {@link indices} properties are for more advanced use cases such as interleaved mesh data encoded for the GPU.
+ */
+export class GLTFBufferView extends Resource {
+    constructor(name = 281) { super(name); }
+
+    /**
+     * Loads the buffer view data from the buffer referenced by this buffer view in the given {@link GLTFState}. Interleaved data with a byte stride is not yet supported by this method. The data is returned as a {@link PackedByteArray}.
+     */
+    loadBufferViewData(state: GLTFState): PackedByteArray { return _C(this, 8668, state) as PackedByteArray; }
+
+    /**
+     * Creates a new GLTFBufferView instance by parsing the given {@link Dictionary}.
+     */
+    static fromDictionary(dictionary: GodotDictionary): GLTFBufferView { return _C(281, 3594, dictionary) as GLTFBufferView; }
+
+    /**
+     * Serializes this GLTFBufferView instance into a {@link Dictionary}.
+     */
+    toDictionary(): GodotDictionary { return _C(this, 14292) as GodotDictionary; }
+
+    /**
+     * The index of the buffer this buffer view is referencing. If `-1`, this buffer view is not referencing any buffer.
+     */
+    get buffer(): number { return _C(this, 4003) as number; }
+    set buffer(v: number) { _C(this, 10740, v); }
+
+    /**
+     * The offset, in bytes, from the start of the buffer to the start of this buffer view.
+     */
+    get byteOffset(): number { return _C(this, 4040) as number; }
+    set byteOffset(v: number) { _C(this, 10770, v); }
+
+    /**
+     * The length, in bytes, of this buffer view. If `0`, this buffer view is empty.
+     */
+    get byteLength(): number { return _C(this, 4039) as number; }
+    set byteLength(v: number) { _C(this, 10769, v); }
+
+    /**
+     * The stride, in bytes, between interleaved data. If `-1`, this buffer view is not interleaved.
+     */
+    get byteStride(): number { return _C(this, 4041) as number; }
+    set byteStride(v: number) { _C(this, 10771, v); }
+
+    /**
+     * `true` if the GLTFBufferView's OpenGL GPU buffer type is an `ELEMENT_ARRAY_BUFFER` used for vertex indices (integer constant `34963`). `false` if the buffer type is any other value. See [Buffers, BufferViews, and Accessors](https://github.com/KhronosGroup/glTF-Tutorials/blob/master/gltfTutorial/gltfTutorial_005_BuffersBufferViewsAccessors.md) for possible values. This property is set on import and used on export.
+     */
+    get indices(): boolean { return _C(this, 5091) as boolean; }
+    set indices(v: boolean) { _C(this, 11692, v); }
+
+    /**
+     * `true` if the GLTFBufferView's OpenGL GPU buffer type is an `ARRAY_BUFFER` used for vertex attributes (integer constant `34962`). `false` if the buffer type is any other value. See [Buffers, BufferViews, and Accessors](https://github.com/KhronosGroup/glTF-Tutorials/blob/master/gltfTutorial/gltfTutorial_005_BuffersBufferViewsAccessors.md) for possible values. This property is set on import and used on export.
+     */
+    get vertexAttributes(): boolean { return _C(this, 7046) as boolean; }
+    set vertexAttributes(v: boolean) { _C(this, 13287, v); }
+
+    static readonly name = _R(281, GLTFBufferView);
+}

package/gen/classes/GLTFCamera.ts

@@ -0,0 +1,66 @@
+// 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 { Camera3D } from './Camera3D.ts';
+
+/**
+ * Represents a camera as defined by the base glTF spec.
+ */
+export class GLTFCamera extends Resource {
+    constructor(name = 282) { super(name); }
+
+    /**
+     * Create a new GLTFCamera instance from the given Godot {@link Camera3D} node.
+     */
+    static fromNode(cameraNode: Camera3D): GLTFCamera { return _C(282, 3599, cameraNode) as GLTFCamera; }
+
+    /**
+     * Converts this GLTFCamera instance into a Godot {@link Camera3D} node.
+     */
+    toNode(): Camera3D { return _C(this, 14306) as Camera3D; }
+
+    /**
+     * Creates a new GLTFCamera instance by parsing the given {@link Dictionary}.
+     */
+    static fromDictionary(dictionary: GodotDictionary): GLTFCamera { return _C(282, 3594, dictionary) as GLTFCamera; }
+
+    /**
+     * Serializes this GLTFCamera instance into a {@link Dictionary}.
+     */
+    toDictionary(): GodotDictionary { return _C(this, 14292) as GodotDictionary; }
+
+    /**
+     * If `true`, the camera is in perspective mode. Otherwise, the camera is in orthographic/orthogonal mode. This maps to glTF's camera `type` property. See {@link Camera3D.projection} and the glTF spec for more information.
+     */
+    get perspective(): boolean { return _C(this, 5881) as boolean; }
+    set perspective(v: boolean) { _C(this, 12304, v); }
+
+    /**
+     * The FOV of the camera. This class and glTF define the camera FOV in radians, while Godot uses degrees. This maps to glTF's `yfov` property. This value is only used for perspective cameras, when {@link perspective} is `true`.
+     */
+    get fov(): number { return _C(this, 4865) as number; }
+    set fov(v: number) { _C(this, 11468, v); }
+
+    /**
+     * The size of the camera. This class and glTF define the camera size magnitude as a radius in meters, while Godot defines it as a diameter in meters. This maps to glTF's `ymag` property. This value is only used for orthographic/orthogonal cameras, when {@link perspective} is `false`.
+     */
+    get sizeMag(): number { return _C(this, 6402) as number; }
+    set sizeMag(v: number) { _C(this, 12755, v); }
+
+    /**
+     * The distance to the far culling boundary for this camera relative to its local Z axis, in meters. This maps to glTF's `zfar` property.
+     */
+    get depthFar(): number { return _C(this, 4476) as number; }
+    set depthFar(v: number) { _C(this, 11091, v); }
+
+    /**
+     * The distance to the near culling boundary for this camera relative to its local Z axis, in meters. This maps to glTF's `znear` property.
+     */
+    get depthNear(): number { return _C(this, 4478) as number; }
+    set depthNear(v: number) { _C(this, 11092, v); }
+
+    static readonly name = _R(282, GLTFCamera);
+}