@ringozz/godot 0.1.0

package/gen/classes/OccluderInstance3D.ts

@@ -0,0 +1,54 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualInstance3D } from './VisualInstance3D.ts';
+import type { Occluder3D } from './Occluder3D.ts';
+
+/**
+ * Occlusion culling can improve rendering performance in closed/semi-open areas by hiding geometry that is occluded by other objects.
+ * The occlusion culling system is mostly static. {@link OccluderInstance3D}s can be moved or hidden at run-time, but doing so will trigger a background recomputation that can take several frames. It is recommended to only move {@link OccluderInstance3D}s sporadically (e.g. for procedural generation purposes), rather than doing so every frame.
+ * The occlusion culling system works by rendering the occluders on the CPU in parallel using [Embree](https://www.embree.org/), drawing the result to a low-resolution buffer then using this to cull 3D nodes individually. In the 3D editor, you can preview the occlusion culling buffer by choosing **Perspective > Display Advanced... > Occlusion Culling Buffer** in the top-left corner of the 3D viewport. The occlusion culling buffer quality can be adjusted in the Project Settings.
+ * **Baking:** Select an {@link OccluderInstance3D} node, then use the **Bake Occluders** button at the top of the 3D editor. Only opaque materials will be taken into account; transparent materials (alpha-blended or alpha-tested) will be ignored by the occluder generation.
+ * **Note:** Occlusion culling is only effective if {@link ProjectSettings.rendering/occlusionCulling/useOcclusionCulling} is `true`. Enabling occlusion culling has a cost on the CPU. Only enable occlusion culling if you actually plan to use it. Large open scenes with few or no objects blocking the view will generally not benefit much from occlusion culling. Large open scenes generally benefit more from mesh LOD and visibility ranges ({@link GeometryInstance3D.visibilityRangeBegin} and {@link GeometryInstance3D.visibilityRangeEnd}) compared to occlusion culling.
+ * **Note:** Due to memory constraints, occlusion culling is not supported by default in Web export templates. It can be enabled by compiling custom Web export templates with `module_raycast_enabled=yes`.
+ */
+export class OccluderInstance3D extends VisualInstance3D {
+    constructor(name = 466) { super(name); }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link bakeMask}, given a `layerNumber` between 1 and 32.
+     */
+    setBakeMaskValue(layerNumber: number, value: boolean): void { _C(this, 10630, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified layer of the {@link bakeMask} is enabled, given a `layerNumber` between 1 and 32.
+     */
+    getBakeMaskValue(layerNumber: number): boolean { return _C(this, 3876, layerNumber) as boolean; }
+
+    /**
+     * The occluder resource for this {@link OccluderInstance3D}. You can generate an occluder resource by selecting an {@link OccluderInstance3D} node then using the **Bake Occluders** button at the top of the editor.
+     * You can also draw your own 2D occluder polygon by adding a new {@link PolygonOccluder3D} resource to the {@link occluder} property in the Inspector.
+     * Alternatively, you can select a primitive occluder to use: {@link QuadOccluder3D}, {@link BoxOccluder3D} or {@link SphereOccluder3D}.
+     */
+    get occluder(): Occluder3D { return _C(this, 5689) as Occluder3D; }
+    set occluder(v: Occluder3D) { _C(this, 12160, v); }
+
+    /**
+     * The visual layers to account for when baking for occluders. Only {@link MeshInstance3D}s whose {@link VisualInstance3D.layers} match with this {@link bakeMask} will be included in the generated occluder mesh. By default, all objects with *opaque* materials are taken into account for the occluder baking.
+     * To improve performance and avoid artifacts, it is recommended to exclude dynamic objects, small objects and fixtures from the baking process by moving them to a separate visual layer and excluding this layer in {@link bakeMask}.
+     */
+    get bakeMask(): number { return _C(this, 3875) as number; }
+    set bakeMask(v: number) { _C(this, 10629, v); }
+
+    /**
+     * The simplification distance to use for simplifying the generated occluder polygon (in 3D units). Higher values result in a less detailed occluder mesh, which improves performance but reduces culling accuracy.
+     * The occluder geometry is rendered on the CPU, so it is important to keep its geometry as simple as possible. Since the buffer is rendered at a low resolution, less detailed occluder meshes generally still work well. The default value is fairly aggressive, so you may have to decrease it if you run into false negatives (objects being occluded even though they are visible by the camera). A value of `0.01` will act conservatively, and will keep geometry *perceptually* unaffected in the occlusion culling buffer. Depending on the scene, a value of `0.01` may still simplify the mesh noticeably compared to disabling simplification entirely.
+     * Setting this to `0.0` disables simplification entirely, but vertices in the exact same position will still be merged. The mesh will also be re-indexed to reduce both the number of vertices and indices.
+     * **Note:** This uses the [meshoptimizer](https://meshoptimizer.org/) library under the hood, similar to LOD generation.
+     */
+    get bakeSimplificationDistance(): number { return _C(this, 3882) as number; }
+    set bakeSimplificationDistance(v: number) { _C(this, 10635, v); }
+
+    static readonly name = _R(466, OccluderInstance3D);
+}

package/gen/classes/OccluderPolygon2D.ts

@@ -0,0 +1,51 @@
+// 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 { PackedVector2Array } from '../heap-types/index.ts';
+
+/**
+ * Editor facility that helps you draw a 2D polygon used as resource for {@link LightOccluder2D}.
+ */
+export class OccluderPolygon2D extends Resource {
+    constructor(name = 467) { super(name); }
+
+    /**
+     * If `true`, closes the polygon. A closed OccluderPolygon2D occludes the light coming from any direction. An opened OccluderPolygon2D occludes the light only at its outline's direction.
+     */
+    get closed(): boolean { return _C(this, 7835) as boolean; }
+    set closed(v: boolean) { _C(this, 10872, v); }
+
+    /**
+     * The culling mode to use.
+     */
+    get cullMode(): CullMode { return _C(this, 4341) as CullMode; }
+    set cullMode(v: CullMode) { _C(this, 10983, v); }
+
+    /**
+     * A {@link Vector2} array with the index for polygon's vertices positions.
+     */
+    get polygon(): PackedVector2Array { return _C(this, 5962) as PackedVector2Array; }
+    set polygon(v: PackedVector2Array) { _C(this, 12373, v); }
+
+    static readonly name = _R(467, OccluderPolygon2D);
+}
+
+export const CullMode = {
+    /**
+     * Culling is disabled. See {@link cullMode}.
+     */
+    CULL_DISABLED: 0,
+    /**
+     * Culling is performed in the clockwise direction. See {@link cullMode}.
+     */
+    CULL_CLOCKWISE: 1,
+    /**
+     * Culling is performed in the counterclockwise direction. See {@link cullMode}.
+     */
+    CULL_COUNTER_CLOCKWISE: 2,
+} as const;
+
+export type CullMode = (typeof CullMode)[keyof typeof CullMode];
+

package/gen/classes/OfflineMultiplayerPeer.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 { MultiplayerPeer } from './MultiplayerPeer.ts';
+
+/**
+ * This is the default {@link MultiplayerAPI.multiplayerPeer} for the {@link Node.multiplayer}. It mimics the behavior of a server with no peers connected.
+ * This means that the {@link SceneTree} will act as the multiplayer authority by default. Calls to {@link MultiplayerAPI.isServer} will return `true`, and calls to {@link MultiplayerAPI.getUniqueId} will return {@link MultiplayerPeer.TARGET_PEER_SERVER}.
+ */
+export class OfflineMultiplayerPeer extends MultiplayerPeer {
+    constructor(name = 468) { super(name); }
+
+    static readonly name = _R(468, OfflineMultiplayerPeer);
+}

package/gen/classes/OggPacketSequence.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, PackedInt64Array } from '../heap-types/index.ts';
+
+/**
+ * A sequence of Ogg packets.
+ */
+export class OggPacketSequence extends Resource {
+    constructor(name = 469) { super(name); }
+
+    /**
+     * The length of this stream, in seconds.
+     */
+    getLength(): number { return _C(this, 5331) as number; }
+
+    /**
+     * Contains the raw packets that make up this OggPacketSequence.
+     */
+    get packetData(): GodotArray<GodotArray> { return _C(this, 5785) as GodotArray<GodotArray>; }
+    set packetData(v: GodotArray<GodotArray>) { _C(this, 12234, v); }
+
+    /**
+     * Contains the granule positions for each page in this packet sequence.
+     */
+    get granulePositions(): PackedInt64Array { return _C(this, 5788) as PackedInt64Array; }
+    set granulePositions(v: PackedInt64Array) { _C(this, 12235, v); }
+
+    /**
+     * Holds sample rate information about this sequence. Must be set by another class that actually understands the codec.
+     */
+    get samplingRate(): number { return _C(this, 6233) as number; }
+    set samplingRate(v: number) { _C(this, 12606, v); }
+
+    static readonly name = _R(469, OggPacketSequence);
+}

