@ringozz/godot 0.1.0

package/gen/classes/RDPipelineRasterizationState.ts

@@ -0,0 +1,81 @@
+// 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 { PolygonCullMode, PolygonFrontFace } from './RenderingDevice.ts';
+
+/**
+ * This object is used by {@link RenderingDevice}.
+ */
+export class RDPipelineRasterizationState extends RefCounted {
+    constructor(name = 624) { super(name); }
+
+    /**
+     * If `true`, clamps depth values according to the minimum and maximum depth of the associated viewport.
+     */
+    get enableDepthClamp(): boolean { return _C(this, 4645) as boolean; }
+    set enableDepthClamp(v: boolean) { _C(this, 11270, v); }
+
+    /**
+     * If `true`, primitives are discarded immediately before the rasterization stage.
+     */
+    get discardPrimitives(): boolean { return _C(this, 4512) as boolean; }
+    set discardPrimitives(v: boolean) { _C(this, 11123, v); }
+
+    /**
+     * If `true`, performs wireframe rendering for triangles instead of flat or textured rendering.
+     */
+    get wireframe(): boolean { return _C(this, 7157) as boolean; }
+    set wireframe(v: boolean) { _C(this, 13379, v); }
+
+    /**
+     * The cull mode to use when drawing polygons, which determines whether front faces or backfaces are hidden.
+     */
+    get cullMode(): PolygonCullMode { return _C(this, 4341) as PolygonCullMode; }
+    set cullMode(v: PolygonCullMode) { _C(this, 10983, v); }
+
+    /**
+     * The winding order to use to determine which face of a triangle is considered its front face.
+     */
+    get frontFace(): PolygonFrontFace { return _C(this, 4900) as PolygonFrontFace; }
+    set frontFace(v: PolygonFrontFace) { _C(this, 11493, v); }
+
+    /**
+     * If `true`, each generated depth value will by offset by some amount. The specific amount is generated per polygon based on the values of {@link depthBiasSlopeFactor} and {@link depthBiasConstantFactor}.
+     */
+    get depthBiasEnabled(): boolean { return _C(this, 4472) as boolean; }
+    set depthBiasEnabled(v: boolean) { _C(this, 11087, v); }
+
+    /**
+     * A constant offset added to each depth value. Applied after {@link depthBiasSlopeFactor}.
+     */
+    get depthBiasConstantFactor(): number { return _C(this, 4471) as number; }
+    set depthBiasConstantFactor(v: number) { _C(this, 11086, v); }
+
+    /**
+     * A limit for how much each depth value can be offset. If negative, it serves as a minimum value, but if positive, it serves as a maximum value.
+     */
+    get depthBiasClamp(): number { return _C(this, 4470) as number; }
+    set depthBiasClamp(v: number) { _C(this, 11085, v); }
+
+    /**
+     * A constant scale applied to the slope of each polygons' depth. Applied before {@link depthBiasConstantFactor}.
+     */
+    get depthBiasSlopeFactor(): number { return _C(this, 4473) as number; }
+    set depthBiasSlopeFactor(v: number) { _C(this, 11088, v); }
+
+    /**
+     * The line width to use when drawing lines (in pixels). Thick lines may not be supported on all hardware.
+     */
+    get lineWidth(): number { return _C(this, 5376) as number; }
+    set lineWidth(v: number) { _C(this, 11929, v); }
+
+    /**
+     * The number of control points to use when drawing a patch with tessellation enabled. Higher values result in higher quality at the cost of performance.
+     */
+    get patchControlPoints(): number { return _C(this, 5838) as number; }
+    set patchControlPoints(v: number) { _C(this, 12269, v); }
+
+    static readonly name = _R(624, RDPipelineRasterizationState);
+}

package/gen/classes/RDPipelineShader.ts

