@ringozz/godot 0.1.0

package/gen/classes/TextServerAdvanced.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { TextServerExtension } from './TextServerExtension.ts';
+
+/**
+ * An implementation of {@link TextServer} that uses HarfBuzz, ICU and SIL Graphite to support BiDi, complex text layouts and contextual OpenType features. This is Godot's default primary {@link TextServer} interface.
+ */
+export class TextServerAdvanced extends TextServerExtension {
+    constructor(name = 772) { super(name); }
+
+    static readonly name = _R(772, TextServerAdvanced);
+}

package/gen/classes/TextServerDummy.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 { TextServerExtension } from './TextServerExtension.ts';
+
+/**
+ * A dummy {@link TextServer} interface that doesn't do anything. Useful for freeing up memory when rendering text is not needed, as text servers are resource-intensive. It can also be used for performance comparisons in complex GUIs to check the impact of text rendering.
+ * A dummy text server is always available at the start of a project. Here's how to access it:
+ *
+ * ```text
+ *
+ * var dummy_text_server = TextServerManager.find_interface("Dummy")
+ * if dummy_text_server != null:
+ * 	TextServerManager.set_primary_interface(dummy_text_server)
+ * 	# If the other text servers are unneeded, they can be removed:
+ * 	for i in TextServerManager.get_interface_count():
+ * 		var text_server = TextServerManager.get_interface(i)
+ * 		if text_server != dummy_text_server:
+ * 			TextServerManager.remove_interface(text_server)
+ *
+ * ```
+ *
+ * The command line argument `--text-driver Dummy` (case-sensitive) can be used to force the "Dummy" {@link TextServer} on any project.
+ */
+export class TextServerDummy extends TextServerExtension {
+    constructor(name = 773) { super(name); }
+
+    static readonly name = _R(773, TextServerDummy);
+}

package/gen/classes/TextServerExtension.ts

@@ -0,0 +1,20 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { TextServer } from './TextServer.ts';
+import type { InlineAlignment, Orientation } from '../global-enums.ts';
+import type { GodotArray, GodotDictionary, PackedByteArray, PackedColorArray, PackedFloat32Array, PackedInt32Array, PackedStringArray, PackedVector2Array, RID, Variant } from '../heap-types/index.ts';
+import type { Color, Rect2, Transform2D, Vector2, Vector2i, Vector3i } from '../value-types/index.ts';
+import type { Feature } from './BaseMaterial3D.ts';
+import type { Image } from './Image.ts';
+import type { Direction, FixedSizeScaleMode, FontAntialiasing, FontStyle, GraphemeFlag, Hinting, JustificationFlag, LineBreakFlag, SpacingType, StructuredTextParser, SubpixelPositioning, TextOverrunFlag } from './TextServer.ts';
+
+/**
+ * External {@link TextServer} implementations should inherit from this class.
+ */
+export class TextServerExtension extends TextServer {
+    constructor(name = 774) { super(name); }
+
+    static readonly name = _R(774, TextServerExtension);
+}

package/gen/classes/TextServerManager.ts

