@ringozz/godot 0.1.0

package/gen/classes/OpenXRRenderModel.ts

@@ -0,0 +1,33 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { RID, Signal } from '../heap-types/index.ts';
+
+/**
+ * This node will display an OpenXR render model by accessing the associated GLTF and processes all animation data (if supported by the XR runtime).
+ * Render models were introduced to allow showing the correct model for the controller (or other device) the user has in hand, since the OpenXR action map does not provide information about the hardware used by the user. Note that while the controller (or device) can be somewhat inferred by the bound action map profile, this is a dangerous approach as the user may be using hardware not known at time of development and OpenXR will simply simulate an available interaction profile.
+ */
+export class OpenXRRenderModel extends Node3D {
+    constructor(name = 501) { super(name); }
+
+    /**
+     * Returns the top level path related to this render model.
+     */
+    getTopLevelPath(): string { return _C(this, 6846) as string; }
+
+    /**
+     * The render model RID for the render model to load, as returned by {@link OpenXRRenderModelExtension.renderModelCreate} or {@link OpenXRRenderModelExtension.renderModelGetAll}.
+     */
+    get renderModel(): RID { return _C(this, 6130) as RID; }
+    set renderModel(v: RID) { _C(this, 12519, v); }
+
+    /**
+     * Emitted when the top level path of this render model has changed.
+     */
+    get renderModelTopLevelPathChanged(): Signal<() => void> { return _G(this, 10023) as Signal<() => void>; }
+    set renderModelTopLevelPathChanged(v: (() => void) | null) { _G(this, 10023, v); }
+
+    static readonly name = _R(501, OpenXRRenderModel);
+}

package/gen/classes/OpenXRRenderModelExtension.ts