@@ -0,0 +1,29 @@
+// 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, RID } from '../heap-types/index.ts';
+import type { RDPipelineSpecializationConstant } from './RDPipelineSpecializationConstant.ts';
+
+/**
+ * Wraps a shader resource and allows specialization constants to be applied at pipeline creation time.
+ * Used by {@link RenderingDevice.raytracingPipelineCreate} for ray generation, miss, and hit shaders. The pipeline selects the required shader stage automatically.
+ */
+export class RDPipelineShader extends RefCounted {
+    constructor(name = 625) { super(name); }
+
+    /**
+     * Shader resource. The required stage is selected by the pipeline.
+     */
+    get shader(): RID { return _C(this, 6354) as RID; }
+    set shader(v: RID) { _C(this, 12701, v); }
+
+    /**
+     * Specialization constants applied to the selected shader stage at pipeline creation time.
+     */
+    get specializationConstants(): GodotArray<RDPipelineSpecializationConstant> { return _C(this, 6488) as GodotArray<RDPipelineSpecializationConstant>; }
+    set specializationConstants(v: GodotArray<RDPipelineSpecializationConstant>) { _C(this, 12832, v); }
+
+    static readonly name = _R(625, RDPipelineShader);
+}

package/gen/classes/RDPipelineSpecializationConstant.ts

@@ -0,0 +1,28 @@
+// 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 { Variant } from '../heap-types/index.ts';
+
+/**
+ * A *specialization constant* is a way to create additional variants of shaders without actually increasing the number of shader versions that are compiled. This allows improving performance by reducing the number of shader versions and reducing `if` branching, while still allowing shaders to be flexible for different use cases.
+ * This object is used by {@link RenderingDevice}.
+ */
+export class RDPipelineSpecializationConstant extends RefCounted {
+    constructor(name = 626) { super(name); }
+
+    /**
+     * The specialization constant's value. Only {@link bool}, {@link int} and {@link float} types are valid for specialization constants.
+     */
+    get value(): Variant { return _C(this, 7018) as Variant; }
+    set value(v: Variant) { _C(this, 13268, v); }
+
+    /**
+     * The identifier of the specialization constant. This is a value starting from `0` and that increments for every different specialization constant for a given shader.
+     */
+    get constantId(): number { return _C(this, 4286) as number; }
+    set constantId(v: number) { _C(this, 10945, v); }
+
+    static readonly name = _R(626, RDPipelineSpecializationConstant);
+}

package/gen/classes/RDSamplerState.ts