@@ -0,0 +1,71 @@
+// 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 { GodotArray, GodotDictionary, Signal, StringName } from '../heap-types/index.ts';
+import type { TextServer } from './TextServer.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 775));
+
+/**
+ * {@link TextServerManager} is the API backend for loading, enumerating, and switching {@link TextServer}s.
+ * **Note:** Switching text server at runtime is possible, but will invalidate all fonts and text buffers. Make sure to unload all controls, fonts, and themes before doing so.
+ */
+export class TextServerManager extends GodotVar {
+
+    /**
+     * Registers a {@link TextServer} interface.
+     */
+    static addInterface(_interface: TextServer): void { _C($(), 1240, _interface); }
+
+    /**
+     * Returns the number of interfaces currently registered.
+     */
+    static getInterfaceCount(): number { return _C($(), 5148) as number; }
+
+    /**
+     * Removes an interface. All fonts and shaped text caches should be freed before removing an interface.
+     */
+    static removeInterface(_interface: TextServer): void { _C($(), 9923, _interface); }
+
+    /**
+     * Returns the interface registered at a given index.
+     */
+    static getInterface(idx: number): TextServer { return _C($(), 5147, idx) as TextServer; }
+
+    /**
+     * Returns a list of available interfaces, with the index and name of each interface.
+     */
+    static getInterfaces(): GodotArray<GodotDictionary> { return _C($(), 5149) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Finds an interface by its `name`.
+     */
+    static findInterface(name: string): TextServer { return _C($(), 3289, name) as TextServer; }
+
+    /**
+     * Sets the primary {@link TextServer} interface.
+     */
+    static setPrimaryInterface(index: TextServer): void { _C($(), 12410, index); }
+
+    /**
+     * Returns the primary {@link TextServer} interface currently in use.
+     */
+    static getPrimaryInterface(): TextServer { return _C($(), 6005) as TextServer; }
+
+    /**
+     * Emitted when a new interface has been added.
+     */
+    static get interfaceAdded(): Signal<(interfaceName: StringName) => void> { return _G($(), 7685) as Signal<(interfaceName: StringName) => void>; }
+    static set interfaceAdded(v: ((interfaceName: StringName) => void) | null) { _G($(), 7685, v); }
+
+    /**
+     * Emitted when an interface is removed.
+     */
+    static get interfaceRemoved(): Signal<(interfaceName: StringName) => void> { return _G($(), 7687) as Signal<(interfaceName: StringName) => void>; }
+    static set interfaceRemoved(v: ((interfaceName: StringName) => void) | null) { _G($(), 7687, v); }
+
+    static readonly name = _R(775, TextServerManager);
+}

package/gen/classes/Texture.ts

@@ -0,0 +1,14 @@
+// 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';
+
+/**
+ * {@link Texture} is the base class for all texture types. Common texture types are {@link Texture2D} and {@link ImageTexture}. See also {@link Image}.
+ */
+export class Texture extends Resource {
+    constructor(name = 776) { super(name); }
+
+    static readonly name = _R(776, Texture);
+}

package/gen/classes/Texture2D.ts

@@ -0,0 +1,84 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture } from './Texture.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { Color, Rect2, Vector2 } from '../value-types/index.ts';
+import type { Format } from './AudioStreamWAV.ts';
+import type { Image } from './Image.ts';
+import type { Resource } from './Resource.ts';
+
+/**
+ * A texture works by registering an image in the video hardware, which then can be used in 3D models or 2D {@link Sprite2D} or GUI {@link Control}.
+ * Textures are often created by loading them from a file. See `@GDScript.load`.
+ * {@link Texture2D} is a base for other resources. It cannot be used directly.
+ * **Note:** The maximum texture size is 16384×16384 pixels due to graphics hardware limitations. Larger textures may fail to import.
+ */
+export class Texture2D extends Texture {
+    constructor(name = 777) { super(name); }
+
+    /**
+     * Returns the image format of the texture.
+     */
+    getFormat(): Format { return _C(this, 4861) as Format; }
+
+    /**
+     * Returns the number of mipmaps of the texture.
+     */
+    getMipmapCount(): number { return _C(this, 5558) as number; }
+
+    /**
+     * Returns the texture width in pixels.
+     */
+    getWidth(): number { return _C(this, 7148) as number; }
+
+    /**
+     * Returns the texture height in pixels.
+     */
+    getHeight(): number { return _C(this, 5024) as number; }
+
+    /**
+     * Returns the texture size in pixels.
+     */
+    getSize(): Vector2 { return _C(this, 6399) as Vector2; }
+
+    /**
+     * Returns `true` if this {@link Texture2D} has an alpha channel.
+     */
+    hasAlpha(): boolean { return _C(this, 7353) as boolean; }
+
+    /**
+     * Returns `true` if the texture has mipmaps.
+     */
+    hasMipmaps(): boolean { return _C(this, 7418) as boolean; }
+
+    /**
+     * Draws the texture using a {@link CanvasItem} with the {@link RenderingServer} API at the specified `position`.
+     */
+    draw(canvasItem: RID, position: Vector2, modulate?: Color /* = Color(1, 1, 1, 1) */, transpose?: boolean /* = false */): void { _C(this, 2902, canvasItem, position, modulate, transpose); }
+
+    /**
+     * Draws the texture using a {@link CanvasItem} with the {@link RenderingServer} API.
+     */
+    drawRect(canvasItem: RID, rect: Rect2, tile: boolean, modulate?: Color /* = Color(1, 1, 1, 1) */, transpose?: boolean /* = false */): void { _C(this, 2960, canvasItem, rect, tile, modulate, transpose); }
+
+    /**
+     * Draws a part of the texture using a {@link CanvasItem} with the {@link RenderingServer} API.
+     */
+    drawRectRegion(canvasItem: RID, rect: Rect2, srcRect: Rect2, modulate?: Color /* = Color(1, 1, 1, 1) */, transpose?: boolean /* = false */, clipUv?: boolean /* = true */): void { _C(this, 2961, canvasItem, rect, srcRect, modulate, transpose, clipUv); }
+
+    /**
+     * Returns an {@link Image} that is a copy of data from this {@link Texture2D} (a new {@link Image} is created each time). {@link Image}s can be accessed and manipulated directly.
+     * **Note:** This will return `null` if this {@link Texture2D} is invalid.
+     * **Note:** This will fetch the texture data from the GPU, which might cause performance problems when overused. Avoid calling {@link getImage} every frame, especially on large textures.
+     */
+    getImage(): Image { return _C(this, 5071) as Image; }
+
+    /**
+     * Creates a placeholder version of this resource ({@link PlaceholderTexture2D}).
+     */
+    createPlaceholder(): Resource { return _C(this, 2563) as Resource; }
+
+    static readonly name = _R(777, Texture2D);
+}