@@ -0,0 +1,105 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { OpenXRExtensionWrapper } from './OpenXRExtensionWrapper.ts';
+import type { GodotArray, PackedStringArray, RID, Signal } from '../heap-types/index.ts';
+import type { Transform3D } from '../value-types/index.ts';
+import type { Node3D } from './Node3D.ts';
+import type { TrackingConfidence } from './XRPose.ts';
+
+/**
+ * This class implements the OpenXR Render Model Extension, if enabled it will maintain a list of active render models and provides an interface to the render model data.
+ */
+export class OpenXRRenderModelExtension extends OpenXRExtensionWrapper {
+    constructor(name = 502) { super(name); }
+
+    /**
+     * Returns `true` if OpenXR's render model extension is supported and enabled.
+     * **Note:** This only returns a valid value after OpenXR has been initialized.
+     */
+    isActive(): boolean { return _C(this, 7746) as boolean; }
+
+    /**
+     * Creates a render model object within OpenXR using a render model id.
+     * **Note:** This function is exposed for dependent OpenXR extensions that provide render model ids to be used with the render model extension.
+     */
+    renderModelCreate(renderModelId: number /* uint64 */): RID { return _C(this, 10010, renderModelId) as RID; }
+
+    /**
+     * Destroys a render model object within OpenXR that was previously created with {@link renderModelCreate}.
+     * **Note:** This function is exposed for dependent OpenXR extensions that provide render model ids to be used with the render model extension.
+     */
+    renderModelDestroy(renderModel: RID): void { _C(this, 10011, renderModel); }
+
+    /**
+     * Returns an array of all currently active render models registered with this extension.
+     */
+    renderModelGetAll(): GodotArray<RID> { return _C(this, 10012) as GodotArray<RID>; }
+
+    /**
+     * Returns an instance of a subscene that contains all {@link MeshInstance3D} nodes that allow you to visualize the render model.
+     */
+    renderModelNewSceneInstance(renderModel: RID): Node3D { return _C(this, 10021, renderModel) as Node3D; }
+
+    /**
+     * Returns a list of active subaction paths for this `renderModel`.
+     * **Note:** If different devices are bound to your actions than available in suggested interaction bindings, this information shows paths related to the interaction bindings being mimicked by that device.
+     */
+    renderModelGetSubactionPaths(renderModel: RID): PackedStringArray { return _C(this, 10018, renderModel) as PackedStringArray; }
+
+    /**
+     * Returns the top level path associated with this `renderModel`. If provided this identifies whether the render model is associated with the player's hands or other body part.
+     */
+    renderModelGetTopLevelPath(renderModel: RID): string { return _C(this, 10019, renderModel) as string; }
+
+    /**
+     * Returns the tracking confidence of the tracking data for the render model.
+     */
+    renderModelGetConfidence(renderModel: RID): TrackingConfidence { return _C(this, 10016, renderModel) as TrackingConfidence; }
+
+    /**
+     * Returns the root transform of a render model. This is the tracked position relative to our {@link XROrigin3D} node.
+     */
+    renderModelGetRootTransform(renderModel: RID): Transform3D { return _C(this, 10017, renderModel) as Transform3D; }
+
+    /**
+     * Returns the number of animatable nodes this render model has.
+     */
+    renderModelGetAnimatableNodeCount(renderModel: RID): number { return _C(this, 10013, renderModel) as number; }
+
+    /**
+     * Returns the name of the given animatable node.
+     */
+    renderModelGetAnimatableNodeName(renderModel: RID, index: number /* uint32 */): string { return _C(this, 10014, renderModel, index) as string; }
+
+    /**
+     * Returns `true` if this animatable node should be visible.
+     */
+    renderModelIsAnimatableNodeVisible(renderModel: RID, index: number /* uint32 */): boolean { return _C(this, 10020, renderModel, index) as boolean; }
+
+    /**
+     * Returns the current local transform for an animatable node. This is updated every frame.
+     */
+    renderModelGetAnimatableNodeTransform(renderModel: RID, index: number /* uint32 */): Transform3D { return _C(this, 10015, renderModel, index) as Transform3D; }
+
+    /**
+     * Emitted when a new render model is added.
+     */
+    get renderModelAdded(): Signal<(renderModel: RID) => void> { return _G(this, 10009) as Signal<(renderModel: RID) => void>; }
+    set renderModelAdded(v: ((renderModel: RID) => void) | null) { _G(this, 10009, v); }
+
+    /**
+     * Emitted when a render model is removed.
+     */
+    get renderModelRemoved(): Signal<(renderModel: RID) => void> { return _G(this, 10022) as Signal<(renderModel: RID) => void>; }
+    set renderModelRemoved(v: ((renderModel: RID) => void) | null) { _G(this, 10022, v); }
+
+    /**
+     * Emitted when the top level path associated with a render model changed.
+     */
+    get renderModelTopLevelPathChanged(): Signal<(renderModel: RID) => void> { return _G(this, 10023) as Signal<(renderModel: RID) => void>; }
+    set renderModelTopLevelPathChanged(v: ((renderModel: RID) => void) | null) { _G(this, 10023, v); }
+
+    static readonly name = _R(502, OpenXRRenderModelExtension);
+}

package/gen/classes/OpenXRRenderModelManager.ts

