@ringozz/godot 0.1.0

package/gen/classes/OpenXRActionMap.ts

@@ -0,0 +1,86 @@
+// 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 } from '../heap-types/index.ts';
+import type { OpenXRActionSet } from './OpenXRActionSet.ts';
+import type { OpenXRInteractionProfile } from './OpenXRInteractionProfile.ts';
+
+/**
+ * OpenXR uses an action system similar to Godots Input map system to bind inputs and outputs on various types of XR controllers to named actions. OpenXR specifies more detail on these inputs and outputs than Godot supports.
+ * Another important distinction is that OpenXR offers no control over these bindings. The bindings we register are suggestions, it is up to the XR runtime to offer users the ability to change these bindings. This allows the XR runtime to fill in the gaps if new hardware becomes available.
+ * The action map therefore needs to be loaded at startup and can't be changed afterwards. This resource is a container for the entire action map.
+ */
+export class OpenXRActionMap extends Resource {
+    constructor(name = 475) { super(name); }
+
+    /**
+     * Retrieve the number of actions sets in our action map.
+     */
+    getActionSetCount(): number { return _C(this, 3686) as number; }
+
+    /**
+     * Retrieve an action set by name.
+     */
+    findActionSet(name: string): OpenXRActionSet { return _C(this, 3278, name) as OpenXRActionSet; }
+
+    /**
+     * Retrieve the action set at this index.
+     */
+    getActionSet(idx: number): OpenXRActionSet { return _C(this, 3685, idx) as OpenXRActionSet; }
+
+    /**
+     * Add an action set.
+     */
+    addActionSet(actionSet: OpenXRActionSet): void { _C(this, 1178, actionSet); }
+
+    /**
+     * Remove an action set.
+     */
+    removeActionSet(actionSet: OpenXRActionSet): void { _C(this, 9880, actionSet); }
+
+    /**
+     * Retrieve the number of interaction profiles in our action map.
+     */
+    getInteractionProfileCount(): number { return _C(this, 5144) as number; }
+
+    /**
+     * Find an interaction profile by its name (path).
+     */
+    findInteractionProfile(name: string): OpenXRInteractionProfile { return _C(this, 3288, name) as OpenXRInteractionProfile; }
+
+    /**
+     * Get the interaction profile at this index.
+     */
+    getInteractionProfile(idx: number): OpenXRInteractionProfile { return _C(this, 5143, idx) as OpenXRInteractionProfile; }
+
+    /**
+     * Add an interaction profile.
+     */
+    addInteractionProfile(interactionProfile: OpenXRInteractionProfile): void { _C(this, 1239, interactionProfile); }
+
+    /**
+     * Remove an interaction profile.
+     */
+    removeInteractionProfile(interactionProfile: OpenXRInteractionProfile): void { _C(this, 9922, interactionProfile); }
+
+    /**
+     * Setup this action set with our default actions.
+     */
+    createDefaultActionSets(): void { _C(this, 2518); }
+
+    /**
+     * Collection of {@link OpenXRActionSet}s that are part of this action map.
+     */
+    get actionSets(): GodotArray { return _C(this, 3687) as GodotArray; }
+    set actionSets(v: GodotArray) { _C(this, 10422, v); }
+
+    /**
+     * Collection of {@link OpenXRInteractionProfile}s that are part of this action map.
+     */
+    get interactionProfiles(): GodotArray { return _C(this, 5146) as GodotArray; }
+    set interactionProfiles(v: GodotArray) { _C(this, 11735, v); }
+
+    static readonly name = _R(475, OpenXRActionMap);
+}

package/gen/classes/OpenXRActionSet.ts

