@ringozz/godot 0.1.0

package/gen/classes/RDAccelerationStructureGeometry.ts

@@ -0,0 +1,71 @@
+// 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 { RID } from '../heap-types/index.ts';
+import type { AccelerationStructureGeometryFlagBits, DataFormat } from './RenderingDevice.ts';
+
+/**
+ * {@link RDAccelerationStructureGeometry} describes a set of triangles used as raytracing geometry in the {@link RenderingDevice.blasCreate} method.
+ * The geometry is always in triangle list form, either indexed or non-indexed. Triangle strips are not supported.
+ */
+export class RDAccelerationStructureGeometry extends RefCounted {
+    constructor(name = 615) { super(name); }
+
+    /**
+     * Flags for the geometry.
+     */
+    get flags(): AccelerationStructureGeometryFlagBits { return _C(this, 4807) as AccelerationStructureGeometryFlagBits; }
+    set flags(v: AccelerationStructureGeometryFlagBits) { _C(this, 11412, v); }
+
+    /**
+     * Buffer containing vertices.
+     */
+    get vertexBuffer(): RID { return _C(this, 7048) as RID; }
+    set vertexBuffer(v: RID) { _C(this, 13289, v); }
+
+    /**
+     * Byte offset of the first vertex in {@link vertexBuffer}.
+     */
+    get vertexOffset(): number { return _C(this, 7057) as number; }
+    set vertexOffset(v: number) { _C(this, 13296, v); }
+
+    /**
+     * Number of bytes between each vertex in {@link vertexBuffer}.
+     */
+    get vertexStride(): number { return _C(this, 7058) as number; }
+    set vertexStride(v: number) { _C(this, 13297, v); }
+
+    /**
+     * Number of vertices used by this geometry in {@link vertexBuffer}.
+     */
+    get vertexCount(): number { return _C(this, 7051) as number; }
+    set vertexCount(v: number) { _C(this, 13292, v); }
+
+    /**
+     * Format of the vertices in {@link vertexBuffer}.
+     */
+    get vertexFormat(): DataFormat { return _C(this, 7054) as DataFormat; }
+    set vertexFormat(v: DataFormat) { _C(this, 13293, v); }
+
+    /**
+     * Buffer containing vertex indices. If `null`, triangles are non-indexed.
+     */
+    get indexBuffer(): RID { return _C(this, 5086) as RID; }
+    set indexBuffer(v: RID) { _C(this, 11688, v); }
+
+    /**
+     * Byte offset of the first index in {@link indexBuffer}.
+     */
+    get indexOffset(): number { return _C(this, 5089) as number; }
+    set indexOffset(v: number) { _C(this, 11690, v); }
+
+    /**
+     * Number of indices used by this geometry in {@link indexBuffer}.
+     */
+    get indexCount(): number { return _C(this, 5087) as number; }
+    set indexCount(v: number) { _C(this, 11689, v); }
+
+    static readonly name = _R(615, RDAccelerationStructureGeometry);
+}

package/gen/classes/RDAccelerationStructureInstance.ts

@@ -0,0 +1,53 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { Transform3D } from '../value-types/index.ts';
+import type { AccelerationStructureInstanceFlagBits } from './RenderingDevice.ts';
+
+/**
+ * {@link RDAccelerationStructureInstance} describes an instance of a Bottom-Level Acceleration Structure (BLAS) used in the {@link RenderingDevice.tlasBuild} method.
+ */
+export class RDAccelerationStructureInstance extends RefCounted {
+    constructor(name = 616) { super(name); }
+
+    /**
+     * Transform applied to the referenced BLAS for this instance.
+     */
+    get transform(): Transform3D { return _C(this, 6874) as Transform3D; }
+    set transform(v: Transform3D) { _C(this, 13134, v); }
+
+    /**
+     * Custom instance ID that can be accessed in GLSL using `gl_InstanceCustomIndexEXT`.
+     */
+    get id(): number { return _C(this, 5062) as number; }
+    set id(v: number) { _C(this, 11654, v); }
+
+    /**
+     * Visibility mask used to control which rays can intersect this instance.
+     */
+    get mask(): number { return _C(this, 5450) as number; }
+    set mask(v: number) { _C(this, 11976, v); }
+
+    /**
+     * Hit shader binding table range used for this instance, allocated using the {@link RenderingDevice.hitSbtRangeAlloc} method.
+     */
+    get hitSbtRange(): number { return _C(this, 5042) as number; }
+    set hitSbtRange(v: number) { _C(this, 11637, v); }
+
+    /**
+     * Flags for the instance.
+     */
+    get flags(): AccelerationStructureInstanceFlagBits { return _C(this, 4807) as AccelerationStructureInstanceFlagBits; }
+    set flags(v: AccelerationStructureInstanceFlagBits) { _C(this, 11412, v); }
+
+    /**
+     * The BLAS referenced by this instance. If `null`, the instance is treated as a placeholder but still contributes to `gl_InstanceIndex` in GLSL.
+     */
+    get blas(): RID { return _C(this, 3929) as RID; }
+    set blas(v: RID) { _C(this, 10674, v); }
+
+    static readonly name = _R(616, RDAccelerationStructureInstance);
+}