@@ -0,0 +1,63 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { Signal } from '../heap-types/index.ts';
+import type { OpenXRRenderModel } from './OpenXRRenderModel.ts';
+
+/**
+ * This helper node will automatically manage displaying render models. It will create new {@link OpenXRRenderModel} nodes as controllers and other hand held devices are detected, and remove those nodes when they are deactivated.
+ * **Note:** If you want more control over this logic you can alternatively call {@link OpenXRRenderModelExtension.renderModelGetAll} to obtain a list of active render model ids and create {@link OpenXRRenderModel} instances for each render model id provided.
+ */
+export class OpenXRRenderModelManager extends Node3D {
+    constructor(name = 503) { super(name); }
+
+    /**
+     * Limits render models to the specified tracker. Include: 0 = All render models, 1 = Render models not related to a tracker, 2 = Render models related to the left hand tracker, 3 = Render models related to the right hand tracker.
+     */
+    get tracker(): RenderModelTracker { return _C(this, 6860) as RenderModelTracker; }
+    set tracker(v: RenderModelTracker) { _C(this, 13120, v); }
+
+    /**
+     * Position render models local to this pose (this will adjust the position of the render models container node).
+     */
+    get makeLocalToPose(): string { return _C(this, 5435) as string; }
+    set makeLocalToPose(v: string) { _C(this, 11964, v); }
+
+    /**
+     * Emitted when a render model node is added as a child to this node.
+     */
+    get renderModelAdded(): Signal<(renderModel: OpenXRRenderModel) => void> { return _G(this, 10009) as Signal<(renderModel: OpenXRRenderModel) => void>; }
+    set renderModelAdded(v: ((renderModel: OpenXRRenderModel) => void) | null) { _G(this, 10009, v); }
+
+    /**
+     * Emitted when a render model child node is about to be removed from this node.
+     */
+    get renderModelRemoved(): Signal<(renderModel: OpenXRRenderModel) => void> { return _G(this, 10022) as Signal<(renderModel: OpenXRRenderModel) => void>; }
+    set renderModelRemoved(v: ((renderModel: OpenXRRenderModel) => void) | null) { _G(this, 10022, v); }
+
+    static readonly name = _R(503, OpenXRRenderModelManager);
+}
+
+export const RenderModelTracker = {
+    /**
+     * All active render models are shown regardless of what tracker they relate to.
+     */
+    RENDER_MODEL_TRACKER_ANY: 0,
+    /**
+     * Only active render models are shown that are not related to any tracker we manage.
+     */
+    RENDER_MODEL_TRACKER_NONE_SET: 1,
+    /**
+     * Only active render models are shown that are related to the left hand tracker.
+     */
+    RENDER_MODEL_TRACKER_LEFT_HAND: 2,
+    /**
+     * Only active render models are shown that are related to the right hand tracker.
+     */
+    RENDER_MODEL_TRACKER_RIGHT_HAND: 3,
+} as const;
+
+export type RenderModelTracker = (typeof RenderModelTracker)[keyof typeof RenderModelTracker];
+

package/gen/classes/OpenXRSpatialAnchorCapability.ts