@@ -0,0 +1,50 @@
+// 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 } from '../heap-types/index.ts';
+import type { OpenXRAction } from './OpenXRAction.ts';
+
+/**
+ * Action sets in OpenXR define a collection of actions that can be activated in unison. This allows games to easily change between different states that require different inputs or need to reinterpret inputs. For instance we could have an action set that is active when a menu is open, an action set that is active when the player is freely walking around and an action set that is active when the player is controlling a vehicle.
+ * Action sets can contain the same action with the same name, if such action sets are active at the same time the action set with the highest priority defines which binding is active.
+ */
+export class OpenXRActionSet extends Resource {
+    constructor(name = 476) { super(name); }
+
+    /**
+     * Retrieve the number of actions in our action set.
+     */
+    getActionCount(): number { return _C(this, 3677) as number; }
+
+    /**
+     * Add an action to this action set.
+     */
+    addAction(action: OpenXRAction): void { _C(this, 1177, action); }
+
+    /**
+     * Remove an action from this action set.
+     */
+    removeAction(action: OpenXRAction): void { _C(this, 9879, action); }
+
+    /**
+     * The localized name of this action set.
+     */
+    get localizedName(): string { return _C(this, 5408) as string; }
+    set localizedName(v: string) { _C(this, 11944, v); }
+
+    /**
+     * The priority for this action set.
+     */
+    get priority(): number { return _C(this, 6015) as number; }
+    set priority(v: number) { _C(this, 12419, v); }
+
+    /**
+     * Collection of actions for this action set.
+     */
+    get actions(): GodotArray { return _C(this, 3691) as GodotArray; }
+    set actions(v: GodotArray) { _C(this, 10425, v); }
+
+    static readonly name = _R(476, OpenXRActionSet);
+}

package/gen/classes/OpenXRAnalogThresholdModifier.ts

@@ -0,0 +1,40 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRActionBindingModifier } from './OpenXRActionBindingModifier.ts';
+import type { OpenXRHapticBase } from './OpenXRHapticBase.ts';
+
+/**
+ * The analog threshold binding modifier can modify a float input to a boolean input with specified thresholds.
+ * See [XR_VALVE_analog_threshold](https://registry.khronos.org/OpenXR/specs/1.1/html/xrspec.html#XR_VALVE_analog_threshold) for in-depth details.
+ */
+export class OpenXRAnalogThresholdModifier extends OpenXRActionBindingModifier {
+    constructor(name = 477) { super(name); }
+
+    /**
+     * When our input value is equal or larger than this value, our output becomes `true`. It stays `true` until it falls under the {@link offThreshold} value.
+     */
+    get onThreshold(): number { return _C(this, 5717) as number; }
+    set onThreshold(v: number) { _C(this, 12184, v); }
+
+    /**
+     * When our input value falls below this, our output becomes `false`.
+     */
+    get offThreshold(): number { return _C(this, 5702) as number; }
+    set offThreshold(v: number) { _C(this, 12169, v); }
+
+    /**
+     * Haptic pulse to emit when the user presses the input.
+     */
+    get onHaptic(): OpenXRHapticBase { return _C(this, 5716) as OpenXRHapticBase; }
+    set onHaptic(v: OpenXRHapticBase) { _C(this, 12183, v); }
+
+    /**
+     * Haptic pulse to emit when the user releases the input.
+     */
+    get offHaptic(): OpenXRHapticBase { return _C(this, 5701) as OpenXRHapticBase; }
+    set offHaptic(v: OpenXRHapticBase) { _C(this, 12168, v); }
+
+    static readonly name = _R(477, OpenXRAnalogThresholdModifier);
+}

package/gen/classes/OpenXRAnchorTracker.ts

@@ -0,0 +1,32 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { OpenXRSpatialEntityTracker } from './OpenXRSpatialEntityTracker.ts';
+import type { Signal } from '../heap-types/index.ts';
+
+/**
+ * Positional tracker for our OpenXR spatial entity anchor extension, it tracks a user defined location in real space and maps it to our virtual space.
+ */
+export class OpenXRAnchorTracker extends OpenXRSpatialEntityTracker {
+    constructor(name = 478) { super(name); }
+
+    /**
+     * Returns `true` if a non-zero UUID is set.
+     */
+    hasUuid(): boolean { return _C(this, 7481) as boolean; }
+
+    /**
+     * The UUID provided for persistent anchors.
+     */
+    get uuid(): string { return _C(this, 7001) as string; }
+    set uuid(v: string) { _C(this, 13250, v); }
+
+    /**
+     * Emitted when the UUID for this anchor was changed.
+     */
+    get uuidChanged(): Signal<() => void> { return _G(this, 14648) as Signal<() => void>; }
+    set uuidChanged(v: (() => void) | null) { _G(this, 14648, v); }
+
+    static readonly name = _R(478, OpenXRAnchorTracker);
+}