package/gen/classes/OggPacketSequencePlayback.ts

@@ -0,0 +1,11 @@
+// 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';
+
+export class OggPacketSequencePlayback extends RefCounted {
+    constructor(name = 470) { super(name); }
+
+    static readonly name = _R(470, OggPacketSequencePlayback);
+}

package/gen/classes/OmniLight3D.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 { Light3D } from './Light3D.ts';
+
+/**
+ * An Omnidirectional light is a type of {@link Light3D} that emits light in all directions. The light is attenuated by distance and this attenuation can be configured by changing its energy, radius, and attenuation parameters.
+ * **Note:** When using the Mobile rendering method, only 8 omni lights can be displayed on each mesh resource. Attempting to display more than 8 omni lights on a single mesh resource will result in omni lights flickering in and out as the camera moves. When using the Compatibility rendering method, only 8 omni lights can be displayed on each mesh resource by default, but this can be increased by adjusting {@link ProjectSettings.rendering/limits/opengl/maxLightsPerObject}.
+ * **Note:** When using the Mobile or Compatibility rendering methods, omni lights will only correctly affect meshes whose visibility AABB intersects with the light's AABB. If using a shader to deform the mesh in a way that makes it go outside its AABB, {@link GeometryInstance3D.extraCullMargin} must be increased on the mesh. Otherwise, the light may not be visible on the mesh.
+ */
+export class OmniLight3D extends Light3D {
+    constructor(name = 471) { super(name); }
+
+    /**
+     * The light's radius. Note that the effectively lit area may appear to be smaller depending on the {@link omniAttenuation} in use. No matter the {@link omniAttenuation} in use, the light will never reach anything outside this radius.
+     * **Note:** {@link omniRange} is not affected by {@link Node3D.scale} (the light's scale or its parent's scale).
+     */
+    get omniRange(): number { return _C(this, 5809, 4) as number; }
+    set omniRange(v: number) { _C(this, 12248, 4, v); }
+
+    /**
+     * Controls the distance attenuation function for omnilights.
+     * A value of `0.0` will maintain a constant brightness through most of the range, but smoothly attenuate the light at the edge of the range. Use a value of `2.0` for physically accurate lights as it results in the proper inverse square attenutation.
+     * **Note:** Setting attenuation to `2.0` or higher may result in distant objects receiving minimal light, even within range. For example, with a range of `4096`, an object at `100` units is attenuated by a factor of `0.0001`. With a default brightness of `1`, the light would not be visible at that distance.
+     * **Note:** Using negative or values higher than `10.0` may lead to unexpected results.
+     */
+    get omniAttenuation(): number { return _C(this, 5809, 6) as number; }
+    set omniAttenuation(v: number) { _C(this, 12248, 6, v); }
+
+    get omniShadowMode(): ShadowMode { return _C(this, 6363) as ShadowMode; }
+    set omniShadowMode(v: ShadowMode) { _C(this, 12710, v); }
+
+    static readonly name = _R(471, OmniLight3D);
+}
+
+export const ShadowMode = {
+    /**
+     * Shadows are rendered to a dual-paraboloid texture. Faster than {@link SHADOW_CUBE}, but lower-quality.
+     */
+    SHADOW_DUAL_PARABOLOID: 0,
+    /**
+     * Shadows are rendered to a cubemap. Slower than {@link SHADOW_DUAL_PARABOLOID}, but higher-quality.
+     */
+    SHADOW_CUBE: 1,
+} as const;
+
+export type ShadowMode = (typeof ShadowMode)[keyof typeof ShadowMode];
+