@@ -0,0 +1,114 @@
+// 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';
+import type { Callable, GodotArray, RID } from '../heap-types/index.ts';
+import type { Transform3D } from '../value-types/index.ts';
+import type { OpenXRAnchorTracker } from './OpenXRAnchorTracker.ts';
+import type { OpenXRFutureResult } from './OpenXRFutureResult.ts';
+import type { OpenXRSpatialComponentData } from './OpenXRSpatialComponentData.ts';
+import type { OpenXRStructureBase } from './OpenXRStructureBase.ts';
+
+/**
+ * This is an internal class that handles the OpenXR anchor spatial entity extension.
+ */
+export class OpenXRSpatialAnchorCapability extends OpenXRExtensionWrapper {
+    constructor(name = 504) { super(name); }
+
+    /**
+     * Returns `true` if spatial anchors are supported by the hardware. Only returns a valid value after OpenXR has been initialized.
+     */
+    isSpatialAnchorSupported(): boolean { return _C(this, 8331) as boolean; }
+
+    /**
+     * Returns `true` if persistent spatial anchors are supported by the hardware. Only returns a valid value after OpenXR has been initialized.
+     */
+    isSpatialPersistenceSupported(): boolean { return _C(this, 8332) as boolean; }
+
+    /**
+     * Returns `true` if this persistence scope is supported by our spatial anchor capability.
+     * **Note:** Only valid after an OpenXR instance has been created.
+     */
+    isPersistenceScopeSupported(scope: PersistenceScope): boolean { return _C(this, 8174, scope) as boolean; }
+
+    /**
+     * Calls {@link createPersistenceContext} with a configuration that likely works with the XR runtime.
+     * `userCallback` is called when the context is created.
+     */
+    createDefaultPersistenceContext(userCallback?: Callable /* = Callable() */): OpenXRFutureResult { return _C(this, 2520, userCallback) as OpenXRFutureResult; }
+
+    /**
+     * Creates a new persistence context for storing persistent data.
+     * **Note:** This is an asynchronous method and returns an {@link OpenXRFutureResult} object with which to track the status, discarding this object will not cancel the creation process. On success `userCallback` will be called if specified. The result value for this function is the {@link RID} for our persistence context.
+     */
+    createPersistenceContext(scope: PersistenceScope, userCallback?: Callable /* = Callable() */): OpenXRFutureResult { return _C(this, 2560, scope, userCallback) as OpenXRFutureResult; }
+
+    /**
+     * Returns the internal handle for this persistence context.
+     * **Note:** For GDExtension implementations.
+     */
+    getPersistenceContextHandle(persistenceContext: RID): number { return _C(this, 5877, persistenceContext) as number; }
+
+    /**
+     * Frees a persistence context previously created with {@link createPersistenceContext}.
+     */
+    freePersistenceContext(persistenceContext: RID): void { _C(this, 3582, persistenceContext); }
+
+    /**
+     * Creates a new anchor that will be tracked by the XR runtime. The `transform` should be a transform in the local space of your {@link XROrigin3D} node. If `spatialContext` is not specified the default will be used, this requires {@link ProjectSettings.xr/openxr/extensions/spatialEntity/enableBuiltinAnchorDetection} to be set. The returned tracker will track the location in case our reference space changes.
+     * `next` must be a valid next object for the `XrSpatialAnchorCreateInfoEXT` chain.
+     */
+    createNewAnchor(transform: Transform3D, spatialContext?: RID /* = RID() */, next?: OpenXRStructureBase /* = null */): OpenXRAnchorTracker { return _C(this, 2554, transform, spatialContext, next) as OpenXRAnchorTracker; }
+
+    /**
+     * Remove an anchor previously created with {@link createNewAnchor}. If this anchor was persistent you must first call {@link unpersistAnchor} and await its callback.
+     */
+    removeAnchor(anchorTracker: OpenXRAnchorTracker): void { _C(this, 9883, anchorTracker); }
+
+    /**
+     * Changes this anchor into a persistent anchor. This means its location will be stored on the device and the anchor will be restored the next time your application starts. If `persistenceContext` is not specified the default will be used, this requires {@link ProjectSettings.xr/openxr/extensions/spatialEntity/enableBuiltinAnchorDetection} to be set.
+     * **Note:** This is an asynchronous method and returns an {@link OpenXRFutureResult} object with which to track the status, discarding this object will not cancel the creation process. On success `userCallback` will be called if specified. The result value for this function is a boolean which will be set to `true` on successful completion.
+     */
+    persistAnchor(anchorTracker: OpenXRAnchorTracker, persistenceContext?: RID /* = RID() */, userCallback?: Callable /* = Callable() */): OpenXRFutureResult { return _C(this, 9396, anchorTracker, persistenceContext, userCallback) as OpenXRFutureResult; }
+
+    /**
+     * Removes the persistent data from this anchor. The runtime will not recreate the anchor when your application restarts. If `persistenceContext` is not specified the default will be used, this requires {@link ProjectSettings.xr/openxr/extensions/spatialEntity/enabled} to be set.
+     * **Note:** This is an asynchronous method and returns an {@link OpenXRFutureResult} object with which to track the status, discarding this object will not cancel the creation process. On success `userCallback` will be called if specified. The result value for this function is a boolean which will be set to `true` on successful completion.
+     */
+    unpersistAnchor(anchorTracker: OpenXRAnchorTracker, persistenceContext?: RID /* = RID() */, userCallback?: Callable /* = Callable() */): OpenXRFutureResult { return _C(this, 14484, anchorTracker, persistenceContext, userCallback) as OpenXRFutureResult; }
+
+    /**
+     * Calls {@link OpenXRSpatialEntityExtension.discoverSpatialEntities} and {@link OpenXRSpatialEntityExtension.querySnapshot} with the anchor entities associated with `spatialContext`.
+     * `componentData` are the {@link OpenXRSpatialComponentData}s to discover for this anchor capability.
+     * If `nextSnapshotCreate` is non-null, then pass this to the `next` parameter in {@link OpenXRSpatialEntityExtension.discoverSpatialEntities}.
+     * If `nextSnapshotQuery` is non-null, then pass this to the `next` parameter in {@link OpenXRSpatialEntityExtension.querySnapshot}.
+     * `userCallback`, when non-null, is called with two parameters usually twice. The first parameter is the {@link RID} of the discovery snapshot and the second parameter is a boolean where `false` indicates the discovery snapshot is about to be processed, and `true` indicates the discovery snapshot has been processed and `componentData` has valid data. The second call is skipped if an error was encountered.
+     * The returned {@link OpenXRFutureResult} is identical to the return from {@link OpenXRSpatialEntityExtension.discoverSpatialEntities}.
+     */
+    startEntityDiscovery(spatialContext: RID, componentData: GodotArray<OpenXRSpatialComponentData>, nextSnapshotCreate?: OpenXRStructureBase /* = null */, nextSnapshotQuery?: OpenXRStructureBase /* = null */, userCallback?: Callable /* = Callable() */): OpenXRFutureResult { return _C(this, 13834, spatialContext, componentData, nextSnapshotCreate, nextSnapshotQuery, userCallback) as OpenXRFutureResult; }
+
+    /**
+     * Calls {@link OpenXRSpatialEntityExtension.updateSpatialEntities} and {@link OpenXRSpatialEntityExtension.querySnapshot} with the anchor entities associated with `spatialContext`.
+     * `componentData` are the {@link OpenXRSpatialComponentData}s to update for this anchor capability.
+     * If `nextSnapshotCreate` is non-null, then pass this to the `next` parameter in {@link OpenXRSpatialEntityExtension.updateSpatialEntities}.
+     * If `nextSnapshotQuery` is non-null, then pass this to the `next` parameter in {@link OpenXRSpatialEntityExtension.querySnapshot}.
+     */
+    doEntityUpdate(spatialContext: RID, componentData: GodotArray<OpenXRSpatialComponentData>, nextSnapshotCreate?: OpenXRStructureBase /* = null */, nextSnapshotQuery?: OpenXRStructureBase /* = null */): void { _C(this, 2852, spatialContext, componentData, nextSnapshotCreate, nextSnapshotQuery); }
+
+    static readonly name = _R(504, OpenXRSpatialAnchorCapability);
+}
+
+export const PersistenceScope = {
+    /**
+     * Provides the application with read-only access (i.e. application cannot modify this scope) to spatial entities persisted and managed by the system. The application can use the UUID in the persistence component for this scope to correlate entities across spatial contexts and device reboots.
+     */
+    PERSISTENCE_SCOPE_SYSTEM_MANAGED: 1,
+    /**
+     * Persistence operations and data access is limited to spatial anchors, on the same device, for the same user and same app (using {@link persistAnchor} and {@link unpersistAnchor} functions)
+     */
+    PERSISTENCE_SCOPE_LOCAL_ANCHORS: 1000781000,
+} as const;
+
+export type PersistenceScope = (typeof PersistenceScope)[keyof typeof PersistenceScope];
+