@@ -0,0 +1,106 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { CompareOperator, SamplerBorderColor, SamplerFilter, SamplerRepeatMode } from './RenderingDevice.ts';
+
+/**
+ * This object is used by {@link RenderingDevice}.
+ */
+export class RDSamplerState extends RefCounted {
+    constructor(name = 627) { super(name); }
+
+    /**
+     * The sampler's magnification filter. It is the filtering method used when sampling texels that appear bigger than on-screen pixels.
+     */
+    get magFilter(): SamplerFilter { return _C(this, 5428) as SamplerFilter; }
+    set magFilter(v: SamplerFilter) { _C(this, 11960, v); }
+
+    /**
+     * The sampler's minification filter. It is the filtering method used when sampling texels that appear smaller than on-screen pixels.
+     */
+    get minFilter(): SamplerFilter { return _C(this, 5540) as SamplerFilter; }
+    set minFilter(v: SamplerFilter) { _C(this, 12051, v); }
+
+    /**
+     * The filtering method to use for mipmaps.
+     */
+    get mipFilter(): SamplerFilter { return _C(this, 5557) as SamplerFilter; }
+    set mipFilter(v: SamplerFilter) { _C(this, 12064, v); }
+
+    /**
+     * The repeat mode to use along the U axis of UV coordinates. This affects the returned values if sampling outside the UV bounds.
+     */
+    get repeatU(): SamplerRepeatMode { return _C(this, 6146) as SamplerRepeatMode; }
+    set repeatU(v: SamplerRepeatMode) { _C(this, 12528, v); }
+
+    /**
+     * The repeat mode to use along the V axis of UV coordinates. This affects the returned values if sampling outside the UV bounds.
+     */
+    get repeatV(): SamplerRepeatMode { return _C(this, 6147) as SamplerRepeatMode; }
+    set repeatV(v: SamplerRepeatMode) { _C(this, 12529, v); }
+
+    /**
+     * The repeat mode to use along the W axis of UV coordinates. This affects the returned values if sampling outside the UV bounds. Only effective for 3D samplers.
+     */
+    get repeatW(): SamplerRepeatMode { return _C(this, 6148) as SamplerRepeatMode; }
+    set repeatW(v: SamplerRepeatMode) { _C(this, 12530, v); }
+
+    /**
+     * The mipmap LOD bias to use. Positive values will make the sampler blurrier at a given distance, while negative values will make the sampler sharper at a given distance (at the risk of looking grainy). Recommended values are between `-0.5` and `0.0`. Only effective if the sampler has mipmaps available.
+     */
+    get lodBias(): number { return _C(this, 5410) as number; }
+    set lodBias(v: number) { _C(this, 11947, v); }
+
+    /**
+     * If `true`, perform anisotropic sampling. See {@link anisotropyMax}.
+     */
+    get useAnisotropy(): boolean { return _C(this, 6972) as boolean; }
+    set useAnisotropy(v: boolean) { _C(this, 13196, v); }
+
+    /**
+     * Maximum anisotropy that can be used when sampling. Only effective if {@link useAnisotropy} is `true`. Higher values result in a sharper sampler at oblique angles, at the cost of performance (due to memory bandwidth). This value may be limited by the graphics hardware in use. Most graphics hardware only supports values up to `16.0`.
+     * If {@link anisotropyMax} is `1.0`, forcibly disables anisotropy even if {@link useAnisotropy} is `true`.
+     */
+    get anisotropyMax(): number { return _C(this, 3774) as number; }
+    set anisotropyMax(v: number) { _C(this, 10511, v); }
+
+    /**
+     * If `true`, returned values will be based on the comparison operation defined in {@link compareOp}. This is a hardware-based approach and is therefore faster than performing this manually in a shader. For example, compare operations are used for shadow map rendering by comparing depth values from a shadow sampler.
+     */
+    get enableCompare(): boolean { return _C(this, 4642) as boolean; }
+    set enableCompare(v: boolean) { _C(this, 11267, v); }
+
+    /**
+     * The compare operation to use. Only effective if {@link enableCompare} is `true`.
+     */
+    get compareOp(): CompareOperator { return _C(this, 4247) as CompareOperator; }
+    set compareOp(v: CompareOperator) { _C(this, 10928, v); }
+
+    /**
+     * The minimum mipmap LOD bias to display (highest resolution). Only effective if the sampler has mipmaps available.
+     */
+    get minLod(): number { return _C(this, 5542) as number; }
+    set minLod(v: number) { _C(this, 12052, v); }
+
+    /**
+     * The maximum mipmap LOD bias to display (lowest resolution). Only effective if the sampler has mipmaps available.
+     */
+    get maxLod(): number { return _C(this, 5474) as number; }
+    set maxLod(v: number) { _C(this, 11998, v); }
+
+    /**
+     * The border color that will be returned when sampling outside the sampler's bounds and the {@link repeatU}, {@link repeatV} or {@link repeatW} modes have repeating disabled.
+     */
+    get borderColor(): SamplerBorderColor { return _C(this, 3986) as SamplerBorderColor; }
+    set borderColor(v: SamplerBorderColor) { _C(this, 10726, v); }
+
+    /**
+     * If `true`, the texture will be sampled with coordinates ranging from 0 to the texture's resolution. Otherwise, the coordinates will be normalized and range from 0 to 1.
+     */
+    get unnormalizedUvw(): boolean { return _C(this, 6958) as boolean; }
+    set unnormalizedUvw(v: boolean) { _C(this, 13176, v); }
+
+    static readonly name = _R(627, RDSamplerState);
+}