package/gen/classes/OpenXRAndroidThreadSettingsExtension.ts

@@ -0,0 +1,43 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRExtensionWrapper } from './OpenXRExtensionWrapper.ts';
+
+/**
+ * For XR to be comfortable, it is important for applications to deliver frames quickly and consistently. In order to make sure the important application threads get their full share of time, these threads must be identified to the system, which will adjust their scheduling priority accordingly.
+ */
+export class OpenXRAndroidThreadSettingsExtension extends OpenXRExtensionWrapper {
+    constructor(name = 479) { super(name); }
+
+    /**
+     * Sets the thread type of the given thread, so that the XR runtime can adjust its scheduling priority accordingly.
+     * `threadId` refers to the OS thread id (ie from `gettid()`). When `threadId` is `0`, it will set the thread type of the current thread.
+     * **NOTE:** The id returned by {@link Thread.getId} is incompatible with `threadId`.
+     */
+    setApplicationThreadType(threadType: ThreadType, threadId?: number /* = 0,  uint32 */): boolean { return _C(this, 10519, threadType, threadId) as boolean; }
+
+    static readonly name = _R(479, OpenXRAndroidThreadSettingsExtension);
+}
+
+export const ThreadType = {
+    /**
+     * Hints to the XR runtime that the thread is doing time critical CPU tasks.
+     */
+    THREAD_TYPE_APPLICATION_MAIN: 0,
+    /**
+     * Hints to the XR runtime that the thread is doing background CPU tasks.
+     */
+    THREAD_TYPE_APPLICATION_WORKER: 1,
+    /**
+     * Hints to the XR runtime that the thread is doing time critical graphics device tasks.
+     */
+    THREAD_TYPE_RENDERER_MAIN: 2,
+    /**
+     * Hints to the XR runtime that the thread is doing background graphics device tasks.
+     */
+    THREAD_TYPE_RENDERER_WORKER: 3,
+} as const;
+
+export type ThreadType = (typeof ThreadType)[keyof typeof ThreadType];
+

package/gen/classes/OpenXRBindingModifier.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { PackedByteArray } from '../heap-types/index.ts';
+
+/**
+ * Binding modifier base class. Subclasses implement various modifiers that alter how an OpenXR runtime processes inputs.
+ */
+export class OpenXRBindingModifier extends Resource {
+
+    static readonly name = _R(480, OpenXRBindingModifier);
+}

package/gen/classes/OpenXRCompositionLayer.ts