package/gen/classes/OpenXRAPIExtension.ts

@@ -0,0 +1,303 @@
+// 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, PackedInt64Array, RID } from '../heap-types/index.ts';
+import type { Rect2i, Transform3D, Vector2i } from '../value-types/index.ts';
+import type { OpenXRExtensionWrapper } from './OpenXRExtensionWrapper.ts';
+
+/**
+ * {@link OpenXRAPIExtension} makes OpenXR available for GDExtension. It provides the OpenXR API to GDExtension through the {@link getInstanceProcAddr} method, and the OpenXR instance through {@link getInstance}.
+ * It also provides methods for querying the status of OpenXR initialization, and helper methods for ease of use of the API with GDExtension.
+ */
+export class OpenXRAPIExtension extends RefCounted {
+    constructor(name = 472) { super(name); }
+
+    /**
+     * Returns the version of OpenXR that was initialized. Only valid after the OpenXR instance has been created. See [XR_MAKE_VERSION](https://registry.khronos.org/OpenXR/specs/1.1/html/xrspec.html#XR_MAKE_VERSION) for how the version is calculated.
+     */
+    getOpenxrVersion(): number { return _C(this, 5726) as number; }
+
+    /**
+     * Returns the [XrInstance](https://registry.khronos.org/OpenXR/specs/1.0/man/html/XrInstance.html) created during the initialization of the OpenXR API.
+     */
+    getInstance(): number { return _C(this, 5128) as number; }
+
+    /**
+     * Returns the ID of the system, which is an [XrSystemId](https://registry.khronos.org/OpenXR/specs/1.0/man/html/XrSystemId.html) cast to an integer.
+     */
+    getSystemId(): number { return _C(this, 6661) as number; }
+
+    /**
+     * Returns the OpenXR session, which is an [XrSession](https://registry.khronos.org/OpenXR/specs/1.0/man/html/XrSession.html) cast to an integer.
+     */
+    getSession(): number { return _C(this, 6346) as number; }
+
+    /**
+     * Creates a {@link Transform3D} from an [XrPosef](https://registry.khronos.org/OpenXR/specs/1.0/man/html/XrPosef.html).
+     */
+    transformFromPose(pose: unknown): Transform3D { return _C(this, 14391, pose) as Transform3D; }
+
+    /**
+     * Returns `true` if the provided [XrResult](https://registry.khronos.org/OpenXR/specs/1.0/man/html/XrResult.html) (cast to an integer) is successful. Otherwise returns `false` and prints the [XrResult](https://registry.khronos.org/OpenXR/specs/1.0/man/html/XrResult.html) converted to a string, with the specified additional information.
+     */
+    xrResult(result: number /* uint64 */, format: string, args: GodotArray): boolean { return _C(this, 14951, result, format, args) as boolean; }
+
+    /**
+     * Returns `true` if OpenXR is enabled.
+     */
+    static openxrIsEnabled(checkRunInEditor: boolean): boolean { return _C(472, 9198, checkRunInEditor) as boolean; }
+
+    /**
+     * Returns the function pointer of the OpenXR function with the specified name, cast to an integer. If the function with the given name does not exist, the method returns `0`.
+     * **Note:** `openxr/util.h` contains utility macros for acquiring OpenXR functions, e.g. `GDEXTENSION_INIT_XR_FUNC_V(xrCreateAction)`.
+     */
+    getInstanceProcAddr(name: string): number { return _C(this, 5137, name) as number; }
+
+    /**
+     * Returns an error string for the given [XrResult](https://registry.khronos.org/OpenXR/specs/1.0/man/html/XrResult.html).
+     */
+    getErrorString(result: number /* uint64 */): string { return _C(this, 4687, result) as string; }
+
+    /**
+     * Returns the name of the specified swapchain format.
+     */
+    getSwapchainFormatName(swapchainFormat: number /* int64 */): string { return _C(this, 6643, swapchainFormat) as string; }
+
+    /**
+     * Set the object name of an OpenXR object, used for debug output. `objectType` must be a valid OpenXR `XrObjectType` enum and `objectHandle` must be a valid OpenXR object handle.
+     */
+    setObjectName(objectType: number /* int64 */, objectHandle: number /* uint64 */, objectName: string): void { _C(this, 12158, objectType, objectHandle, objectName); }
+
+    /**
+     * Begins a new debug label region, this label will be reported in debug messages for any calls following this until {@link endDebugLabelRegion} is called. Debug labels can be stacked.
+     */
+    beginDebugLabelRegion(labelName: string): void { _C(this, 1749, labelName); }
+
+    /**
+     * Marks the end of a debug label region. Removes the latest debug label region added by calling {@link beginDebugLabelRegion}.
+     */
+    endDebugLabelRegion(): void { _C(this, 3098); }
+
+    /**
+     * Inserts a debug label, this label is reported in any debug message resulting from the OpenXR calls that follows, until any of {@link beginDebugLabelRegion}, {@link endDebugLabelRegion}, or {@link insertDebugLabel} is called.
+     */
+    insertDebugLabel(labelName: string): void { _C(this, 7633, labelName); }
+
+    /**
+     * Returns the number of views. It is usually two, one for each eye, but may differ with different view configurations.
+     */
+    getViewCount(): number { return _C(this, 7078) as number; }
+
+    /**
+     * Returns the view configuration type, which is an [XrViewConfigurationType](https://registry.khronos.org/OpenXR/specs/1.0/man/html/XrViewConfigurationType.html) cast to an integer.
+     */
+    getViewConfiguration(): number { return _C(this, 7077) as number; }
+
+    /**
+     * Returns `true` if OpenXR is initialized.
+     */
+    isInitialized(): boolean { return _C(this, 8024) as boolean; }
+
+    /**
+     * Returns `true` if OpenXR is running ([xrBeginSession](https://registry.khronos.org/OpenXR/specs/1.0/man/html/xrBeginSession.html) was successfully called and the swapchains were created).
+     */
+    isRunning(): boolean { return _C(this, 8258) as boolean; }
+
+    /**
+     * Sets the reference space used by OpenXR to the given [XrSpace](https://registry.khronos.org/OpenXR/specs/1.0/man/html/XrSpace.html) (cast to a `void *`).
+     */
+    setCustomPlaySpace(space: unknown): void { _C(this, 11019, space); }
+
+    /**
+     * Returns the play space, which is an [XrSpace](https://registry.khronos.org/OpenXR/specs/1.0/man/html/XrSpace.html) cast to an integer.
+     */
+    getPlaySpace(): number { return _C(this, 5931) as number; }
+
+    /**
+     * Returns the predicted display timing for the current frame.
+     */
+    getPredictedDisplayTime(): number { return _C(this, 5988) as number; }
+
+    /**
+     * Returns the predicted display timing for the next frame.
+     */
+    getNextFrameTime(): number { return _C(this, 5625) as number; }
+
+    /**
+     * Returns `true` if OpenXR is initialized for rendering with an XR viewport.
+     */
+    canRender(): boolean { return _C(this, 2016) as boolean; }
+
+    /**
+     * Returns the {@link RID} corresponding to an `Action` of a matching name, optionally limited to a specified action set.
+     */
+    findAction(name: string, actionSet: RID): RID { return _C(this, 3277, name, actionSet) as RID; }
+
+    /**
+     * Returns the corresponding `XrAction` OpenXR handle for the given action RID.
+     */
+    actionGetHandle(action: RID): number { return _C(this, 1161, action) as number; }
+
+    /**
+     * Returns the corresponding `XRHandTrackerEXT` handle for the given hand index value.
+     */
+    getHandTracker(handIndex: number): number { return _C(this, 5015, handIndex) as number; }
+
+    /**
+     * Registers the given extension as a composition layer provider.
+     * **Note:** This cannot be called after the OpenXR session has started. However, it can be called in {@link OpenXRExtensionWrapper.OnSessionCreated}.
+     */
+    registerCompositionLayerProvider(extension: OpenXRExtensionWrapper): void { _C(this, 9842, extension); }
+
+    /**
+     * Unregisters the given extension as a composition layer provider.
+     * **Note:** This cannot be called while the OpenXR session is still running.
+     */
+    unregisterCompositionLayerProvider(extension: OpenXRExtensionWrapper): void { _C(this, 14488, extension); }
+
+    /**
+     * Registers the given extension as a provider of additional data structures to projections views.
+     * **Note:** This cannot be called after the OpenXR session has started. However, it can be called in {@link OpenXRExtensionWrapper.OnSessionCreated}.
+     */
+    registerProjectionViewsExtension(extension: OpenXRExtensionWrapper): void { _C(this, 9854, extension); }
+
+    /**
+     * Unregisters the given extension as a provider of additional data structures to projections views.
+     * **Note:** This cannot be called while the OpenXR session is still running.
+     */
+    unregisterProjectionViewsExtension(extension: OpenXRExtensionWrapper): void { _C(this, 14494, extension); }
+
+    /**
+     * Registers the given extension as modifying frame info via the {@link OpenXRExtensionWrapper.SetFrameWaitInfoAndGetNextPointer}, {@link OpenXRExtensionWrapper.SetViewLocateInfoAndGetNextPointer}, or {@link OpenXRExtensionWrapper.SetFrameEndInfoAndGetNextPointer} virtual methods.
+     * **Note:** This cannot be called after the OpenXR session has started. However, it can be called in {@link OpenXRExtensionWrapper.OnSessionCreated}.
+     */
+    registerFrameInfoExtension(extension: OpenXRExtensionWrapper): void { _C(this, 9844, extension); }
+
+    /**
+     * Unregisters the given extension as modifying frame info.
+     * **Note:** This cannot be called while the OpenXR session is still running.
+     */
+    unregisterFrameInfoExtension(extension: OpenXRExtensionWrapper): void { _C(this, 14489, extension); }
+
+    /**
+     * Registers the given extension as modifying `XrCompositionLayerProjection` via the {@link OpenXRExtensionWrapper.SetProjectionLayerAndGetNextPointer} virtual method.
+     * **Note:** This cannot be called after the OpenXR session has started. However, it can be called in {@link OpenXRExtensionWrapper.OnSessionCreated}.
+     */
+    registerProjectionLayerExtension(extension: OpenXRExtensionWrapper): void { _C(this, 9853, extension); }
+
+    /**
+     * Unregisters the given extension as modifying `XrCompositionLayerProjection`.
+     * **Note:** This cannot be called while the OpenXR session is still running.
+     */
+    unregisterProjectionLayerExtension(extension: OpenXRExtensionWrapper): void { _C(this, 14493, extension); }
+
+    /**
+     * Returns the near boundary value of the camera frustum.
+     * **Note:** This is only accessible in the render thread.
+     */
+    getRenderStateZNear(): number { return _C(this, 6135) as number; }
+
+    /**
+     * Returns the far boundary value of the camera frustum.
+     * **Note:** This is only accessible in the render thread.
+     */
+    getRenderStateZFar(): number { return _C(this, 6134) as number; }
+
+    /**
+     * Sets the render target of the velocity texture.
+     */
+    setVelocityTexture(renderTarget: RID): void { _C(this, 13285, renderTarget); }
+
+    /**
+     * Sets the render target of the velocity depth texture.
+     */
+    setVelocityDepthTexture(renderTarget: RID): void { _C(this, 13280, renderTarget); }
+
+    /**
+     * Sets the target size of the velocity and velocity depth textures.
+     */
+    setVelocityTargetSize(targetSize: Vector2i): void { _C(this, 13284, targetSize); }
+
+    /**
+     * Returns an array of supported swapchain formats.
+     */
+    getSupportedSwapchainFormats(): PackedInt64Array { return _C(this, 6621) as PackedInt64Array; }
+
+    /**
+     * Returns a pointer to a new swapchain created using the provided parameters.
+     */
+    openxrSwapchainCreate(createFlags: number /* uint64 */, usageFlags: number /* uint64 */, swapchainFormat: number /* int64 */, width: number /* uint32 */, height: number /* uint32 */, sampleCount: number /* uint32 */, arraySize: number /* uint32 */): number { return _C(this, 9200, createFlags, usageFlags, swapchainFormat, width, height, sampleCount, arraySize) as number; }
+
+    /**
+     * Destroys the provided swapchain and frees it from memory.
+     */
+    openxrSwapchainFree(swapchain: number /* uint64 */): void { _C(this, 9201, swapchain); }
+
+    /**
+     * Returns the `XrSwapchain` handle of the provided swapchain.
+     */
+    openxrSwapchainGetSwapchain(swapchain: number /* uint64 */): number { return _C(this, 9203, swapchain) as number; }
+
+    /**
+     * Acquires the image of the provided swapchain.
+     */
+    openxrSwapchainAcquire(swapchain: number /* uint64 */): void { _C(this, 9199, swapchain); }
+
+    /**
+     * Returns the RID of the provided swapchain's image.
+     */
+    openxrSwapchainGetImage(swapchain: number /* uint64 */): RID { return _C(this, 9202, swapchain) as RID; }
+
+    /**
+     * Releases the image of the provided swapchain.
+     */
+    openxrSwapchainRelease(swapchain: number /* uint64 */): void { _C(this, 9204, swapchain); }
+
+    /**
+     * Returns a pointer to the render state's `XrCompositionLayerProjection` struct.
+     * **Note:** This method should only be called from the rendering thread.
+     */
+    getProjectionLayer(): number { return _C(this, 6045) as number; }
+
+    /**
+     * Sets the render region to `renderRegion`, overriding the normal render target's rect.
+     */
+    setRenderRegion(renderRegion: Rect2i): void { _C(this, 12521, renderRegion); }
+
+    /**
+     * If set to `true`, an OpenXR extension is loaded which is capable of emulating the {@link XRInterface.XR_ENV_BLEND_MODE_ALPHA_BLEND} blend mode.
+     */
+    setEmulateEnvironmentBlendModeAlphaBlend(enabled: boolean): void { _C(this, 11259, enabled); }
+
+    /**
+     * Returns {@link OpenXRAPIExtension.OpenXRAlphaBlendModeSupport} denoting if {@link XRInterface.XR_ENV_BLEND_MODE_ALPHA_BLEND} is really supported, emulated or not supported at all.
+     */
+    isEnvironmentBlendModeAlphaSupported(): OpenXRAlphaBlendModeSupport { return _C(this, 7937) as OpenXRAlphaBlendModeSupport; }
+
+    /**
+     * Request the recommended resolution from the OpenXR runtime and update the main swapchain size if it has changed.
+     */
+    updateMainSwapchainSize(): void { _C(this, 14519); }
+
+    static readonly name = _R(472, OpenXRAPIExtension);
+}
+
+export const OpenXRAlphaBlendModeSupport = {
+    /**
+     * Means that {@link XRInterface.XR_ENV_BLEND_MODE_ALPHA_BLEND} isn't supported at all.
+     */
+    OPENXR_ALPHA_BLEND_MODE_SUPPORT_NONE: 0,
+    /**
+     * Means that {@link XRInterface.XR_ENV_BLEND_MODE_ALPHA_BLEND} is really supported.
+     */
+    OPENXR_ALPHA_BLEND_MODE_SUPPORT_REAL: 1,
+    /**
+     * Means that {@link XRInterface.XR_ENV_BLEND_MODE_ALPHA_BLEND} is emulated.
+     */
+    OPENXR_ALPHA_BLEND_MODE_SUPPORT_EMULATING: 2,
+} as const;
+
+export type OpenXRAlphaBlendModeSupport = (typeof OpenXRAlphaBlendModeSupport)[keyof typeof OpenXRAlphaBlendModeSupport];
+

