@ringozz/godot 0.1.0

package/gen/classes/RenderSceneBuffersConfiguration.ts

@@ -0,0 +1,78 @@
+// 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 { Vector2i } from '../value-types/index.ts';
+import type { ViewportAnisotropicFiltering, ViewportMSAA, ViewportScaling3DMode, ViewportScreenSpaceAA } from './RenderingServer.ts';
+
+/**
+ * This configuration object is created and populated by the render engine on a viewport change and used to (re)configure a {@link RenderSceneBuffers} object.
+ */
+export class RenderSceneBuffersConfiguration extends RefCounted {
+    constructor(name = 651) { super(name); }
+
+    /**
+     * The render target associated with these buffer.
+     */
+    get renderTarget(): RID { return _C(this, 6136) as RID; }
+    set renderTarget(v: RID) { _C(this, 12522, v); }
+
+    /**
+     * The size of the 3D render buffer used for rendering.
+     */
+    get internalSize(): Vector2i { return _C(this, 5150) as Vector2i; }
+    set internalSize(v: Vector2i) { _C(this, 11738, v); }
+
+    /**
+     * The target (upscale) size if scaling is used.
+     */
+    get targetSize(): Vector2i { return _C(this, 6703) as Vector2i; }
+    set targetSize(v: Vector2i) { _C(this, 13008, v); }
+
+    /**
+     * The number of views we're rendering.
+     */
+    get viewCount(): number { return _C(this, 7078) as number; }
+    set viewCount(v: number) { _C(this, 13311, v); }
+
+    /**
+     * The requested scaling mode with which we upscale/downscale if {@link internalSize} and {@link targetSize} are not equal.
+     */
+    get scaling3dMode(): ViewportScaling3DMode { return _C(this, 6244) as ViewportScaling3DMode; }
+    set scaling3dMode(v: ViewportScaling3DMode) { _C(this, 12616, v); }
+
+    /**
+     * The MSAA mode we're using for 3D rendering.
+     */
+    get msaa3d(): ViewportMSAA { return _C(this, 5593) as ViewportMSAA; }
+    set msaa3d(v: ViewportMSAA) { _C(this, 12101, v); }
+
+    /**
+     * The requested screen space AA applied in post processing.
+     */
+    get screenSpaceAa(): ViewportScreenSpaceAA { return _C(this, 6264) as ViewportScreenSpaceAA; }
+    set screenSpaceAa(v: ViewportScreenSpaceAA) { _C(this, 12629, v); }
+
+    /**
+     * FSR Sharpness applicable if FSR upscaling is used.
+     */
+    get fsrSharpness(): number { return _C(this, 4910) as number; }
+    set fsrSharpness(v: number) { _C(this, 11503, v); }
+
+    /**
+     * Bias applied to mipmaps.
+     * **Note:** This property is only supported in the Forward+ and Mobile renderers, not Compatibility. In Compatibility, this property is always treated as if it was set to `0.0`.
+     */
+    get textureMipmapBias(): number { return _C(this, 6737) as number; }
+    set textureMipmapBias(v: number) { _C(this, 13034, v); }
+
+    /**
+     * Level of the anisotropic filter.
+     */
+    get anisotropicFilteringLevel(): ViewportAnisotropicFiltering { return _C(this, 3772) as ViewportAnisotropicFiltering; }
+    set anisotropicFilteringLevel(v: ViewportAnisotropicFiltering) { _C(this, 10509, v); }
+
+    static readonly name = _R(651, RenderSceneBuffersConfiguration);
+}

package/gen/classes/RenderSceneBuffersExtension.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 { RenderSceneBuffers } from './RenderSceneBuffers.ts';
+import type { RenderSceneBuffersConfiguration } from './RenderSceneBuffersConfiguration.ts';
+
+/**
+ * This class allows for a RenderSceneBuffer implementation to be made in GDExtension.
+ */
+export class RenderSceneBuffersExtension extends RenderSceneBuffers {
+    constructor(name = 652) { super(name); }
+
+    static readonly name = _R(652, RenderSceneBuffersExtension);
+}

package/gen/classes/RenderSceneBuffersRD.ts