package/gen/classes/OpenXRSpatialCapabilityConfigurationAnchor.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 { OpenXRSpatialCapabilityConfigurationBaseHeader } from './OpenXRSpatialCapabilityConfigurationBaseHeader.ts';
+import type { PackedInt64Array } from '../heap-types/index.ts';
+
+/**
+ * Configuration header for spatial anchors. Pass this to {@link OpenXRSpatialEntityExtension.createSpatialContext} to create a spatial context with spatial anchor capabilities.
+ */
+export class OpenXRSpatialCapabilityConfigurationAnchor extends OpenXRSpatialCapabilityConfigurationBaseHeader {
+    constructor(name = 505) { super(name); }
+
+    /**
+     * Returns the components enabled by this configuration.
+     * **Note:** Only valid after this configuration was used to create a spatial context.
+     */
+    getEnabledComponents(): PackedInt64Array { return _C(this, 4657) as PackedInt64Array; }
+
+    static readonly name = _R(505, OpenXRSpatialCapabilityConfigurationAnchor);
+}

package/gen/classes/OpenXRSpatialCapabilityConfigurationAprilTag.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 { OpenXRSpatialCapabilityConfigurationBaseHeader } from './OpenXRSpatialCapabilityConfigurationBaseHeader.ts';
+import type { PackedInt64Array } from '../heap-types/index.ts';
+
+/**
+ * Configuration header for April tag markers. Pass this to {@link OpenXRSpatialEntityExtension.createSpatialContext} to create a spatial context that can detect April tags.
+ */
+export class OpenXRSpatialCapabilityConfigurationAprilTag extends OpenXRSpatialCapabilityConfigurationBaseHeader {
+    constructor(name = 506) { super(name); }
+
+    /**
+     * Returns the components enabled by this configuration.
+     * **Note:** Only valid after this configuration was used to create a spatial context.
+     */
+    getEnabledComponents(): PackedInt64Array { return _C(this, 4657) as PackedInt64Array; }
+
+    /**
+     * Dictionary to use to decode April tags.
+     * **Note:** Must be set before using this configuration to create a spatial context.
+     */
+    get aprilDict(): AprilTagDict { return _C(this, 3787) as AprilTagDict; }
+    set aprilDict(v: AprilTagDict) { _C(this, 10526, v); }
+
+    static readonly name = _R(506, OpenXRSpatialCapabilityConfigurationAprilTag);
+}
+
+export const AprilTagDict = {
+    /**
+     * 4 by 4 bits, minimum Hamming distance between any two codes = 5, 30 codes.
+     */
+    APRIL_TAG_DICT_16H5: 1,
+    /**
+     * 5 by 5 bits, minimum Hamming distance between any two codes = 9, 35 codes.
+     */
+    APRIL_TAG_DICT_25H9: 2,
+    /**
+     * 6 by 6 bits, minimum Hamming distance between any two codes = 10, 2320 codes.
+     */
+    APRIL_TAG_DICT_36H10: 3,
+    /**
+     * 6 by 6 bits, minimum Hamming distance between any two codes = 11, 587 codes.
+     */
+    APRIL_TAG_DICT_36H11: 4,
+} as const;
+
+export type AprilTagDict = (typeof AprilTagDict)[keyof typeof AprilTagDict];
+