package/gen/classes/RDShaderFile.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';
+import type { GodotArray, StringName } from '../heap-types/index.ts';
+import type { RDShaderSPIRV } from './RDShaderSPIRV.ts';
+
+/**
+ * Compiled shader file in SPIR-V form.
+ * See also {@link RDShaderSource}. {@link RDShaderFile} is only meant to be used with the {@link RenderingDevice} API. It should not be confused with Godot's own {@link Shader} resource, which is what Godot's various nodes use for high-level shader programming.
+ */
+export class RDShaderFile extends Resource {
+    constructor(name = 628) { super(name); }
+
+    /**
+     * Sets the SPIR-V `bytecode` that will be compiled for the specified `version`.
+     */
+    setBytecode(bytecode: RDShaderSPIRV, version?: StringName /* = &"" */): void { _C(this, 10772, bytecode, version); }
+
+    /**
+     * Returns the SPIR-V intermediate representation for the specified shader `version`.
+     */
+    getSpirv(version?: StringName /* = &"" */): RDShaderSPIRV { return _C(this, 6498, version) as RDShaderSPIRV; }
+
+    /**
+     * Returns the list of compiled versions for this shader.
+     */
+    getVersionList(): GodotArray<StringName> { return _C(this, 7044) as GodotArray<StringName>; }
+
+    /**
+     * The base compilation error message, which indicates errors not related to a specific shader stage if non-empty. If empty, shader compilation is not necessarily successful (check {@link RDShaderSPIRV}'s error message members).
+     */
+    get baseError(): string { return _C(this, 3895) as string; }
+    set baseError(v: string) { _C(this, 10641, v); }
+
+    static readonly name = _R(628, RDShaderFile);
+}