@@ -0,0 +1,275 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { Color, Vector2, Vector2i, Vector3 } from '../value-types/index.ts';
+import type { JavaObject } from './JavaObject.ts';
+import type { SubViewport } from './SubViewport.ts';
+
+/**
+ * Composition layers allow 2D viewports to be displayed inside of the headset by the XR compositor through special projections that retain their quality. This allows for rendering clear text while keeping the layer at a native resolution.
+ * **Note:** If the OpenXR runtime doesn't support the given composition layer type, a fallback mesh can be generated with a {@link ViewportTexture}, in order to emulate the composition layer.
+ */
+export class OpenXRCompositionLayer extends Node3D {
+
+    /**
+     * Returns a {@link JavaObject} representing an `android.view.Surface` if {@link useAndroidSurface} is enabled and OpenXR has created the surface. Otherwise, this will return `null`.
+     * **Note:** The surface can only be created during an active OpenXR session. So, if {@link useAndroidSurface} is enabled outside of an OpenXR session, it won't be created until a new session fully starts.
+     */
+    getAndroidSurface(): JavaObject { return _C(this, 3747) as JavaObject; }
+
+    /**
+     * Returns `true` if the OpenXR runtime natively supports this composition layer type.
+     * **Note:** This will only return an accurate result after the OpenXR session has started.
+     */
+    isNativelySupported(): boolean { return _C(this, 8127) as boolean; }
+
+    /**
+     * Returns UV coordinates where the given ray intersects with the composition layer. `origin` and `direction` must be in global space.
+     * Returns `Vector2(-1.0, -1.0)` if the ray doesn't intersect.
+     */
+    intersectsRay(origin: Vector3, direction: Vector3): Vector2 { return _C(this, 7709, origin, direction) as Vector2; }
+
+    /**
+     * The {@link SubViewport} to render on the composition layer.
+     */
+    get layerViewport(): SubViewport { return _C(this, 5323) as SubViewport; }
+    set layerViewport(v: SubViewport) { _C(this, 11884, v); }
+
+    /**
+     * If enabled, an Android surface will be created (with the dimensions from {@link androidSurfaceSize}) which will provide the 2D content for the composition layer, rather than using {@link layerViewport}.
+     * See {@link getAndroidSurface} for information about how to get the surface so that your application can draw to it.
+     * **Note:** This will only work in Android builds.
+     */
+    get useAndroidSurface(): boolean { return _C(this, 6971) as boolean; }
+    set useAndroidSurface(v: boolean) { _C(this, 13194, v); }
+
+    /**
+     * If enabled, the OpenXR swapchain will be created with the `XR_SWAPCHAIN_CREATE_PROTECTED_CONTENT_BIT` flag, which will protect its contents from CPU access.
+     * When used with an Android Surface, this may allow DRM content to be presented, and will only take effect when the Surface is first created; later changes to this property will have no effect.
+     */
+    get protectedContent(): boolean { return _C(this, 8213) as boolean; }
+    set protectedContent(v: boolean) { _C(this, 12446, v); }
+
+    /**
+     * The size of the Android surface to create if {@link useAndroidSurface} is enabled.
+     */
+    get androidSurfaceSize(): Vector2i { return _C(this, 3748) as Vector2i; }
+    set androidSurfaceSize(v: Vector2i) { _C(this, 10491, v); }
+
+    /**
+     * The sort order for this composition layer. Higher numbers will be shown in front of lower numbers.
+     * **Note:** This will have no effect if a fallback mesh is being used.
+     */
+    get sortOrder(): number { return _C(this, 6452) as number; }
+    set sortOrder(v: number) { _C(this, 12809, v); }
+
+    /**
+     * Enables the blending the layer using its alpha channel.
+     * Can be combined with {@link Viewport.transparentBg} to give the layer a transparent background.
+     */
+    get alphaBlend(): boolean { return _C(this, 3724) as boolean; }
+    set alphaBlend(v: boolean) { _C(this, 10465, v); }
+
+    /**
+     * Enables a technique called "hole punching", which allows putting the composition layer behind the main projection layer (i.e. setting {@link sortOrder} to a negative value) while "punching a hole" through everything rendered by Godot so that the layer is still visible.
+     * This can be used to create the illusion that the composition layer exists in the same 3D space as everything rendered by Godot, allowing objects to appear to pass both behind or in front of the composition layer.
+     */
+    get enableHolePunch(): boolean { return _C(this, 4650) as boolean; }
+    set enableHolePunch(v: boolean) { _C(this, 11277, v); }
+
+    /**
+     * The eye(s) the composition layer is visible to.
+     * **Note:** Not all composition layer types or runtimes support restricting visibility to a single eye.
+     */
+    get eyeVisibility(): EyeVisibility { return _C(this, 4723) as EyeVisibility; }
+    set eyeVisibility(v: EyeVisibility) { _C(this, 11343, v); }
+
+    /**
+     * The minification filter of the swapchain state.
+     * **Note:** This property only has an effect on devices that support the OpenXR XR_FB_swapchain_update_state OpenGLES/Vulkan extensions.
+     */
+    get swapchainStateMinFilter(): Filter { return _C(this, 5540) as Filter; }
+    set swapchainStateMinFilter(v: Filter) { _C(this, 12051, v); }
+
+    /**
+     * The magnification filter of the swapchain state.
+     * **Note:** This property only has an effect on devices that support the OpenXR XR_FB_swapchain_update_state OpenGLES/Vulkan extensions.
+     */
+    get swapchainStateMagFilter(): Filter { return _C(this, 5428) as Filter; }
+    set swapchainStateMagFilter(v: Filter) { _C(this, 11960, v); }
+
+    /**
+     * The mipmap mode of the swapchain state.
+     * **Note:** This property only has an effect on devices that support the OpenXR XR_FB_swapchain_update_state OpenGLES/Vulkan extensions.
+     */
+    get swapchainStateMipmapMode(): MipmapMode { return _C(this, 5559) as MipmapMode; }
+    set swapchainStateMipmapMode(v: MipmapMode) { _C(this, 12065, v); }
+
+    /**
+     * The horizontal wrap mode of the swapchain state.
+     * **Note:** This property only has an effect on devices that support the OpenXR XR_FB_swapchain_update_state OpenGLES/Vulkan extensions.
+     */
+    get swapchainStateHorizontalWrap(): Wrap { return _C(this, 5047) as Wrap; }
+    set swapchainStateHorizontalWrap(v: Wrap) { _C(this, 11641, v); }
+
+    /**
+     * The vertical wrap mode of the swapchain state.
+     * **Note:** This property only has an effect on devices that support the OpenXR XR_FB_swapchain_update_state OpenGLES/Vulkan extensions.
+     */
+    get swapchainStateVerticalWrap(): Wrap { return _C(this, 7067) as Wrap; }
+    set swapchainStateVerticalWrap(v: Wrap) { _C(this, 13307, v); }
+
+    /**
+     * The swizzle value for the red channel of the swapchain state.
+     * **Note:** This property only has an effect on devices that support the OpenXR XR_FB_swapchain_update_state OpenGLES/Vulkan extensions.
+     */
+    get swapchainStateRedSwizzle(): Swizzle { return _C(this, 6094) as Swizzle; }
+    set swapchainStateRedSwizzle(v: Swizzle) { _C(this, 12490, v); }
+
+    /**
+     * The swizzle value for the green channel of the swapchain state.
+     * **Note:** This property only has an effect on devices that support the OpenXR XR_FB_swapchain_update_state OpenGLES/Vulkan extensions.
+     */
+    get swapchainStateGreenSwizzle(): Swizzle { return _C(this, 4978) as Swizzle; }
+    set swapchainStateGreenSwizzle(v: Swizzle) { _C(this, 11561, v); }
+
+    /**
+     * The swizzle value for the blue channel of the swapchain state.
+     * **Note:** This property only has an effect on devices that support the OpenXR XR_FB_swapchain_update_state OpenGLES/Vulkan extensions.
+     */
+    get swapchainStateBlueSwizzle(): Swizzle { return _C(this, 3945) as Swizzle; }
+    set swapchainStateBlueSwizzle(v: Swizzle) { _C(this, 10691, v); }
+
+    /**
+     * The swizzle value for the alpha channel of the swapchain state.
+     * **Note:** This property only has an effect on devices that support the OpenXR XR_FB_swapchain_update_state OpenGLES/Vulkan extensions.
+     */
+    get swapchainStateAlphaSwizzle(): Swizzle { return _C(this, 3730) as Swizzle; }
+    set swapchainStateAlphaSwizzle(v: Swizzle) { _C(this, 10471, v); }
+
+    /**
+     * The max anisotropy of the swapchain state.
+     * **Note:** This property only has an effect on devices that support the OpenXR XR_FB_swapchain_update_state OpenGLES/Vulkan extensions.
+     */
+    get swapchainStateMaxAnisotropy(): number { return _C(this, 5458) as number; }
+    set swapchainStateMaxAnisotropy(v: number) { _C(this, 11984, v); }
+
+    /**
+     * The border color of the swapchain state that is used when the wrap mode clamps to the border.
+     * **Note:** This property only has an effect on devices that support the OpenXR XR_FB_swapchain_update_state OpenGLES/Vulkan extensions.
+     */
+    get swapchainStateBorderColor(): Color { return _C(this, 3986) as Color; }
+    set swapchainStateBorderColor(v: Color) { _C(this, 10726, v); }
+
+    static readonly name = _R(481, OpenXRCompositionLayer);
+}
+
+export const Filter = {
+    /**
+     * Perform nearest-neighbor filtering when sampling the texture.
+     */
+    FILTER_NEAREST: 0,
+    /**
+     * Perform linear filtering when sampling the texture.
+     */
+    FILTER_LINEAR: 1,
+    /**
+     * Perform cubic filtering when sampling the texture.
+     */
+    FILTER_CUBIC: 2,
+} as const;
+
+export type Filter = (typeof Filter)[keyof typeof Filter];
+
+export const MipmapMode = {
+    /**
+     * Disable mipmapping.
+     * **Note:** Mipmapping can only be disabled in the Compatibility renderer.
+     */
+    MIPMAP_MODE_DISABLED: 0,
+    /**
+     * Use the mipmap of the nearest resolution.
+     */
+    MIPMAP_MODE_NEAREST: 1,
+    /**
+     * Use linear interpolation of the two mipmaps of the nearest resolution.
+     */
+    MIPMAP_MODE_LINEAR: 2,
+} as const;
+
+export type MipmapMode = (typeof MipmapMode)[keyof typeof MipmapMode];
+
+export const Wrap = {
+    /**
+     * Clamp the texture to its specified border color.
+     */
+    WRAP_CLAMP_TO_BORDER: 0,
+    /**
+     * Clamp the texture to its edge color.
+     */
+    WRAP_CLAMP_TO_EDGE: 1,
+    /**
+     * Repeat the texture infinitely.
+     */
+    WRAP_REPEAT: 2,
+    /**
+     * Repeat the texture infinitely, mirroring it on each repeat.
+     */
+    WRAP_MIRRORED_REPEAT: 3,
+    /**
+     * Mirror the texture once and then clamp the texture to its edge color.
+     * **Note:** This wrap mode is not available in the Compatibility renderer.
+     */
+    WRAP_MIRROR_CLAMP_TO_EDGE: 4,
+} as const;
+
+export type Wrap = (typeof Wrap)[keyof typeof Wrap];
+
+export const Swizzle = {
+    /**
+     * Maps a color channel to the value of the red channel.
+     */
+    SWIZZLE_RED: 0,
+    /**
+     * Maps a color channel to the value of the green channel.
+     */
+    SWIZZLE_GREEN: 1,
+    /**
+     * Maps a color channel to the value of the blue channel.
+     */
+    SWIZZLE_BLUE: 2,
+    /**
+     * Maps a color channel to the value of the alpha channel.
+     */
+    SWIZZLE_ALPHA: 3,
+    /**
+     * Maps a color channel to the value of zero.
+     */
+    SWIZZLE_ZERO: 4,
+    /**
+     * Maps a color channel to the value of one.
+     */
+    SWIZZLE_ONE: 5,
+} as const;
+
+export type Swizzle = (typeof Swizzle)[keyof typeof Swizzle];
+
+export const EyeVisibility = {
+    /**
+     * The layer is visible to both the left and right eyes.
+     */
+    EYE_VISIBILITY_BOTH: 0,
+    /**
+     * The layer is visible only to the left eye.
+     */
+    EYE_VISIBILITY_LEFT: 1,
+    /**
+     * The layer is visible only to the right eye.
+     */
+    EYE_VISIBILITY_RIGHT: 2,
+} as const;
+
+export type EyeVisibility = (typeof EyeVisibility)[keyof typeof EyeVisibility];
+