package/gen/classes/RDAttachmentFormat.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 { RefCounted } from './RefCounted.ts';
+import type { DataFormat, TextureSamples } from './RenderingDevice.ts';
+
+/**
+ * This object is used by {@link RenderingDevice}.
+ */
+export class RDAttachmentFormat extends RefCounted {
+    constructor(name = 617) { super(name); }
+
+    /**
+     * The attachment's data format.
+     */
+    get format(): DataFormat { return _C(this, 4861) as DataFormat; }
+    set format(v: DataFormat) { _C(this, 11465, v); }
+
+    /**
+     * The number of samples used when sampling the attachment.
+     */
+    get samples(): TextureSamples { return _C(this, 6232) as TextureSamples; }
+    set samples(v: TextureSamples) { _C(this, 12605, v); }
+
+    /**
+     * The attachment's usage flags, which determine what can be done with it.
+     */
+    get usageFlags(): number { return _C(this, 6969) as number; }
+    set usageFlags(v: number) { _C(this, 13190, v); }
+
+    static readonly name = _R(617, RDAttachmentFormat);
+}

package/gen/classes/RDFramebufferPass.ts

@@ -0,0 +1,52 @@
+// 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 { PackedInt32Array } from '../heap-types/index.ts';
+
+/**
+ * This class contains the list of attachment descriptions for a framebuffer pass. Each points with an index to a previously supplied list of texture attachments.
+ * Multipass framebuffers can optimize some configurations in mobile. On desktop, they provide little to no advantage.
+ * This object is used by {@link RenderingDevice}.
+ */
+export class RDFramebufferPass extends RefCounted {
+    constructor(name = 618) { super(name); }
+
+    /**
+     * Color attachments in order starting from 0. If this attachment is not used by the shader, pass ATTACHMENT_UNUSED to skip.
+     */
+    get colorAttachments(): PackedInt32Array { return _C(this, 4220) as PackedInt32Array; }
+    set colorAttachments(v: PackedInt32Array) { _C(this, 10906, v); }
+
+    /**
+     * Used for multipass framebuffers (more than one render pass). Converts an attachment to an input. Make sure to also supply it properly in the {@link RDUniform} for the uniform set.
+     */
+    get inputAttachments(): PackedInt32Array { return _C(this, 5107) as PackedInt32Array; }
+    set inputAttachments(v: PackedInt32Array) { _C(this, 11710, v); }
+
+    /**
+     * If the color attachments are multisampled, non-multisampled resolve attachments can be provided.
+     */
+    get resolveAttachments(): PackedInt32Array { return _C(this, 6155) as PackedInt32Array; }
+    set resolveAttachments(v: PackedInt32Array) { _C(this, 12541, v); }
+
+    /**
+     * Attachments to preserve in this pass (otherwise they are erased).
+     */
+    get preserveAttachments(): PackedInt32Array { return _C(this, 5991) as PackedInt32Array; }
+    set preserveAttachments(v: PackedInt32Array) { _C(this, 12400, v); }
+
+    /**
+     * Depth attachment. ATTACHMENT_UNUSED should be used if no depth buffer is required for this pass.
+     */
+    get depthAttachment(): number { return _C(this, 4469) as number; }
+    set depthAttachment(v: number) { _C(this, 11084, v); }
+
+    /**
+     * Attachment is unused.
+     */
+    static readonly ATTACHMENT_UNUSED = -1;
+
+    static readonly name = _R(618, RDFramebufferPass);
+}