package/gen/classes/Texture2DArray.ts

@@ -0,0 +1,22 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { ImageTextureLayered } from './ImageTextureLayered.ts';
+import type { Resource } from './Resource.ts';
+
+/**
+ * A Texture2DArray is different from a Texture3D: The Texture2DArray does not support trilinear interpolation between the {@link Image}s, i.e. no blending. See also {@link Cubemap} and {@link CubemapArray}, which are texture arrays with specialized cubemap functions.
+ * A Texture2DArray is also different from an {@link AtlasTexture}: In a Texture2DArray, all images are treated separately. In an atlas, the regions (i.e. the single images) can be of different sizes. Furthermore, you usually need to add a padding around the regions, to prevent accidental UV mapping to more than one region. The same goes for mipmapping: Mipmap chains are handled separately for each layer. In an atlas, the slicing has to be done manually in the fragment shader.
+ * To create such a texture file yourself, reimport your image files using the Godot Editor import presets. To create a Texture2DArray from code, use {@link ImageTextureLayered.createFromImages} on an instance of the Texture2DArray class.
+ */
+export class Texture2DArray extends ImageTextureLayered {
+    constructor(name = 778) { super(name); }
+
+    /**
+     * Creates a placeholder version of this resource ({@link PlaceholderTexture2DArray}).
+     */
+    createPlaceholder(): Resource { return _C(this, 2563) as Resource; }
+
+    static readonly name = _R(778, Texture2DArray);
+}

package/gen/classes/Texture2DArrayRD.ts

@@ -0,0 +1,15 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { TextureLayeredRD } from './TextureLayeredRD.ts';
+
+/**
+ * This texture array class allows you to use a 2D array texture created directly on the {@link RenderingDevice} as a texture for materials, meshes, etc.
+ * **Note:** {@link Texture2DArrayRD} is intended for low-level usage with {@link RenderingDevice}. For most use cases, use {@link Texture2DArray} instead.
+ */
+export class Texture2DArrayRD extends TextureLayeredRD {
+    constructor(name = 779) { super(name); }
+
+    static readonly name = _R(779, Texture2DArrayRD);
+}

package/gen/classes/Texture2DRD.ts

@@ -0,0 +1,22 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture2D } from './Texture2D.ts';
+import type { RID } from '../heap-types/index.ts';
+
+/**
+ * This texture class allows you to use a 2D texture created directly on the {@link RenderingDevice} as a texture for materials, meshes, etc.
+ * **Note:** {@link Texture2DRD} is intended for low-level usage with {@link RenderingDevice}. For most use cases, use {@link Texture2D} instead.
+ */
+export class Texture2DRD extends Texture2D {
+    constructor(name = 780) { super(name); }
+
+    /**
+     * The RID of the texture object created on the {@link RenderingDevice}.
+     */
+    get textureRdRid(): RID { return _C(this, 6745) as RID; }
+    set textureRdRid(v: RID) { _C(this, 13042, v); }
+
+    static readonly name = _R(780, Texture2DRD);
+}

package/gen/classes/Texture3D.ts