package/gen/classes/OpenXRCompositionLayerCylinder.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 { OpenXRCompositionLayer } from './OpenXRCompositionLayer.ts';
+
+/**
+ * An OpenXR composition layer that allows rendering a {@link SubViewport} on an internal slice of a cylinder.
+ */
+export class OpenXRCompositionLayerCylinder extends OpenXRCompositionLayer {
+    constructor(name = 482) { super(name); }
+
+    /**
+     * The radius of the cylinder.
+     */
+    get radius(): number { return _C(this, 6068) as number; }
+    set radius(v: number) { _C(this, 12467, v); }
+
+    /**
+     * The aspect ratio of the slice. Used to set the height relative to the width.
+     */
+    get aspectRatio(): number { return _C(this, 3801) as number; }
+    set aspectRatio(v: number) { _C(this, 10544, v); }
+
+    /**
+     * The central angle of the cylinder. Used to set the width.
+     */
+    get centralAngle(): number { return _C(this, 4135) as number; }
+    set centralAngle(v: number) { _C(this, 10848, v); }
+
+    /**
+     * The number of segments to use in the fallback mesh.
+     */
+    get fallbackSegments(): number { return _C(this, 4755) as number; }
+    set fallbackSegments(v: number) { _C(this, 11366, v); }
+
+    static readonly name = _R(482, OpenXRCompositionLayerCylinder);
+}