package/gen/classes/OpenXRAction.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 { Resource } from './Resource.ts';
+import type { PackedStringArray } from '../heap-types/index.ts';
+
+/**
+ * This resource defines an OpenXR action. Actions can be used both for inputs (buttons, joysticks, triggers, etc.) and outputs (haptics).
+ * OpenXR performs automatic conversion between action type and input type whenever possible. An analog trigger bound to a boolean action will thus return `false` if the trigger is depressed and `true` if pressed fully.
+ * Actions are not directly bound to specific devices, instead OpenXR recognizes a limited number of top level paths that identify devices by usage. We can restrict which devices an action can be bound to by these top level paths. For instance an action that should only be used for hand held controllers can have the top level paths "/user/hand/left" and "/user/hand/right" associated with them. See the [reserved path section in the OpenXR specification](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#semantic-path-reserved) for more info on the top level paths.
+ * Note that the name of the resource is used to register the action with.
+ */
+export class OpenXRAction extends Resource {
+    constructor(name = 473) { super(name); }
+
+    /**
+     * The localized description of this action.
+     */
+    get localizedName(): string { return _C(this, 5408) as string; }
+    set localizedName(v: string) { _C(this, 11944, v); }
+
+    /**
+     * The type of action.
+     */
+    get actionType(): ActionType { return _C(this, 3689) as ActionType; }
+    set actionType(v: ActionType) { _C(this, 10423, v); }
+
+    /**
+     * A collections of toplevel paths to which this action can be bound.
+     */
+    get toplevelPaths(): PackedStringArray { return _C(this, 6848) as PackedStringArray; }
+    set toplevelPaths(v: PackedStringArray) { _C(this, 13117, v); }
+
+    static readonly name = _R(473, OpenXRAction);
+}
+
+export const ActionType = {
+    /**
+     * This action provides a boolean value.
+     */
+    OPENXR_ACTION_BOOL: 0,
+    /**
+     * This action provides a float value between `0.0` and `1.0` for any analog input such as triggers.
+     */
+    OPENXR_ACTION_FLOAT: 1,
+    /**
+     * This action provides a {@link Vector2} value and can be bound to embedded trackpads and joysticks.
+     */
+    OPENXR_ACTION_VECTOR2: 2,
+    OPENXR_ACTION_POSE: 3,
+} as const;
+
+export type ActionType = (typeof ActionType)[keyof typeof ActionType];
+

package/gen/classes/OpenXRActionBindingModifier.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 { OpenXRBindingModifier } from './OpenXRBindingModifier.ts';
+
+/**
+ * Binding modifier that applies on individual actions related to an interaction profile.
+ */
+export class OpenXRActionBindingModifier extends OpenXRBindingModifier {
+    constructor(name = 474) { super(name); }
+
+    static readonly name = _R(474, OpenXRActionBindingModifier);
+}