package/gen/classes/RDShaderSPIRV.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 { Resource } from './Resource.ts';
+import type { PackedByteArray } from '../heap-types/index.ts';
+
+/**
+ * {@link RDShaderSPIRV} represents an {@link RDShaderFile}'s [SPIR-V](https://www.khronos.org/spir/) code for various shader stages, as well as possible compilation error messages. SPIR-V is a low-level intermediate shader representation. This intermediate representation is not used directly by GPUs for rendering, but it can be compiled into binary shaders that GPUs can understand. Unlike compiled shaders, SPIR-V is portable across GPU models and driver versions.
+ * This object is used by {@link RenderingDevice}.
+ */
+export class RDShaderSPIRV extends Resource {
+    constructor(name = 629) { super(name); }
+
+    /**
+     * The SPIR-V bytecode for the vertex shader stage.
+     */
+    get bytecodeVertex(): PackedByteArray { return _C(this, 6530, 0) as PackedByteArray; }
+    set bytecodeVertex(v: PackedByteArray) { _C(this, 12876, 0, v); }
+
+    /**
+     * The SPIR-V bytecode for the fragment shader stage.
+     */
+    get bytecodeFragment(): PackedByteArray { return _C(this, 6530, 1) as PackedByteArray; }
+    set bytecodeFragment(v: PackedByteArray) { _C(this, 12876, 1, v); }
+
+    /**
+     * The SPIR-V bytecode for the tessellation control shader stage.
+     */
+    get bytecodeTesselationControl(): PackedByteArray { return _C(this, 6530, 2) as PackedByteArray; }
+    set bytecodeTesselationControl(v: PackedByteArray) { _C(this, 12876, 2, v); }
+
+    /**
+     * The SPIR-V bytecode for the tessellation evaluation shader stage.
+     */
+    get bytecodeTesselationEvaluation(): PackedByteArray { return _C(this, 6530, 3) as PackedByteArray; }
+    set bytecodeTesselationEvaluation(v: PackedByteArray) { _C(this, 12876, 3, v); }
+
+    /**
+     * The SPIR-V bytecode for the compute shader stage.
+     */
+    get bytecodeCompute(): PackedByteArray { return _C(this, 6530, 4) as PackedByteArray; }
+    set bytecodeCompute(v: PackedByteArray) { _C(this, 12876, 4, v); }
+
+    /**
+     * The SPIR-V bytecode for the ray generation shader stage.
+     */
+    get bytecodeRaygen(): PackedByteArray { return _C(this, 6530, 5) as PackedByteArray; }
+    set bytecodeRaygen(v: PackedByteArray) { _C(this, 12876, 5, v); }
+
+    /**
+     * The SPIR-V bytecode for the any hit shader stage.
+     */
+    get bytecodeAnyHit(): PackedByteArray { return _C(this, 6530, 6) as PackedByteArray; }
+    set bytecodeAnyHit(v: PackedByteArray) { _C(this, 12876, 6, v); }
+
+    /**
+     * The SPIR-V bytecode for the closest hit shader stage.
+     */
+    get bytecodeClosestHit(): PackedByteArray { return _C(this, 6530, 7) as PackedByteArray; }
+    set bytecodeClosestHit(v: PackedByteArray) { _C(this, 12876, 7, v); }
+
+    /**
+     * The SPIR-V bytecode for the miss shader stage.
+     */
+    get bytecodeMiss(): PackedByteArray { return _C(this, 6530, 8) as PackedByteArray; }
+    set bytecodeMiss(v: PackedByteArray) { _C(this, 12876, 8, v); }
+
+    /**
+     * The SPIR-V bytecode for the intersection shader stage.
+     */
+    get bytecodeIntersection(): PackedByteArray { return _C(this, 6530, 9) as PackedByteArray; }
+    set bytecodeIntersection(v: PackedByteArray) { _C(this, 12876, 9, v); }
+
+    /**
+     * The compilation error message for the vertex shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+     */
+    get compileErrorVertex(): string { return _C(this, 6531, 0) as string; }
+    set compileErrorVertex(v: string) { _C(this, 12877, 0, v); }
+
+    /**
+     * The compilation error message for the fragment shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+     */
+    get compileErrorFragment(): string { return _C(this, 6531, 1) as string; }
+    set compileErrorFragment(v: string) { _C(this, 12877, 1, v); }
+
+    /**
+     * The compilation error message for the tessellation control shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+     */
+    get compileErrorTesselationControl(): string { return _C(this, 6531, 2) as string; }
+    set compileErrorTesselationControl(v: string) { _C(this, 12877, 2, v); }
+
+    /**
+     * The compilation error message for the tessellation evaluation shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+     */
+    get compileErrorTesselationEvaluation(): string { return _C(this, 6531, 3) as string; }
+    set compileErrorTesselationEvaluation(v: string) { _C(this, 12877, 3, v); }
+
+    /**
+     * The compilation error message for the compute shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+     */
+    get compileErrorCompute(): string { return _C(this, 6531, 4) as string; }
+    set compileErrorCompute(v: string) { _C(this, 12877, 4, v); }
+
+    /**
+     * The compilation error message for the ray generation shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+     */
+    get compileErrorRaygen(): string { return _C(this, 6531, 5) as string; }
+    set compileErrorRaygen(v: string) { _C(this, 12877, 5, v); }
+
+    /**
+     * The compilation error message for the any hit shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+     */
+    get compileErrorAnyHit(): string { return _C(this, 6531, 6) as string; }
+    set compileErrorAnyHit(v: string) { _C(this, 12877, 6, v); }
+
+    /**
+     * The compilation error message for the closest hit shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+     */
+    get compileErrorClosestHit(): string { return _C(this, 6531, 7) as string; }
+    set compileErrorClosestHit(v: string) { _C(this, 12877, 7, v); }
+
+    /**
+     * The compilation error message for the miss shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+     */
+    get compileErrorMiss(): string { return _C(this, 6531, 8) as string; }
+    set compileErrorMiss(v: string) { _C(this, 12877, 8, v); }
+
+    /**
+     * The compilation error message for the intersection shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+     */
+    get compileErrorIntersection(): string { return _C(this, 6531, 9) as string; }
+    set compileErrorIntersection(v: string) { _C(this, 12877, 9, v); }
+
+    static readonly name = _R(629, RDShaderSPIRV);
+}

package/gen/classes/RDShaderSource.ts