@@ -0,0 +1,163 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RenderSceneBuffers } from './RenderSceneBuffers.ts';
+import type { RID, StringName } from '../heap-types/index.ts';
+import type { Vector2i } from '../value-types/index.ts';
+import type { RDTextureFormat } from './RDTextureFormat.ts';
+import type { RDTextureView } from './RDTextureView.ts';
+import type { DataFormat, TextureSamples } from './RenderingDevice.ts';
+import type { ViewportMSAA, ViewportScaling3DMode, ViewportScreenSpaceAA } from './RenderingServer.ts';
+
+/**
+ * This object manages all 3D rendering buffers for the rendering device based renderers. An instance of this object is created for every viewport that has 3D rendering enabled. See also {@link RenderSceneBuffers}.
+ * All buffers are organized in **contexts**. The default context is called **render_buffers** and can contain amongst others the color buffer, depth buffer, velocity buffers, VRS density map and MSAA variants of these buffers.
+ * Buffers are only guaranteed to exist during rendering of the viewport.
+ * **Note:** This is an internal rendering server object. Do not instantiate this class from a script.
+ */
+export class RenderSceneBuffersRD extends RenderSceneBuffers {
+    constructor(name = 653) { super(name); }
+
+    /**
+     * Returns `true` if a cached texture exists for this name.
+     */
+    hasTexture(context: StringName, name: StringName): boolean { return _C(this, 7457, context, name) as boolean; }
+
+    /**
+     * Create a new texture with the given definition and cache this under the given name. Will return the existing texture if it already exists.
+     */
+    createTexture(context: StringName, name: StringName, dataFormat: DataFormat, usageBits: number /* uint32 */, textureSamples: TextureSamples, size: Vector2i, layers: number /* uint32 */, mipmaps: number /* uint32 */, unique: boolean, discardable: boolean): RID { return _C(this, 2577, context, name, dataFormat, usageBits, textureSamples, size, layers, mipmaps, unique, discardable) as RID; }
+
+    /**
+     * Create a new texture using the given format and view and cache this under the given name. Will return the existing texture if it already exists.
+     */
+    createTextureFromFormat(context: StringName, name: StringName, format: RDTextureFormat, view: RDTextureView, unique: boolean): RID { return _C(this, 2578, context, name, format, view, unique) as RID; }
+
+    /**
+     * Create a new texture view for an existing texture and cache this under the given `viewName`. Will return the existing texture view if it already exists. Will error if the source texture doesn't exist.
+     */
+    createTextureView(context: StringName, name: StringName, viewName: StringName, view: RDTextureView): RID { return _C(this, 2579, context, name, viewName, view) as RID; }
+
+    /**
+     * Returns a cached texture with this name.
+     */
+    getTexture(context: StringName, name: StringName): RID { return _C(this, 6726, context, name) as RID; }
+
+    /**
+     * Returns the texture format information with which a cached texture was created.
+     */
+    getTextureFormat(context: StringName, name: StringName): RDTextureFormat { return _C(this, 6732, context, name) as RDTextureFormat; }
+
+    /**
+     * Returns a specific slice (layer or mipmap) for a cached texture.
+     */
+    getTextureSlice(context: StringName, name: StringName, layer: number /* uint32 */, mipmap: number /* uint32 */, layers: number /* uint32 */, mipmaps: number /* uint32 */): RID { return _C(this, 6752, context, name, layer, mipmap, layers, mipmaps) as RID; }
+
+    /**
+     * Returns a specific view of a slice (layer or mipmap) for a cached texture.
+     */
+    getTextureSliceView(context: StringName, name: StringName, layer: number /* uint32 */, mipmap: number /* uint32 */, layers: number /* uint32 */, mipmaps: number /* uint32 */, view: RDTextureView): RID { return _C(this, 6754, context, name, layer, mipmap, layers, mipmaps, view) as RID; }
+
+    /**
+     * Returns the texture size of a given slice of a cached texture.
+     */
+    getTextureSliceSize(context: StringName, name: StringName, mipmap: number /* uint32 */): Vector2i { return _C(this, 6753, context, name, mipmap) as Vector2i; }
+
+    /**
+     * Frees all buffers related to this context.
+     */
+    clearContext(context: StringName): void { _C(this, 2255, context); }
+
+    /**
+     * Returns the color texture we are rendering 3D content to. If multiview is used this will be a texture array with all views.
+     * If `msaa` is `true` and MSAA is enabled, this returns the MSAA variant of the buffer.
+     */
+    getColorTexture(msaa?: boolean /* = false */): RID { return _C(this, 4230, msaa) as RID; }
+
+    /**
+     * Returns the specified layer from the color texture we are rendering 3D content to.
+     * If `msaa` is `true` and MSAA is enabled, this returns the MSAA variant of the buffer.
+     */
+    getColorLayer(layer: number /* uint32 */, msaa?: boolean /* = false */): RID { return _C(this, 4224, layer, msaa) as RID; }
+
+    /**
+     * Returns the depth texture we are rendering 3D content to. If multiview is used this will be a texture array with all views.
+     * If `msaa` is `true` and MSAA is enabled, this returns the MSAA variant of the buffer.
+     */
+    getDepthTexture(msaa?: boolean /* = false */): RID { return _C(this, 4482, msaa) as RID; }
+
+    /**
+     * Returns the specified layer from the depth texture we are rendering 3D content to.
+     * If `msaa` is `true` and MSAA is enabled, this returns the MSAA variant of the buffer.
+     */
+    getDepthLayer(layer: number /* uint32 */, msaa?: boolean /* = false */): RID { return _C(this, 4477, layer, msaa) as RID; }
+
+    /**
+     * Returns the velocity texture we are rendering 3D content to. If multiview is used this will be a texture array with all views.
+     * If `msaa` is **true** and MSAA is enabled, this returns the MSAA variant of the buffer.
+     */
+    getVelocityTexture(msaa?: boolean /* = false */): RID { return _C(this, 7040, msaa) as RID; }
+
+    /**
+     * Returns the specified layer from the velocity texture we are rendering 3D content to.
+     */
+    getVelocityLayer(layer: number /* uint32 */, msaa?: boolean /* = false */): RID { return _C(this, 7037, layer, msaa) as RID; }
+
+    /**
+     * Returns the render target associated with this buffers object.
+     */
+    getRenderTarget(): RID { return _C(this, 6136) as RID; }
+
+    /**
+     * Returns the view count for the associated viewport.
+     */
+    getViewCount(): number { return _C(this, 7078) as number; }
+
+    /**
+     * Returns the internal size of the render buffer (size before upscaling) with which textures are created by default.
+     */
+    getInternalSize(): Vector2i { return _C(this, 5150) as Vector2i; }
+
+    /**
+     * Returns the target size of the render buffer (size after upscaling).
+     */
+    getTargetSize(): Vector2i { return _C(this, 6703) as Vector2i; }
+
+    /**
+     * Returns the scaling mode used for upscaling.
+     */
+    getScaling3dMode(): ViewportScaling3DMode { return _C(this, 6244) as ViewportScaling3DMode; }
+
+    /**
+     * Returns the FSR sharpness value used while rendering the 3D content (if {@link getScaling3dMode} is an FSR mode).
+     */
+    getFsrSharpness(): number { return _C(this, 4910) as number; }
+
+    /**
+     * Returns the applied 3D MSAA mode for this viewport.
+     */
+    getMsaa3d(): ViewportMSAA { return _C(this, 5593) as ViewportMSAA; }
+
+    /**
+     * Returns the number of MSAA samples used.
+     */
+    getTextureSamples(): TextureSamples { return _C(this, 6750) as TextureSamples; }
+
+    /**
+     * Returns the screen-space antialiasing method applied.
+     */
+    getScreenSpaceAa(): ViewportScreenSpaceAA { return _C(this, 6264) as ViewportScreenSpaceAA; }
+
+    /**
+     * Returns `true` if TAA is enabled.
+     */
+    getUseTaa(): boolean { return _C(this, 6986) as boolean; }
+
+    /**
+     * Returns `true` if debanding is enabled.
+     */
+    getUseDebanding(): boolean { return _C(this, 6974) as boolean; }
+
+    static readonly name = _R(653, RenderSceneBuffersRD);
+}