package/gen/classes/RDHitGroup.ts

@@ -0,0 +1,35 @@
+// 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 { RDPipelineShader } from './RDPipelineShader.ts';
+
+/**
+ * Defines a hit group for use with {@link RenderingDevice.raytracingPipelineCreate}.
+ * A hit group combines shaders that are executed when a ray intersects geometry. It may include a closest-hit shader, any-hit shader, and intersection shader.
+ * Hit groups are referenced by index when populating hit shader binding tables using {@link RenderingDevice.hitSbtRangeUpdate}.
+ */
+export class RDHitGroup extends RefCounted {
+    constructor(name = 619) { super(name); }
+
+    /**
+     * Closest-hit shader for this hit group. Executed for the closest intersection. Can be `null`.
+     */
+    get closestHitShader(): RDPipelineShader { return _C(this, 4172) as RDPipelineShader; }
+    set closestHitShader(v: RDPipelineShader) { _C(this, 10873, v); }
+
+    /**
+     * Any-hit shader for this hit group. Executed for each potential intersection. Can be `null`.
+     */
+    get anyHitShader(): RDPipelineShader { return _C(this, 3777) as RDPipelineShader; }
+    set anyHitShader(v: RDPipelineShader) { _C(this, 10515, v); }
+
+    /**
+     * Intersection shader for this hit group. Required for non-triangle geometry. Must be `null` when using for triangle geometry.
+     */
+    get intersectionShader(): RDPipelineShader { return _C(this, 5158) as RDPipelineShader; }
+    set intersectionShader(v: RDPipelineShader) { _C(this, 11745, v); }
+
+    static readonly name = _R(619, RDHitGroup);
+}

package/gen/classes/RDPipelineColorBlendState.ts

@@ -0,0 +1,42 @@
+// 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 } from '../heap-types/index.ts';
+import type { Color } from '../value-types/index.ts';
+import type { RDPipelineColorBlendStateAttachment } from './RDPipelineColorBlendStateAttachment.ts';
+import type { LogicOperation } from './RenderingDevice.ts';
+
+/**
+ * This object is used by {@link RenderingDevice}.
+ */
+export class RDPipelineColorBlendState extends RefCounted {
+    constructor(name = 620) { super(name); }
+
+    /**
+     * If `true`, performs the logic operation defined in {@link logicOp}.
+     */
+    get enableLogicOp(): boolean { return _C(this, 4651) as boolean; }
+    set enableLogicOp(v: boolean) { _C(this, 11278, v); }
+
+    /**
+     * The logic operation to perform for blending. Only effective if {@link enableLogicOp} is `true`.
+     */
+    get logicOp(): LogicOperation { return _C(this, 5412) as LogicOperation; }
+    set logicOp(v: LogicOperation) { _C(this, 11948, v); }
+
+    /**
+     * The constant color to blend with. See also {@link RenderingDevice.drawListSetBlendConstants}.
+     */
+    get blendConstant(): Color { return _C(this, 3930) as Color; }
+    set blendConstant(v: Color) { _C(this, 10675, v); }
+
+    /**
+     * The attachments that are blended together.
+     */
+    get attachments(): GodotArray<RDPipelineColorBlendStateAttachment> { return _C(this, 3807) as GodotArray<RDPipelineColorBlendStateAttachment>; }
+    set attachments(v: GodotArray<RDPipelineColorBlendStateAttachment>) { _C(this, 10548, v); }
+
+    static readonly name = _R(620, RDPipelineColorBlendState);
+}

package/gen/classes/RDPipelineColorBlendStateAttachment.ts