@@ -0,0 +1,82 @@
+// 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 { ShaderLanguage } from './RenderingDevice.ts';
+
+/**
+ * Shader source code in text form.
+ * See also {@link RDShaderFile}. {@link RDShaderSource} is only meant to be used with the {@link RenderingDevice} API. It should not be confused with Godot's own {@link Shader} resource, which is what Godot's various nodes use for high-level shader programming.
+ */
+export class RDShaderSource extends RefCounted {
+    constructor(name = 630) { super(name); }
+
+    /**
+     * Source code for the shader's vertex stage.
+     */
+    get sourceVertex(): string { return _C(this, 6532, 0) as string; }
+    set sourceVertex(v: string) { _C(this, 12878, 0, v); }
+
+    /**
+     * Source code for the shader's fragment stage.
+     */
+    get sourceFragment(): string { return _C(this, 6532, 1) as string; }
+    set sourceFragment(v: string) { _C(this, 12878, 1, v); }
+
+    /**
+     * Source code for the shader's tessellation control stage.
+     */
+    get sourceTesselationControl(): string { return _C(this, 6532, 2) as string; }
+    set sourceTesselationControl(v: string) { _C(this, 12878, 2, v); }
+
+    /**
+     * Source code for the shader's tessellation evaluation stage.
+     */
+    get sourceTesselationEvaluation(): string { return _C(this, 6532, 3) as string; }
+    set sourceTesselationEvaluation(v: string) { _C(this, 12878, 3, v); }
+
+    /**
+     * Source code for the shader's compute stage.
+     */
+    get sourceCompute(): string { return _C(this, 6532, 4) as string; }
+    set sourceCompute(v: string) { _C(this, 12878, 4, v); }
+
+    /**
+     * Source code for the shader's ray generation stage.
+     */
+    get sourceRaygen(): string { return _C(this, 6532, 5) as string; }
+    set sourceRaygen(v: string) { _C(this, 12878, 5, v); }
+
+    /**
+     * Source code for the shader's any hit stage.
+     */
+    get sourceAnyHit(): string { return _C(this, 6532, 6) as string; }
+    set sourceAnyHit(v: string) { _C(this, 12878, 6, v); }
+
+    /**
+     * Source code for the shader's closest hit stage.
+     */
+    get sourceClosestHit(): string { return _C(this, 6532, 7) as string; }
+    set sourceClosestHit(v: string) { _C(this, 12878, 7, v); }
+
+    /**
+     * Source code for the shader's miss stage.
+     */
+    get sourceMiss(): string { return _C(this, 6532, 8) as string; }
+    set sourceMiss(v: string) { _C(this, 12878, 8, v); }
+
+    /**
+     * Source code for the shader's intersection stage.
+     */
+    get sourceIntersection(): string { return _C(this, 6532, 9) as string; }
+    set sourceIntersection(v: string) { _C(this, 12878, 9, v); }
+
+    /**
+     * The language the shader is written in.
+     */
+    get language(): ShaderLanguage { return _C(this, 5299) as ShaderLanguage; }
+    set language(v: ShaderLanguage) { _C(this, 11871, v); }
+
+    static readonly name = _R(630, RDShaderSource);
+}

package/gen/classes/RDTextureFormat.ts