package/gen/classes/RenderSceneData.ts

@@ -0,0 +1,49 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { Projection, Transform3D, Vector3 } from '../value-types/index.ts';
+
+/**
+ * Abstract scene data object, exists for the duration of rendering a single viewport. See also {@link RenderSceneDataRD}, {@link RenderData}, and {@link RenderDataRD}.
+ * **Note:** This is an internal rendering server object. Do not instantiate this class from a script.
+ */
+export class RenderSceneData extends Object {
+
+    /**
+     * Returns the camera transform used to render this frame.
+     * **Note:** If more than one view is rendered, this will return a centered transform.
+     */
+    getCamTransform(): Transform3D { return _C(this, 4058) as Transform3D; }
+
+    /**
+     * Returns the camera projection used to render this frame.
+     * **Note:** If more than one view is rendered, this will return a combined projection.
+     */
+    getCamProjection(): Projection { return _C(this, 4057) as Projection; }
+
+    /**
+     * Returns the number of views being rendered.
+     */
+    getViewCount(): number { return _C(this, 7078) as number; }
+
+    /**
+     * Returns the eye offset per view used to render this frame. This is the offset between our camera transform and the eye transform.
+     */
+    getViewEyeOffset(view: number /* uint32 */): Vector3 { return _C(this, 7079, view) as Vector3; }
+
+    /**
+     * Returns the view projection per view used to render this frame.
+     * **Note:** If a single view is rendered, this returns the camera projection. If more than one view is rendered, this will return a projection for the given view including the eye offset.
+     */
+    getViewProjection(view: number /* uint32 */): Projection { return _C(this, 7080, view) as Projection; }
+
+    /**
+     * Return the {@link RID} of the uniform buffer containing the scene data as a UBO.
+     */
+    getUniformBuffer(): RID { return _C(this, 6948) as RID; }
+
+    static readonly name = _R(654, RenderSceneData);
+}

package/gen/classes/RenderSceneDataExtension.ts

@@ -0,0 +1,16 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RenderSceneData } from './RenderSceneData.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { Projection, Transform3D, Vector3 } from '../value-types/index.ts';
+
+/**
+ * This class allows for a RenderSceneData implementation to be made in GDExtension.
+ */
+export class RenderSceneDataExtension extends RenderSceneData {
+    constructor(name = 655) { super(name); }
+
+    static readonly name = _R(655, RenderSceneDataExtension);
+}

package/gen/classes/RenderSceneDataRD.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 { RenderSceneData } from './RenderSceneData.ts';
+
+/**
+ * Object holds scene data related to rendering a single frame of a viewport. See also {@link RenderSceneData}, {@link RenderData}, and {@link RenderDataRD}.
+ * **Note:** This is an internal rendering server object. Do not instantiate this class from a script.
+ */
+export class RenderSceneDataRD extends RenderSceneData {
+    constructor(name = 656) { super(name); }
+
+    static readonly name = _R(656, RenderSceneDataRD);
+}