package/gen/classes/OpenXRSpatialCapabilityConfigurationAruco.ts

@@ -0,0 +1,98 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRSpatialCapabilityConfigurationBaseHeader } from './OpenXRSpatialCapabilityConfigurationBaseHeader.ts';
+import type { PackedInt64Array } from '../heap-types/index.ts';
+
+/**
+ * Configuration header for Aruco markers. Pass this to {@link OpenXRSpatialEntityExtension.createSpatialContext} to create a spatial context that can detect Aruco markers.
+ */
+export class OpenXRSpatialCapabilityConfigurationAruco extends OpenXRSpatialCapabilityConfigurationBaseHeader {
+    constructor(name = 507) { super(name); }
+
+    /**
+     * Returns the components enabled by this configuration.
+     * **Note:** Only valid after this configuration was used to create a spatial context.
+     */
+    getEnabledComponents(): PackedInt64Array { return _C(this, 4657) as PackedInt64Array; }
+
+    /**
+     * Dictionary to use to decode Aruco markers.
+     * **Note:** Must be set before using this configuration to create a spatial context.
+     */
+    get arucoDict(): ArucoDict { return _C(this, 3795) as ArucoDict; }
+    set arucoDict(v: ArucoDict) { _C(this, 10533, v); }
+
+    static readonly name = _R(507, OpenXRSpatialCapabilityConfigurationAruco);
+}
+
+export const ArucoDict = {
+    /**
+     * 4 by 4 pixel Aruco marker dictionary with 50 IDs.
+     */
+    ARUCO_DICT_4X4_50: 1,
+    /**
+     * 4 by 4 pixel Aruco marker dictionary with 100 IDs.
+     */
+    ARUCO_DICT_4X4_100: 2,
+    /**
+     * 4 by 4 pixel Aruco marker dictionary with 250 IDs.
+     */
+    ARUCO_DICT_4X4_250: 3,
+    /**
+     * 4 by 4 pixel Aruco marker dictionary with 1000 IDs.
+     */
+    ARUCO_DICT_4X4_1000: 4,
+    /**
+     * 5 by 5 pixel Aruco marker dictionary with 50 IDs.
+     */
+    ARUCO_DICT_5X5_50: 5,
+    /**
+     * 5 by 5 pixel Aruco marker dictionary with 100 IDs.
+     */
+    ARUCO_DICT_5X5_100: 6,
+    /**
+     * 5 by 5 pixel Aruco marker dictionary with 250 IDs.
+     */
+    ARUCO_DICT_5X5_250: 7,
+    /**
+     * 5 by 5 pixel Aruco marker dictionary with 1000 IDs.
+     */
+    ARUCO_DICT_5X5_1000: 8,
+    /**
+     * 6 by 6 pixel Aruco marker dictionary with 50 IDs.
+     */
+    ARUCO_DICT_6X6_50: 9,
+    /**
+     * 6 by 6 pixel Aruco marker dictionary with 100 IDs.
+     */
+    ARUCO_DICT_6X6_100: 10,
+    /**
+     * 6 by 6 pixel Aruco marker dictionary with 250 IDs.
+     */
+    ARUCO_DICT_6X6_250: 11,
+    /**
+     * 6 by 6 pixel Aruco marker dictionary with 1000 IDs.
+     */
+    ARUCO_DICT_6X6_1000: 12,
+    /**
+     * 7 by 7 pixel Aruco marker dictionary with 50 IDs.
+     */
+    ARUCO_DICT_7X7_50: 13,
+    /**
+     * 7 by 7 pixel Aruco marker dictionary with 100 IDs.
+     */
+    ARUCO_DICT_7X7_100: 14,
+    /**
+     * 7 by 7 pixel Aruco marker dictionary with 250 IDs.
+     */
+    ARUCO_DICT_7X7_250: 15,
+    /**
+     * 7 by 7 pixel Aruco marker dictionary with 1000 IDs.
+     */
+    ARUCO_DICT_7X7_1000: 16,
+} as const;
+
+export type ArucoDict = (typeof ArucoDict)[keyof typeof ArucoDict];
+