@@ -0,0 +1,55 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture } from './Texture.ts';
+import type { GodotArray } from '../heap-types/index.ts';
+import type { Format } from './AudioStreamWAV.ts';
+import type { Image } from './Image.ts';
+import type { Resource } from './Resource.ts';
+
+/**
+ * Base class for {@link ImageTexture3D} and {@link CompressedTexture3D}. Cannot be used directly, but contains all the functions necessary for accessing the derived resource types. {@link Texture3D} is the base class for all 3-dimensional texture types. See also {@link TextureLayered}.
+ * All images need to have the same width, height and number of mipmap levels.
+ * To create such a texture file yourself, reimport your image files using the Godot Editor import presets.
+ */
+export class Texture3D extends Texture {
+    constructor(name = 781) { super(name); }
+
+    /**
+     * Returns the current format being used by this texture.
+     */
+    getFormat(): Format { return _C(this, 4861) as Format; }
+
+    /**
+     * Returns the {@link Texture3D}'s width in pixels. Width is typically represented by the X axis.
+     */
+    getWidth(): number { return _C(this, 7148) as number; }
+
+    /**
+     * Returns the {@link Texture3D}'s height in pixels. Width is typically represented by the Y axis.
+     */
+    getHeight(): number { return _C(this, 5024) as number; }
+
+    /**
+     * Returns the {@link Texture3D}'s depth in pixels. Depth is typically represented by the Z axis (a dimension not present in {@link Texture2D}).
+     */
+    getDepth(): number { return _C(this, 4468) as number; }
+
+    /**
+     * Returns `true` if the {@link Texture3D} has generated mipmaps.
+     */
+    hasMipmaps(): boolean { return _C(this, 7418) as boolean; }
+
+    /**
+     * Returns the {@link Texture3D}'s data as an array of {@link Image}s. Each {@link Image} represents a *slice* of the {@link Texture3D}, with different slices mapping to different depth (Z axis) levels.
+     */
+    getData(): GodotArray<Image> { return _C(this, 4410) as GodotArray<Image>; }
+
+    /**
+     * Creates a placeholder version of this resource ({@link PlaceholderTexture3D}).
+     */
+    createPlaceholder(): Resource { return _C(this, 2563) as Resource; }
+
+    static readonly name = _R(781, Texture3D);
+}

package/gen/classes/Texture3DRD.ts

@@ -0,0 +1,22 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture3D } from './Texture3D.ts';
+import type { RID } from '../heap-types/index.ts';
+
+/**
+ * This texture class allows you to use a 3D texture created directly on the {@link RenderingDevice} as a texture for materials, meshes, etc.
+ * **Note:** {@link Texture3DRD} is intended for low-level usage with {@link RenderingDevice}. For most use cases, use {@link Texture3D} instead.
+ */
+export class Texture3DRD extends Texture3D {
+    constructor(name = 782) { super(name); }
+
+    /**
+     * The RID of the texture object created on the {@link RenderingDevice}.
+     */
+    get textureRdRid(): RID { return _C(this, 6745) as RID; }
+    set textureRdRid(v: RID) { _C(this, 13042, v); }
+
+    static readonly name = _R(782, Texture3DRD);
+}

package/gen/classes/TextureButton.ts