@@ -0,0 +1,161 @@
+// 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 { BlendFactor, BlendOperation } from './RenderingDevice.ts';
+
+/**
+ * Controls how blending between source and destination fragments is performed when using {@link RenderingDevice}.
+ * For reference, this is how common user-facing blend modes are implemented in Godot's 2D renderer:
+ * **Mix:**
+ *
+ * ```text
+ *
+ * var attachment = RDPipelineColorBlendStateAttachment.new()
+ * attachment.enable_blend = true
+ * attachment.color_blend_op = RenderingDevice.BLEND_OP_ADD
+ * attachment.src_color_blend_factor = RenderingDevice.BLEND_FACTOR_SRC_ALPHA
+ * attachment.dst_color_blend_factor = RenderingDevice.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA
+ * attachment.alpha_blend_op = RenderingDevice.BLEND_OP_ADD
+ * attachment.src_alpha_blend_factor = RenderingDevice.BLEND_FACTOR_ONE
+ * attachment.dst_alpha_blend_factor = RenderingDevice.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA
+ *
+ * ```
+ *
+ * **Add:**
+ *
+ * ```text
+ *
+ * var attachment = RDPipelineColorBlendStateAttachment.new()
+ * attachment.enable_blend = true
+ * attachment.alpha_blend_op = RenderingDevice.BLEND_OP_ADD
+ * attachment.color_blend_op = RenderingDevice.BLEND_OP_ADD
+ * attachment.src_color_blend_factor = RenderingDevice.BLEND_FACTOR_SRC_ALPHA
+ * attachment.dst_color_blend_factor = RenderingDevice.BLEND_FACTOR_ONE
+ * attachment.src_alpha_blend_factor = RenderingDevice.BLEND_FACTOR_SRC_ALPHA
+ * attachment.dst_alpha_blend_factor = RenderingDevice.BLEND_FACTOR_ONE
+ *
+ * ```
+ *
+ * **Subtract:**
+ *
+ * ```text
+ *
+ * var attachment = RDPipelineColorBlendStateAttachment.new()
+ * attachment.enable_blend = true
+ * attachment.alpha_blend_op = RenderingDevice.BLEND_OP_REVERSE_SUBTRACT
+ * attachment.color_blend_op = RenderingDevice.BLEND_OP_REVERSE_SUBTRACT
+ * attachment.src_color_blend_factor = RenderingDevice.BLEND_FACTOR_SRC_ALPHA
+ * attachment.dst_color_blend_factor = RenderingDevice.BLEND_FACTOR_ONE
+ * attachment.src_alpha_blend_factor = RenderingDevice.BLEND_FACTOR_SRC_ALPHA
+ * attachment.dst_alpha_blend_factor = RenderingDevice.BLEND_FACTOR_ONE
+ *
+ * ```
+ *
+ * **Multiply:**
+ *
+ * ```text
+ *
+ * var attachment = RDPipelineColorBlendStateAttachment.new()
+ * attachment.enable_blend = true
+ * attachment.alpha_blend_op = RenderingDevice.BLEND_OP_ADD
+ * attachment.color_blend_op = RenderingDevice.BLEND_OP_ADD
+ * attachment.src_color_blend_factor = RenderingDevice.BLEND_FACTOR_DST_COLOR
+ * attachment.dst_color_blend_factor = RenderingDevice.BLEND_FACTOR_ZERO
+ * attachment.src_alpha_blend_factor = RenderingDevice.BLEND_FACTOR_DST_ALPHA
+ * attachment.dst_alpha_blend_factor = RenderingDevice.BLEND_FACTOR_ZERO
+ *
+ * ```
+ *
+ * **Pre-multiplied alpha:**
+ *
+ * ```text
+ *
+ * var attachment = RDPipelineColorBlendStateAttachment.new()
+ * attachment.enable_blend = true
+ * attachment.alpha_blend_op = RenderingDevice.BLEND_OP_ADD
+ * attachment.color_blend_op = RenderingDevice.BLEND_OP_ADD
+ * attachment.src_color_blend_factor = RenderingDevice.BLEND_FACTOR_ONE
+ * attachment.dst_color_blend_factor = RenderingDevice.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA
+ * attachment.src_alpha_blend_factor = RenderingDevice.BLEND_FACTOR_ONE
+ * attachment.dst_alpha_blend_factor = RenderingDevice.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA
+ *
+ * ```
+ */
+export class RDPipelineColorBlendStateAttachment extends RefCounted {
+    constructor(name = 621) { super(name); }
+
+    /**
+     * Convenience method to perform standard mix blending with straight (non-premultiplied) alpha. This sets {@link enableBlend} to `true`, {@link srcColorBlendFactor} to {@link RenderingDevice.BLEND_FACTOR_SRC_ALPHA}, {@link dstColorBlendFactor} to {@link RenderingDevice.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA}, {@link srcAlphaBlendFactor} to {@link RenderingDevice.BLEND_FACTOR_SRC_ALPHA} and {@link dstAlphaBlendFactor} to {@link RenderingDevice.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA}.
+     */
+    setAsMix(): void { _C(this, 10539); }
+
+    /**
+     * If `true`, performs blending between the source and destination according to the factors defined in {@link srcColorBlendFactor}, {@link dstColorBlendFactor}, {@link srcAlphaBlendFactor} and {@link dstAlphaBlendFactor}. The blend modes {@link colorBlendOp} and {@link alphaBlendOp} are also taken into account, with {@link writeR}, {@link writeG}, {@link writeB} and {@link writeA} controlling the output.
+     */
+    get enableBlend(): boolean { return _C(this, 4641) as boolean; }
+    set enableBlend(v: boolean) { _C(this, 11265, v); }
+
+    /**
+     * Controls how the blend factor for the color channels is determined based on the source's fragments.
+     */
+    get srcColorBlendFactor(): BlendFactor { return _C(this, 6505) as BlendFactor; }
+    set srcColorBlendFactor(v: BlendFactor) { _C(this, 12848, v); }
+
+    /**
+     * Controls how the blend factor for the color channels is determined based on the destination's fragments.
+     */
+    get dstColorBlendFactor(): BlendFactor { return _C(this, 4589) as BlendFactor; }
+    set dstColorBlendFactor(v: BlendFactor) { _C(this, 11203, v); }
+
+    /**
+     * The blend mode to use for the red/green/blue color channels.
+     */
+    get colorBlendOp(): BlendOperation { return _C(this, 4221) as BlendOperation; }
+    set colorBlendOp(v: BlendOperation) { _C(this, 10907, v); }
+
+    /**
+     * Controls how the blend factor for the alpha channel is determined based on the source's fragments.
+     */
+    get srcAlphaBlendFactor(): BlendFactor { return _C(this, 6504) as BlendFactor; }
+    set srcAlphaBlendFactor(v: BlendFactor) { _C(this, 12847, v); }
+
+    /**
+     * Controls how the blend factor for the alpha channel is determined based on the destination's fragments.
+     */
+    get dstAlphaBlendFactor(): BlendFactor { return _C(this, 4588) as BlendFactor; }
+    set dstAlphaBlendFactor(v: BlendFactor) { _C(this, 11202, v); }
+
+    /**
+     * The blend mode to use for the alpha channel.
+     */
+    get alphaBlendOp(): BlendOperation { return _C(this, 3725) as BlendOperation; }
+    set alphaBlendOp(v: BlendOperation) { _C(this, 10466, v); }
+
+    /**
+     * If `true`, writes the new red color channel to the final result.
+     */
+    get writeR(): boolean { return _C(this, 7171) as boolean; }
+    set writeR(v: boolean) { _C(this, 13392, v); }
+
+    /**
+     * If `true`, writes the new green color channel to the final result.
+     */
+    get writeG(): boolean { return _C(this, 7168) as boolean; }
+    set writeG(v: boolean) { _C(this, 13390, v); }
+
+    /**
+     * If `true`, writes the new blue color channel to the final result.
+     */
+    get writeB(): boolean { return _C(this, 7167) as boolean; }
+    set writeB(v: boolean) { _C(this, 13389, v); }
+
+    /**
+     * If `true`, writes the new alpha channel to the final result.
+     */
+    get writeA(): boolean { return _C(this, 7166) as boolean; }
+    set writeA(v: boolean) { _C(this, 13388, v); }
+
+    static readonly name = _R(621, RDPipelineColorBlendStateAttachment);
+}