package/gen/classes/OpenXRSpatialCapabilityConfigurationBaseHeader.ts

@@ -0,0 +1,25 @@
+// 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';
+
+/**
+ * Wrapper base class for OpenXR Spatial Capability Configuration headers. This class needs to be implemented for each capability configuration structure usable within OpenXR's spatial entities system.
+ */
+export class OpenXRSpatialCapabilityConfigurationBaseHeader extends RefCounted {
+    constructor(name = 508) { super(name); }
+
+    /**
+     * Returns `true` if this object contains a valid configuration that can be used when calling {@link OpenXRSpatialEntityExtension.createSpatialContext}.
+     */
+    hasValidConfiguration(): boolean { return _C(this, 7482) as boolean; }
+
+    /**
+     * Gets a pointer to the `XrSpatialCapabilityConfigurationBaseHeaderEXT` struct.
+     * **Note:** This method is intended to be used from GDExtensions.
+     */
+    getConfiguration(): number { return _C(this, 4259) as number; }
+
+    static readonly name = _R(508, OpenXRSpatialCapabilityConfigurationBaseHeader);
+}

package/gen/classes/OpenXRSpatialCapabilityConfigurationMicroQrCode.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 { OpenXRSpatialCapabilityConfigurationBaseHeader } from './OpenXRSpatialCapabilityConfigurationBaseHeader.ts';
+import type { PackedInt64Array } from '../heap-types/index.ts';
+
+/**
+ * Configuration header for QR code markers. Pass this to {@link OpenXRSpatialEntityExtension.createSpatialContext} to create a spatial context that can detect QR code markers.
+ */
+export class OpenXRSpatialCapabilityConfigurationMicroQrCode extends OpenXRSpatialCapabilityConfigurationBaseHeader {
+    constructor(name = 509) { super(name); }
+
+    /**
+     * Returns the components enabled by this configuration.
+     * **Note:** Only valid after this configuration was used to create a spatial context.
+     */
+    getEnabledComponents(): PackedInt64Array { return _C(this, 4657) as PackedInt64Array; }
+
+    static readonly name = _R(509, OpenXRSpatialCapabilityConfigurationMicroQrCode);
+}

package/gen/classes/OpenXRSpatialCapabilityConfigurationPlaneTracking.ts