@@ -0,0 +1,93 @@
+// 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 { DataFormat, TextureSamples, TextureUsageBits } from './RenderingDevice.ts';
+import type { TextureType } from './VisualShaderNodeTextureParameter.ts';
+
+/**
+ * This object is used by {@link RenderingDevice}.
+ */
+export class RDTextureFormat extends RefCounted {
+    constructor(name = 631) { super(name); }
+
+    /**
+     * Adds `format` as a valid format for the corresponding {@link RDTextureView}'s {@link RDTextureView.formatOverride} property. If any format is added as shareable, then the main {@link format} must also be added.
+     */
+    addShareableFormat(format: DataFormat): void { _C(this, 1287, format); }
+
+    /**
+     * Removes `format` from the list of valid formats that the corresponding {@link RDTextureView}'s {@link RDTextureView.formatOverride} property can be set to.
+     */
+    removeShareableFormat(format: DataFormat): void { _C(this, 9957, format); }
+
+    /**
+     * The texture's pixel data format.
+     */
+    get format(): DataFormat { return _C(this, 4861) as DataFormat; }
+    set format(v: DataFormat) { _C(this, 11465, v); }
+
+    /**
+     * The texture's width (in pixels).
+     */
+    get width(): number { return _C(this, 7148) as number; }
+    set width(v: number) { _C(this, 13372, v); }
+
+    /**
+     * The texture's height (in pixels).
+     */
+    get height(): number { return _C(this, 5024) as number; }
+    set height(v: number) { _C(this, 11609, v); }
+
+    /**
+     * The texture's depth (in pixels). This is always `1` for 2D textures.
+     */
+    get depth(): number { return _C(this, 4468) as number; }
+    set depth(v: number) { _C(this, 11083, v); }
+
+    /**
+     * The number of layers in the texture. Only relevant for 2D texture arrays.
+     */
+    get arrayLayers(): number { return _C(this, 3794) as number; }
+    set arrayLayers(v: number) { _C(this, 10531, v); }
+
+    /**
+     * The number of mipmaps available in the texture.
+     */
+    get mipmaps(): number { return _C(this, 5561) as number; }
+    set mipmaps(v: number) { _C(this, 12066, v); }
+
+    /**
+     * The texture type.
+     */
+    get textureType(): TextureType { return _C(this, 6757) as TextureType; }
+    set textureType(v: TextureType) { _C(this, 13049, v); }
+
+    /**
+     * The number of samples used when sampling the texture.
+     */
+    get samples(): TextureSamples { return _C(this, 6232) as TextureSamples; }
+    set samples(v: TextureSamples) { _C(this, 12605, v); }
+
+    /**
+     * The texture's usage bits, which determine what can be done using the texture.
+     */
+    get usageBits(): TextureUsageBits { return _C(this, 6968) as TextureUsageBits; }
+    set usageBits(v: TextureUsageBits) { _C(this, 13189, v); }
+
+    /**
+     * The texture will be used as the destination of a resolve operation.
+     */
+    get isResolveBuffer(): boolean { return _C(this, 5172) as boolean; }
+    set isResolveBuffer(v: boolean) { _C(this, 11754, v); }
+
+    /**
+     * If a texture is discardable, its contents do not need to be preserved between frames. This flag is only relevant when the texture is used as target in a draw list.
+     * This information is used by {@link RenderingDevice} to figure out if a texture's contents can be discarded, eliminating unnecessary writes to memory and boosting performance.
+     */
+    get isDiscardable(): boolean { return _C(this, 5170) as boolean; }
+    set isDiscardable(v: boolean) { _C(this, 11752, v); }
+
+    static readonly name = _R(631, RDTextureFormat);
+}

package/gen/classes/RDTextureView.ts

@@ -0,0 +1,45 @@
+// 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 { DataFormat, TextureSwizzle } from './RenderingDevice.ts';
+
+/**
+ * This object is used by {@link RenderingDevice}.
+ */
+export class RDTextureView extends RefCounted {
+    constructor(name = 632) { super(name); }
+
+    /**
+     * Optional override for the data format to return sampled values in. The corresponding {@link RDTextureFormat} must have had this added as a shareable format. The default value of {@link RenderingDevice.DATA_FORMAT_MAX} does not override the format.
+     */
+    get formatOverride(): DataFormat { return _C(this, 4862) as DataFormat; }
+    set formatOverride(v: DataFormat) { _C(this, 11466, v); }
+
+    /**
+     * The channel to sample when sampling the red color channel.
+     */
+    get swizzleR(): TextureSwizzle { return _C(this, 6649) as TextureSwizzle; }
+    set swizzleR(v: TextureSwizzle) { _C(this, 12953, v); }
+
+    /**
+     * The channel to sample when sampling the green color channel.
+     */
+    get swizzleG(): TextureSwizzle { return _C(this, 6648) as TextureSwizzle; }
+    set swizzleG(v: TextureSwizzle) { _C(this, 12952, v); }
+
+    /**
+     * The channel to sample when sampling the blue color channel.
+     */
+    get swizzleB(): TextureSwizzle { return _C(this, 6647) as TextureSwizzle; }
+    set swizzleB(v: TextureSwizzle) { _C(this, 12951, v); }
+
+    /**
+     * The channel to sample when sampling the alpha channel.
+     */
+    get swizzleA(): TextureSwizzle { return _C(this, 6646) as TextureSwizzle; }
+    set swizzleA(v: TextureSwizzle) { _C(this, 12950, v); }
+
+    static readonly name = _R(632, RDTextureView);
+}