package/gen/classes/RDPipelineDepthStencilState.ts

@@ -0,0 +1,141 @@
+// 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, StencilOperation } from './RenderingDevice.ts';
+
+/**
+ * {@link RDPipelineDepthStencilState} controls the way depth and stencil comparisons are performed when sampling those values using {@link RenderingDevice}.
+ */
+export class RDPipelineDepthStencilState extends RefCounted {
+    constructor(name = 622) { super(name); }
+
+    /**
+     * If `true`, enables depth testing which allows objects to be automatically occluded by other objects based on their depth. This also allows objects to be partially occluded by other objects. If `false`, objects will appear in the order they were drawn (like in Godot's 2D renderer).
+     */
+    get enableDepthTest(): boolean { return _C(this, 4647) as boolean; }
+    set enableDepthTest(v: boolean) { _C(this, 11272, v); }
+
+    /**
+     * If `true`, writes to the depth buffer whenever the depth test returns `true`. Only works when enable_depth_test is also `true`.
+     */
+    get enableDepthWrite(): boolean { return _C(this, 4648) as boolean; }
+    set enableDepthWrite(v: boolean) { _C(this, 11273, v); }
+
+    /**
+     * The method used for comparing the previous and current depth values.
+     */
+    get depthCompareOperator(): CompareOperator { return _C(this, 4474) as CompareOperator; }
+    set depthCompareOperator(v: CompareOperator) { _C(this, 11089, v); }
+
+    /**
+     * If `true`, each depth value will be tested to see if it is between {@link depthRangeMin} and {@link depthRangeMax}. If it is outside of these values, it is discarded.
+     */
+    get enableDepthRange(): boolean { return _C(this, 4646) as boolean; }
+    set enableDepthRange(v: boolean) { _C(this, 11271, v); }
+
+    /**
+     * The minimum depth that returns `true` for {@link enableDepthRange}.
+     */
+    get depthRangeMin(): number { return _C(this, 4480) as number; }
+    set depthRangeMin(v: number) { _C(this, 11094, v); }
+
+    /**
+     * The maximum depth that returns `true` for {@link enableDepthRange}.
+     */
+    get depthRangeMax(): number { return _C(this, 4479) as number; }
+    set depthRangeMax(v: number) { _C(this, 11093, v); }
+
+    /**
+     * If `true`, enables stencil testing. There are separate stencil buffers for front-facing triangles and back-facing triangles. See properties that begin with "front_op" and properties with "back_op" for each.
+     */
+    get enableStencil(): boolean { return _C(this, 4655) as boolean; }
+    set enableStencil(v: boolean) { _C(this, 11284, v); }
+
+    /**
+     * The operation to perform on the stencil buffer for front pixels that fail the stencil test.
+     */
+    get frontOpFail(): StencilOperation { return _C(this, 4904) as StencilOperation; }
+    set frontOpFail(v: StencilOperation) { _C(this, 11497, v); }
+
+    /**
+     * The operation to perform on the stencil buffer for front pixels that pass the stencil test.
+     */
+    get frontOpPass(): StencilOperation { return _C(this, 4905) as StencilOperation; }
+    set frontOpPass(v: StencilOperation) { _C(this, 11498, v); }
+
+    /**
+     * The operation to perform on the stencil buffer for front pixels that pass the stencil test but fail the depth test.
+     */
+    get frontOpDepthFail(): StencilOperation { return _C(this, 4903) as StencilOperation; }
+    set frontOpDepthFail(v: StencilOperation) { _C(this, 11496, v); }
+
+    /**
+     * The method used for comparing the previous front stencil value and {@link frontOpReference}.
+     */
+    get frontOpCompare(): CompareOperator { return _C(this, 4901) as CompareOperator; }
+    set frontOpCompare(v: CompareOperator) { _C(this, 11494, v); }
+
+    /**
+     * Selects which bits from the front stencil value will be compared.
+     */
+    get frontOpCompareMask(): number { return _C(this, 4902) as number; }
+    set frontOpCompareMask(v: number) { _C(this, 11495, v); }
+
+    /**
+     * Selects which bits from the front stencil value will be changed.
+     */
+    get frontOpWriteMask(): number { return _C(this, 4907) as number; }
+    set frontOpWriteMask(v: number) { _C(this, 11500, v); }
+
+    /**
+     * The value the previous front stencil value will be compared to.
+     */
+    get frontOpReference(): number { return _C(this, 4906) as number; }
+    set frontOpReference(v: number) { _C(this, 11499, v); }
+
+    /**
+     * The operation to perform on the stencil buffer for back pixels that fail the stencil test.
+     */
+    get backOpFail(): StencilOperation { return _C(this, 3867) as StencilOperation; }
+    set backOpFail(v: StencilOperation) { _C(this, 10619, v); }
+
+    /**
+     * The operation to perform on the stencil buffer for back pixels that pass the stencil test.
+     */
+    get backOpPass(): StencilOperation { return _C(this, 3868) as StencilOperation; }
+    set backOpPass(v: StencilOperation) { _C(this, 10620, v); }
+
+    /**
+     * The operation to perform on the stencil buffer for back pixels that pass the stencil test but fail the depth test.
+     */
+    get backOpDepthFail(): StencilOperation { return _C(this, 3866) as StencilOperation; }
+    set backOpDepthFail(v: StencilOperation) { _C(this, 10618, v); }
+
+    /**
+     * The method used for comparing the previous back stencil value and {@link backOpReference}.
+     */
+    get backOpCompare(): CompareOperator { return _C(this, 3864) as CompareOperator; }
+    set backOpCompare(v: CompareOperator) { _C(this, 10616, v); }
+
+    /**
+     * Selects which bits from the back stencil value will be compared.
+     */
+    get backOpCompareMask(): number { return _C(this, 3865) as number; }
+    set backOpCompareMask(v: number) { _C(this, 10617, v); }
+
+    /**
+     * Selects which bits from the back stencil value will be changed.
+     */
+    get backOpWriteMask(): number { return _C(this, 3870) as number; }
+    set backOpWriteMask(v: number) { _C(this, 10622, v); }
+
+    /**
+     * The value the previous back stencil value will be compared to.
+     */
+    get backOpReference(): number { return _C(this, 3869) as number; }
+    set backOpReference(v: number) { _C(this, 10621, v); }
+
+    static readonly name = _R(622, RDPipelineDepthStencilState);
+}