@@ -0,0 +1,36 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRSpatialCapabilityConfigurationBaseHeader } from './OpenXRSpatialCapabilityConfigurationBaseHeader.ts';
+import type { PackedInt64Array } from '../heap-types/index.ts';
+
+/**
+ * Configuration header for plane tracking. Pass this to {@link OpenXRSpatialEntityExtension.createSpatialContext} to create a spatial context with plane tracking capabilities.
+ */
+export class OpenXRSpatialCapabilityConfigurationPlaneTracking extends OpenXRSpatialCapabilityConfigurationBaseHeader {
+    constructor(name = 510) { super(name); }
+
+    /**
+     * Returns `true` if we support the mesh 2D component (only valid after the OpenXR session has started). You can query these using the {@link OpenXRSpatialComponentMesh2DList} data object.
+     */
+    supportsMesh2d(): boolean { return _C(this, 14020) as boolean; }
+
+    /**
+     * Returns `true` if we support the polygon 2D component (only valid after the OpenXR session has started). You can query these using the {@link OpenXRSpatialComponentPolygon2DList} data object.
+     */
+    supportsPolygons(): boolean { return _C(this, 14022) as boolean; }
+
+    /**
+     * Returns `true` if we support the plane semantic label component (only valid after the OpenXR session has started). You can query these using the {@link OpenXRSpatialComponentPlaneSemanticLabelList} data object.
+     */
+    supportsLabels(): boolean { return _C(this, 14019) as boolean; }
+
+    /**
+     * Returns the components enabled by this configuration.
+     * **Note:** Only valid after this configuration was used to create a spatial context.
+     */
+    getEnabledComponents(): PackedInt64Array { return _C(this, 4657) as PackedInt64Array; }
+
+    static readonly name = _R(510, OpenXRSpatialCapabilityConfigurationPlaneTracking);
+}

package/gen/classes/OpenXRSpatialCapabilityConfigurationQrCode.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 { OpenXRSpatialCapabilityConfigurationBaseHeader } from './OpenXRSpatialCapabilityConfigurationBaseHeader.ts';
+import type { PackedInt64Array } from '../heap-types/index.ts';
+
+/**
+ * Configuration header for micro QR code markers. Pass this to {@link OpenXRSpatialEntityExtension.createSpatialContext} to create a spatial context that can detect micro QR code markers.
+ */
+export class OpenXRSpatialCapabilityConfigurationQrCode extends OpenXRSpatialCapabilityConfigurationBaseHeader {
+    constructor(name = 511) { super(name); }
+
+    /**
+     * Returns the components enabled by this configuration.
+     * **Note:** Only valid after this configuration was used to create a spatial context.
+     */
+    getEnabledComponents(): PackedInt64Array { return _C(this, 4657) as PackedInt64Array; }
+
+    static readonly name = _R(511, OpenXRSpatialCapabilityConfigurationQrCode);
+}

package/gen/classes/OpenXRSpatialComponentAnchorList.ts

@@ -0,0 +1,20 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRSpatialComponentData } from './OpenXRSpatialComponentData.ts';
+import type { Transform3D } from '../value-types/index.ts';
+
+/**
+ * Object for storing the queries anchor result data when calling {@link OpenXRSpatialEntityExtension.querySnapshot}.
+ */
+export class OpenXRSpatialComponentAnchorList extends OpenXRSpatialComponentData {
+    constructor(name = 512) { super(name); }
+
+    /**
+     * Returns the transform for the entity at this `index`.
+     */
+    getEntityPose(index: number /* int64 */): Transform3D { return _C(this, 4674, index) as Transform3D; }
+
+    static readonly name = _R(512, OpenXRSpatialComponentAnchorList);
+}

package/gen/classes/OpenXRSpatialComponentBounded2DList.ts

@@ -0,0 +1,25 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRSpatialComponentData } from './OpenXRSpatialComponentData.ts';
+import type { Transform3D, Vector2 } from '../value-types/index.ts';
+
+/**
+ * Object for storing the queries 2D bounding rectangle result data when calling {@link OpenXRSpatialEntityExtension.querySnapshot}.
+ */
+export class OpenXRSpatialComponentBounded2DList extends OpenXRSpatialComponentData {
+    constructor(name = 513) { super(name); }
+
+    /**
+     * Returns the center of our bounding rectangle for the entity at this `index`.
+     */
+    getCenterPose(index: number /* int64 */): Transform3D { return _C(this, 4130, index) as Transform3D; }
+
+    /**
+     * Returns the size of our bounding rectangle for the entity at this `index`.
+     */
+    getSize(index: number /* int64 */): Vector2 { return _C(this, 6399, index) as Vector2; }
+
+    static readonly name = _R(513, OpenXRSpatialComponentBounded2DList);
+}