@@ -0,0 +1,112 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { BaseButton } from './BaseButton.ts';
+import type { BitMap } from './BitMap.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * {@link TextureButton} has the same functionality as {@link Button}, except it uses sprites instead of Godot's {@link Theme} resource. It is faster to create, but it doesn't support localization like more complex {@link Control}s.
+ * See also {@link BaseButton} which contains common properties and methods associated with this node.
+ * **Note:** Setting a texture for the "normal" state ({@link textureNormal}) is recommended. If {@link textureNormal} is not set, the {@link TextureButton} will still receive input events and be clickable, but the user will not be able to see it unless they activate another one of its states with a texture assigned (e.g., hover over it to show {@link textureHover}).
+ */
+export class TextureButton extends BaseButton {
+    constructor(name = 783) { super(name); }
+
+    /**
+     * Texture to display by default, when the node is **not** in the disabled, hover or pressed state. This texture is still displayed in the focused state, with {@link textureFocused} drawn on top.
+     */
+    get textureNormal(): Texture2D { return _C(this, 6739) as Texture2D; }
+    set textureNormal(v: Texture2D) { _C(this, 13036, v); }
+
+    /**
+     * Texture to display on mouse down over the node, if the node has keyboard focus and the player presses the Enter key or if the player presses the {@link BaseButton.shortcut} key. If not assigned, the {@link TextureButton} displays {@link textureHover} instead when pressed.
+     */
+    get texturePressed(): Texture2D { return _C(this, 6743) as Texture2D; }
+    set texturePressed(v: Texture2D) { _C(this, 13040, v); }
+
+    /**
+     * Texture to display when the mouse hovers over the node. If not assigned, the {@link TextureButton} displays {@link textureNormal} instead when hovered over.
+     */
+    get textureHover(): Texture2D { return _C(this, 6733) as Texture2D; }
+    set textureHover(v: Texture2D) { _C(this, 13029, v); }
+
+    /**
+     * Texture to display when the node is disabled. See {@link BaseButton.disabled}. If not assigned, the {@link TextureButton} displays {@link textureNormal} instead.
+     */
+    get textureDisabled(): Texture2D { return _C(this, 6729) as Texture2D; }
+    set textureDisabled(v: Texture2D) { _C(this, 13026, v); }
+
+    /**
+     * Texture to *overlay on the base texture* when the node has mouse or keyboard focus. Because {@link textureFocused} is displayed on top of the base texture, a partially transparent texture should be used to ensure the base texture remains visible. A texture that represents an outline or an underline works well for this purpose. To disable the focus visual effect, assign a fully transparent texture of any size. Note that disabling the focus visual effect will harm keyboard/controller navigation usability, so this is not recommended for accessibility reasons.
+     */
+    get textureFocused(): Texture2D { return _C(this, 6731) as Texture2D; }
+    set textureFocused(v: Texture2D) { _C(this, 13028, v); }
+
+    /**
+     * Pure black and white {@link BitMap} image to use for click detection. On the mask, white pixels represent the button's clickable area. Use it to create buttons with curved shapes.
+     */
+    get textureClickMask(): BitMap { return _C(this, 4156) as BitMap; }
+    set textureClickMask(v: BitMap) { _C(this, 10860, v); }
+
+    /**
+     * If `true`, the size of the texture won't be considered for minimum size calculation, so the {@link TextureButton} can be shrunk down past the texture size.
+     */
+    get ignoreTextureSize(): boolean { return _C(this, 5070) as boolean; }
+    set ignoreTextureSize(v: boolean) { _C(this, 11667, v); }
+
+    /**
+     * Controls the texture's behavior when you resize the node's bounding rectangle. See the {@link StretchMode} constants for available options.
+     */
+    get stretchMode(): StretchMode { return _C(this, 6569) as StretchMode; }
+    set stretchMode(v: StretchMode) { _C(this, 12907, v); }
+
+    /**
+     * If `true`, texture is flipped horizontally.
+     */
+    get flipH(): boolean { return _C(this, 7957) as boolean; }
+    set flipH(v: boolean) { _C(this, 11417, v); }
+
+    /**
+     * If `true`, texture is flipped vertically.
+     */
+    get flipV(): boolean { return _C(this, 7958) as boolean; }
+    set flipV(v: boolean) { _C(this, 11418, v); }
+
+    static readonly name = _R(783, TextureButton);
+}
+
+export const StretchMode = {
+    /**
+     * Scale to fit the node's bounding rectangle.
+     */
+    STRETCH_SCALE: 0,
+    /**
+     * Tile inside the node's bounding rectangle.
+     */
+    STRETCH_TILE: 1,
+    /**
+     * The texture keeps its original size and stays in the bounding rectangle's top-left corner.
+     */
+    STRETCH_KEEP: 2,
+    /**
+     * The texture keeps its original size and stays centered in the node's bounding rectangle.
+     */
+    STRETCH_KEEP_CENTERED: 3,
+    /**
+     * Scale the texture to fit the node's bounding rectangle, but maintain the texture's aspect ratio.
+     */
+    STRETCH_KEEP_ASPECT: 4,
+    /**
+     * Scale the texture to fit the node's bounding rectangle, center it, and maintain its aspect ratio.
+     */
+    STRETCH_KEEP_ASPECT_CENTERED: 5,
+    /**
+     * Scale the texture so that the shorter side fits the bounding rectangle. The other side clips to the node's limits.
+     */
+    STRETCH_KEEP_ASPECT_COVERED: 6,
+} as const;
+
+export type StretchMode = (typeof StretchMode)[keyof typeof StretchMode];
+

package/gen/classes/TextureCubemapArrayRD.ts

@@ -0,0 +1,15 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { TextureLayeredRD } from './TextureLayeredRD.ts';
+
+/**
+ * This texture class allows you to use a cubemap array texture created directly on the {@link RenderingDevice} as a texture for materials, meshes, etc.
+ * **Note:** {@link TextureCubemapArrayRD} is intended for low-level usage with {@link RenderingDevice}. For most use cases, use {@link CubemapArray} instead.
+ */
+export class TextureCubemapArrayRD extends TextureLayeredRD {
+    constructor(name = 784) { super(name); }
+
+    static readonly name = _R(784, TextureCubemapArrayRD);
+}