package/gen/classes/RDPipelineMultisampleState.ts

@@ -0,0 +1,52 @@
+// 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 } from '../heap-types/index.ts';
+import type { TextureSamples } from './RenderingDevice.ts';
+
+/**
+ * {@link RDPipelineMultisampleState} is used to control how multisample or supersample antialiasing is being performed when rendering using {@link RenderingDevice}.
+ */
+export class RDPipelineMultisampleState extends RefCounted {
+    constructor(name = 623) { super(name); }
+
+    /**
+     * The number of MSAA samples (or SSAA samples if {@link enableSampleShading} is `true`) to perform. Higher values result in better antialiasing, at the cost of performance.
+     */
+    get sampleCount(): TextureSamples { return _C(this, 6227) as TextureSamples; }
+    set sampleCount(v: TextureSamples) { _C(this, 12599, v); }
+
+    /**
+     * If `true`, enables per-sample shading which replaces MSAA by SSAA. This provides higher quality antialiasing that works with transparent (alpha scissor) edges. This has a very high performance cost. See also {@link minSampleShading}. See the [per-sample shading Vulkan documentation](https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#primsrast-sampleshading) for more details.
+     */
+    get enableSampleShading(): boolean { return _C(this, 4654) as boolean; }
+    set enableSampleShading(v: boolean) { _C(this, 11282, v); }
+
+    /**
+     * The multiplier of {@link sampleCount} that determines how many samples are performed for each fragment. Must be between `0.0` and `1.0` (inclusive). Only effective if {@link enableSampleShading} is `true`. If {@link minSampleShading} is `1.0`, fragment invocation must only read from the coverage index sample. Tile image access must not be used if {@link enableSampleShading} is *not* `1.0`.
+     */
+    get minSampleShading(): number { return _C(this, 5543) as number; }
+    set minSampleShading(v: number) { _C(this, 12053, v); }
+
+    /**
+     * If `true`, alpha to coverage is enabled. This generates a temporary coverage value based on the alpha component of the fragment's first color output. This allows alpha transparency to make use of multisample antialiasing.
+     */
+    get enableAlphaToCoverage(): boolean { return _C(this, 4639) as boolean; }
+    set enableAlphaToCoverage(v: boolean) { _C(this, 11263, v); }
+
+    /**
+     * If `true`, alpha is forced to either `0.0` or `1.0`. This allows hardening the edges of antialiased alpha transparencies. Only relevant if {@link enableAlphaToCoverage} is `true`.
+     */
+    get enableAlphaToOne(): boolean { return _C(this, 4640) as boolean; }
+    set enableAlphaToOne(v: boolean) { _C(this, 11264, v); }
+
+    /**
+     * The sample mask array. See the [sample mask Vulkan documentation](https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#fragops-samplemask) for more details.
+     */
+    get sampleMasks(): GodotArray<number> { return _C(this, 6228) as GodotArray<number>; }
+    set sampleMasks(v: GodotArray<number>) { _C(this, 12600, v); }
+
+    static readonly name = _R(623, RDPipelineMultisampleState);
+}