package/gen/classes/OpenXRCompositionLayerEquirect.ts

@@ -0,0 +1,44 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRCompositionLayer } from './OpenXRCompositionLayer.ts';
+
+/**
+ * An OpenXR composition layer that allows rendering a {@link SubViewport} on an internal slice of a sphere.
+ */
+export class OpenXRCompositionLayerEquirect extends OpenXRCompositionLayer {
+    constructor(name = 483) { super(name); }
+
+    /**
+     * The radius of the sphere.
+     */
+    get radius(): number { return _C(this, 6068) as number; }
+    set radius(v: number) { _C(this, 12467, v); }
+
+    /**
+     * The central horizontal angle of the sphere. Used to set the width.
+     */
+    get centralHorizontalAngle(): number { return _C(this, 4136) as number; }
+    set centralHorizontalAngle(v: number) { _C(this, 10849, v); }
+
+    /**
+     * The upper vertical angle of the sphere. Used (together with {@link lowerVerticalAngle}) to set the height.
+     */
+    get upperVerticalAngle(): number { return _C(this, 6966) as number; }
+    set upperVerticalAngle(v: number) { _C(this, 13186, v); }
+
+    /**
+     * The lower vertical angle of the sphere. Used (together with {@link upperVerticalAngle}) to set the height.
+     */
+    get lowerVerticalAngle(): number { return _C(this, 5426) as number; }
+    set lowerVerticalAngle(v: number) { _C(this, 11959, v); }
+
+    /**
+     * The number of segments to use in the fallback mesh.
+     */
+    get fallbackSegments(): number { return _C(this, 4755) as number; }
+    set fallbackSegments(v: number) { _C(this, 11366, v); }
+
+    static readonly name = _R(483, OpenXRCompositionLayerEquirect);
+}

package/gen/classes/OpenXRCompositionLayerQuad.ts

@@ -0,0 +1,21 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRCompositionLayer } from './OpenXRCompositionLayer.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * An OpenXR composition layer that allows rendering a {@link SubViewport} on a quad.
+ */
+export class OpenXRCompositionLayerQuad extends OpenXRCompositionLayer {
+    constructor(name = 484) { super(name); }
+
+    /**
+     * The dimensions of the quad.
+     */
+    get quadSize(): Vector2 { return _C(this, 6059) as Vector2; }
+    set quadSize(v: Vector2) { _C(this, 12458, v); }
+
+    static readonly name = _R(484, OpenXRCompositionLayerQuad);
+}