package/gen/classes/TextureCubemapRD.ts

@@ -0,0 +1,15 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { TextureLayeredRD } from './TextureLayeredRD.ts';
+
+/**
+ * This texture class allows you to use a cubemap texture created directly on the {@link RenderingDevice} as a texture for materials, meshes, etc.
+ * **Note:** {@link TextureCubemapRD} is intended for low-level usage with {@link RenderingDevice}. For most use cases, use {@link Cubemap} instead.
+ */
+export class TextureCubemapRD extends TextureLayeredRD {
+    constructor(name = 785) { super(name); }
+
+    static readonly name = _R(785, TextureCubemapRD);
+}

package/gen/classes/TextureLayered.ts

@@ -0,0 +1,73 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture } from './Texture.ts';
+import type { Format } from './AudioStreamWAV.ts';
+import type { Image } from './Image.ts';
+
+/**
+ * Base class for {@link ImageTextureLayered} and {@link CompressedTextureLayered}. Cannot be used directly, but contains all the functions necessary for accessing the derived resource types. See also {@link Texture3D}.
+ * Data is set on a per-layer basis. For {@link Texture2DArray}s, the layer specifies the array layer.
+ * All images need to have the same width, height and number of mipmap levels.
+ * A {@link TextureLayered} can be loaded with {@link ResourceLoader.load}.
+ * Internally, Godot maps these files to their respective counterparts in the target rendering driver (Vulkan, OpenGL3).
+ */
+export class TextureLayered extends Texture {
+    constructor(name = 786) { super(name); }
+
+    /**
+     * Returns the current format being used by this texture.
+     */
+    getFormat(): Format { return _C(this, 4861) as Format; }
+
+    /**
+     * Returns the {@link TextureLayered}'s type. The type determines how the data is accessed, with cubemaps having special types.
+     */
+    getLayeredType(): LayeredType { return _C(this, 5326) as LayeredType; }
+
+    /**
+     * Returns the width of the texture in pixels. Width is typically represented by the X axis.
+     */
+    getWidth(): number { return _C(this, 7148) as number; }
+
+    /**
+     * Returns the height of the texture in pixels. Height is typically represented by the Y axis.
+     */
+    getHeight(): number { return _C(this, 5024) as number; }
+
+    /**
+     * Returns the number of referenced {@link Image}s.
+     */
+    getLayers(): number { return _C(this, 5327) as number; }
+
+    /**
+     * Returns `true` if the layers have generated mipmaps.
+     */
+    hasMipmaps(): boolean { return _C(this, 7418) as boolean; }
+
+    /**
+     * Returns an {@link Image} resource with the data from specified `layer`.
+     */
+    getLayerData(layer: number): Image { return _C(this, 5314, layer) as Image; }
+
+    static readonly name = _R(786, TextureLayered);
+}
+
+export const LayeredType = {
+    /**
+     * Texture is a generic {@link Texture2DArray}.
+     */
+    LAYERED_TYPE_2D_ARRAY: 0,
+    /**
+     * Texture is a {@link Cubemap}, with each side in its own layer (6 in total).
+     */
+    LAYERED_TYPE_CUBEMAP: 1,
+    /**
+     * Texture is a {@link CubemapArray}, with each cubemap being made of 6 layers.
+     */
+    LAYERED_TYPE_CUBEMAP_ARRAY: 2,
+} as const;
+
+export type LayeredType = (typeof LayeredType)[keyof typeof LayeredType];
+

package/gen/classes/TextureLayeredRD.ts

@@ -0,0 +1,21 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { TextureLayered } from './TextureLayered.ts';
+import type { RID } from '../heap-types/index.ts';
+
+/**
+ * Base class for {@link Texture2DArrayRD}, {@link TextureCubemapRD} and {@link TextureCubemapArrayRD}. Cannot be used directly, but contains all the functions necessary for accessing the derived resource types.
+ * **Note:** {@link TextureLayeredRD} is intended for low-level usage with {@link RenderingDevice}. For most use cases, use {@link TextureLayered} instead.
+ */
+export class TextureLayeredRD extends TextureLayered {
+
+    /**
+     * The RID of the texture object created on the {@link RenderingDevice}.
+     */
+    get textureRdRid(): RID { return _C(this, 6745) as RID; }
+    set textureRdRid(v: RID) { _C(this, 13042, v); }
+
+    static readonly name = _R(787, TextureLayeredRD);
+}