@downdraft/engine 0.1.1 → 0.1.2-alpha.5

package/dist/modules/xr/src/input.js

@@ -0,0 +1,164 @@
+const KEY_ESCAPE = 27;
+const KEY_A = 65;
+const KEY_B = 66;
+const KEY_X = 88;
+const KEY_Y = 89;
+export class XRInputMapper {
+    controllers = [];
+    prevButtonStates = [];
+    update(frame, referenceSpace, inputState) {
+        const session = frame.session;
+        const sources = session.inputSources;
+        const controllers = [];
+        this.controllers = [];
+        let gamepadIdx = 0;
+        for (let i = 0; i < sources.length; i++) {
+            const source = sources[i];
+            if (source.targetRayMode !== "tracked-pointer")
+                continue;
+            const handedness = source.handedness;
+            const gamepad = source.gamepad;
+            // Get aim and grip poses
+            const aimPose = this.getPose(frame, source, referenceSpace, "target-ray");
+            const gripPose = this.getPose(frame, source, referenceSpace, "grip");
+            this.controllers.push({
+                aimPose,
+                gripPose,
+                handedness,
+            });
+            // Build XRControllerState
+            if (aimPose || gripPose) {
+                const ctrl = {
+                    aimPosition: aimPose?.position ?? [0, 0, 0],
+                    aimQuaternion: aimPose?.quaternion ?? [0, 0, 0, 1],
+                    gripPosition: gripPose?.position ?? [0, 0, 0],
+                    gripQuaternion: gripPose?.quaternion ?? [0, 0, 0, 1],
+                    handedness,
+                };
+                controllers.push(ctrl);
+            }
+            // Map gamepad buttons to InputState
+            if (gamepad) {
+                this.mapGamepadToInputState(gamepad, gamepadIdx, inputState, i);
+                gamepadIdx++;
+            }
+        }
+        inputState.xrControllers = controllers;
+    }
+    mapGamepadToInputState(gamepad, _gamepadIdx, inputState, sourceIdx) {
+        const buttons = gamepad.buttons;
+        const axes = gamepad.axes;
+        // Ensure prevButtonStates is large enough
+        while (this.prevButtonStates.length <= sourceIdx) {
+            this.prevButtonStates.push([]);
+        }
+        const prevStates = this.prevButtonStates[sourceIdx];
+        while (prevStates.length < buttons.length) {
+            prevStates.push(false);
+        }
+        for (let b = 0; b < buttons.length; b++) {
+            const pressed = buttons[b].pressed;
+            const wasPressed = prevStates[b];
+            if (pressed && !wasPressed) {
+                // Button just pressed — map to key
+                const keyCode = this.buttonToKeyCode(b);
+                if (keyCode !== null) {
+                    inputState.keyDown(keyCode);
+                }
+                // Also map trigger (0) and squeeze (1) to mouse buttons
+                if (b === 0)
+                    inputState.mouseDown(0);
+                if (b === 1)
+                    inputState.mouseDown(2);
+            }
+            else if (!pressed && wasPressed) {
+                // Button just released
+                const keyCode = this.buttonToKeyCode(b);
+                if (keyCode !== null) {
+                    inputState.keyUp(keyCode);
+                }
+                if (b === 0)
+                    inputState.mouseUp(0);
+                if (b === 1)
+                    inputState.mouseUp(2);
+            }
+            prevStates[b] = pressed;
+        }
+        // Map axes (thumbstick) to gamepadAxes
+        // Standard XR controller: axes[0] = x, axes[1] = y, axes[2] = x2, axes[3] = y2
+        if (axes.length >= 2) {
+            inputState.gamepadAxes[0] = axes[0];
+            inputState.gamepadAxes[1] = axes[1];
+        }
+        if (axes.length >= 4) {
+            inputState.gamepadAxes[2] = axes[2];
+            inputState.gamepadAxes[3] = axes[3];
+        }
+    }
+    buttonToKeyCode(buttonIndex) {
+        // Standard XR gamepad button mapping:
+        // 0 = trigger, 1 = squeeze, 2 = thumbstick press, 3 = A/X, 4 = B/Y
+        switch (buttonIndex) {
+            case 0: return null; // trigger → mapped to mouse button 0
+            case 1: return null; // squeeze → mapped to mouse button 2
+            case 2: return null; // thumbstick press — no standard key
+            case 3: return KEY_A; // A / X
+            case 4: return KEY_B; // B / Y
+            default: return null;
+        }
+    }
+    getPose(frame, source, referenceSpace, spaceType) {
+        const space = spaceType === "target-ray" ? source.targetRaySpace : source.gripSpace;
+        if (!space)
+            return null;
+        const pose = frame.getPose(space, referenceSpace);
+        if (!pose)
+            return null;
+        const matrix = pose.transform.matrix;
+        const position = [matrix[12], matrix[13], matrix[14]];
+        const quaternion = this.matrixToQuaternion(matrix);
+        return { position, quaternion, matrix: new Float32Array(matrix) };
+    }
+    matrixToQuaternion(m) {
+        const trace = m[0] + m[5] + m[10];
+        let qw, qx, qy, qz;
+        if (trace > 0) {
+            const s = 0.5 / Math.sqrt(trace + 1);
+            qw = 0.25 / s;
+            qx = (m[6] - m[9]) * s;
+            qy = (m[8] - m[2]) * s;
+            qz = (m[1] - m[4]) * s;
+        }
+        else if (m[0] > m[5] && m[0] > m[10]) {
+            const s = 2 * Math.sqrt(1 + m[0] - m[5] - m[10]);
+            qw = (m[6] - m[9]) / s;
+            qx = 0.25 * s;
+            qy = (m[4] + m[1]) / s;
+            qz = (m[8] + m[2]) / s;
+        }
+        else if (m[5] > m[10]) {
+            const s = 2 * Math.sqrt(1 + m[5] - m[0] - m[10]);
+            qw = (m[8] - m[2]) / s;
+            qx = (m[4] + m[1]) / s;
+            qy = 0.25 * s;
+            qz = (m[9] + m[6]) / s;
+        }
+        else {
+            const s = 2 * Math.sqrt(1 + m[10] - m[0] - m[5]);
+            qw = (m[1] - m[4]) / s;
+            qx = (m[8] + m[2]) / s;
+            qy = (m[9] + m[6]) / s;
+            qz = 0.25 * s;
+        }
+        return [qx, qy, qz, qw];
+    }
+    getAimPose(controllerIdx) {
+        return this.controllers[controllerIdx]?.aimPose ?? null;
+    }
+    getGripPose(controllerIdx) {
+        return this.controllers[controllerIdx]?.gripPose ?? null;
+    }
+    getControllerCount() {
+        return this.controllers.length;
+    }
+}

package/dist/modules/xr/src/layer.js

@@ -0,0 +1,100 @@
+import { isXRGPUBindingAvailable } from "./session.js";
+export class XRLayerManager {
+    binding = null;
+    layer = null;
+    device = null;
+    format = "bgra8unorm";
+    depthFormat = "depth32float";
+    currentViews = new Map([
+        ["left", null],
+        ["right", null],
+    ]);
+    init(device, session) {
+        this.device = device;
+        if (!isXRGPUBindingAvailable()) {
+            throw new Error("XRGPUBinding not available — enable chrome://flags/#webxr-incubations");
+        }
+        const BindingCtor = globalThis.XRGPUBinding;
+        if (!BindingCtor) {
+            throw new Error("XRGPUBinding constructor not found");
+        }
+        this.binding = new BindingCtor(device, session);
+    }
+    createLayer(session, referenceSpace, format, depthFormat) {
+        if (!this.binding)
+            throw new Error("XRLayerManager not initialized — call init() first");
+        this.format = format;
+        this.depthFormat = depthFormat;
+        this.layer = this.binding.createProjectionLayer({
+            space: referenceSpace,
+            format,
+            depthFormat,
+        });
+        session.updateRenderState({ layers: [this.layer] });
+    }
+    beginFrame(frame, referenceSpace) {
+        if (!this.layer || !this.binding)
+            return;
+        const pose = frame.getViewerPose(referenceSpace);
+        if (!pose) {
+            this.currentViews.set("left", null);
+            this.currentViews.set("right", null);
+            return;
+        }
+        for (let _i = 0, _it = pose.views, _n = _it.length; _i < _n; _i++) {
+            const view = _it[_i];
+            const eye = view.eye;
+            if (eye !== "left" && eye !== "right")
+                continue;
+            const layerView = this.layer.getView(view);
+            this.currentViews.set(eye, layerView);
+        }
+    }
+    getColorTextureView(eye) {
+        const view = this.currentViews.get(eye);
+        if (!view || !view.subImage.colorTexture)
+            throw new Error(`No color texture for eye: ${eye}`);
+        return view.subImage.colorTexture.createView();
+    }
+    getDepthTextureView(eye) {
+        const view = this.currentViews.get(eye);
+        if (!view || !view.subImage.depthTexture) {
+            throw new Error(`No depth texture for eye: ${eye}`);
+        }
+        return view.subImage.depthTexture.createView();
+    }
+    getViewport(eye) {
+        const view = this.currentViews.get(eye);
+        if (!view)
+            return null;
+        return view.subImage.viewport;
+    }
+    getProjectionMatrix(eye) {
+        const view = this.currentViews.get(eye);
+        if (!view)
+            return null;
+        return view.projectionMatrix;
+    }
+    getViewMatrix(eye) {
+        const view = this.currentViews.get(eye);
+        if (!view)
+            return null;
+        return view.transform.matrix;
+    }
+    hasView(eye) {
+        return this.currentViews.get(eye) !== null;
+    }
+    getLayer() {
+        return this.layer;
+    }
+    destroy() {
+        if (this.layer) {
+            this.layer.destroy();
+            this.layer = null;
+        }
+        this.binding = null;
+        this.device = null;
+        this.currentViews.set("left", null);
+        this.currentViews.set("right", null);
+    }
+}

package/dist/modules/xr/src/session.js

@@ -0,0 +1,133 @@
+import { DEFAULT_XR_CONFIG } from "./types.js";
+export class XRSessionManager {
+    session = null;
+    referenceSpace = null;
+    state = "idle";
+    sessionEndCallbacks = [];
+    visibilityChangeCallbacks = [];
+    resetCallbacks = [];
+    onSessionEndHandler = null;
+    onVisibilityChangeHandler = null;
+    onReferenceSpaceResetHandler = null;
+    async requestSession(mode = "immersive-vr", config = DEFAULT_XR_CONFIG) {
+        if (this.state !== "idle") {
+            throw new Error(`Cannot request session in state: ${this.state}`);
+        }
+        if (!navigator.xr) {
+            throw new Error("WebXR not available");
+        }
+        this.state = "requesting";
+        try {
+            const session = await navigator.xr.requestSession(mode, {
+                requiredFeatures: config.requiredFeatures,
+                optionalFeatures: config.optionalFeatures,
+            });
+            this.session = session;
+            this.state = "active";
+            this.onSessionEndHandler = () => {
+                try {
+                    this.cleanup();
+                }
+                finally {
+                    this.sessionEndCallbacks.forEach((cb) => {
+                        try {
+                            cb();
+                        }
+                        catch { }
+                    });
+                }
+            };
+            this.onVisibilityChangeHandler = ((e) => {
+                const visible = e.visibilityState === "visible";
+                this.visibilityChangeCallbacks.forEach((cb) => { cb(visible); ; });
+            });
+            session.addEventListener("end", this.onSessionEndHandler);
+            session.addEventListener("visibilitychange", this.onVisibilityChangeHandler);
+            return session;
+        }
+        catch (err) {
+            this.state = "idle";
+            throw err;
+        }
+    }
+    async setReferenceSpace(type) {
+        if (!this.session)
+            throw new Error("No active session");
+        this.referenceSpace = await this.session.requestReferenceSpace(type);
+        this.onReferenceSpaceResetHandler = ((e) => {
+            this.referenceSpace = e.referenceSpace;
+            this.resetCallbacks.forEach((cb) => { cb(); ; });
+        });
+        this.referenceSpace.addEventListener("reset", this.onReferenceSpaceResetHandler);
+    }
+    async endSession() {
+        if (!this.session || this.state === "ending")
+            return;
+        this.state = "ending";
+        try {
+            await this.session.end();
+        }
+        finally {
+            this.cleanup();
+        }
+    }
+    getSession() {
+        return this.session;
+    }
+    getReferenceSpace() {
+        return this.referenceSpace;
+    }
+    getState() {
+        return this.state;
+    }
+    isActive() {
+        return this.state === "active" && this.session !== null;
+    }
+    onSessionEnd(cb) {
+        this.sessionEndCallbacks.push(cb);
+    }
+    onVisibilityChange(cb) {
+        this.visibilityChangeCallbacks.push(cb);
+    }
+    onReset(cb) {
+        this.resetCallbacks.push(cb);
+    }
+    cleanup() {
+        if (this.onSessionEndHandler && this.session) {
+            this.session.removeEventListener("end", this.onSessionEndHandler);
+        }
+        if (this.onVisibilityChangeHandler && this.session) {
+            this.session.removeEventListener("visibilitychange", this.onVisibilityChangeHandler);
+        }
+        if (this.onReferenceSpaceResetHandler && this.referenceSpace) {
+            this.referenceSpace.removeEventListener("reset", this.onReferenceSpaceResetHandler);
+        }
+        this.onSessionEndHandler = null;
+        this.onVisibilityChangeHandler = null;
+        this.onReferenceSpaceResetHandler = null;
+        this.session = null;
+        this.referenceSpace = null;
+        this.state = "idle";
+    }
+    /** Public cleanup — called by the plugin's onDispose. */
+    destroy() {
+        this.cleanup();
+        this.resetCallbacks.length = 0;
+    }
+}
+export function isXRAvailable() {
+    return typeof navigator !== "undefined" && !!navigator.xr;
+}
+export async function isVRSupported() {
+    if (!navigator.xr)
+        return false;
+    try {
+        return await navigator.xr.isSessionSupported("immersive-vr");
+    }
+    catch {
+        return false;
+    }
+}
+export function isXRGPUBindingAvailable() {
+    return typeof globalThis !== "undefined" && "XRGPUBinding" in globalThis;
+}

package/dist/modules/xr/src/sim-module.js

@@ -0,0 +1,21 @@
+import { resourceToken } from "@downdraft/engine";
+import { XRInputMapper } from "./input.js";
+import { XRSessionManager } from "./session.js";
+/** Token for the XR session manager provided by `xrModule`. */
+export const XRSessionManagerTok = resourceToken("xrSessionManager");
+/** Token for the XR input mapper provided by `xrModule`. */
+export const XRInputMapperTok = resourceToken("xrInputMapper");
+export const xrModule = {
+    name: "@downdraft/engine/modules/xr",
+    version: "0.1.0",
+    provides: [XRSessionManagerTok, XRInputMapperTok],
+    register(ctx) {
+        const session = new XRSessionManager();
+        const input = new XRInputMapper();
+        ctx.provide(XRSessionManagerTok, session);
+        ctx.provide(XRInputMapperTok, input);
+        ctx.onDispose(() => {
+            session.destroy();
+        });
+    },
+};

package/dist/modules/xr/src/types.js

@@ -0,0 +1,4 @@
+export const DEFAULT_XR_CONFIG = {
+    requiredFeatures: ["local-floor"],
+    optionalFeatures: ["depth-sensing", "hand-tracking"],
+};

package/dist/modules/xr/src/webxr.d.ts

@@ -0,0 +1,182 @@
+// Minimal WebXR type declarations (global)
+// These types are not included in TypeScript's DOM lib
+
+declare global {
+  type XRReferenceSpaceType = "viewer" | "local" | "local-floor" | "bounded-floor" | "unbounded";
+  type XRSessionMode = "inline" | "immersive-vr" | "immersive-ar";
+  type XRVisibilityState = "visible" | "visible-blurred" | "hidden";
+  type XRFrameRequestCallback = (time: number, frame: XRFrame) => void;
+  type XRSessionFeature = "local" | "local-floor" | "bounded-floor" | "unbounded" | "hit-test" | "dom-overlay" | "layers" | "anchors";
+  type XREye = "none" | "left" | "right";
+
+  interface XRSessionInit {
+    requiredFeatures?: XRSessionFeature[];
+    optionalFeatures?: XRSessionFeature[];
+  }
+
+  interface XRRenderState {
+    depthNear: number;
+    depthFar: number;
+    inlineVerticalFieldOfView?: number;
+    baseLayer?: XRWebGLLayer | null;
+  }
+
+  interface XRRenderStateInit {
+    depthNear?: number;
+    depthFar?: number;
+    inlineVerticalFieldOfView?: number;
+    baseLayer?: XRWebGLLayer | null;
+  }
+
+  interface XRWebGLLayerInit {
+    antialias?: boolean;
+    depth?: boolean;
+    stencil?: boolean;
+    alpha?: boolean;
+    multiview?: boolean;
+  }
+
+  class XRWebGLLayer {
+    constructor(session: XRSession, gl: WebGLRenderingContext | WebGL2RenderingContext, init?: XRWebGLLayerInit);
+    readonly antialias: boolean;
+    readonly depth: boolean;
+    readonly stencil: boolean;
+    readonly alpha: boolean;
+    readonly multiview: boolean;
+    getViewport(view: XRView): XRViewport | null;
+    requestViewportScaling(viewportScaleFactor: number): void;
+  }
+
+  interface XRViewport {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  }
+
+  interface XRView {
+    readonly eye: XREye;
+    readonly projectionMatrix: Float32Array;
+    readonly transform: XRRigidTransform;
+    readonly viewport?: XRViewport;
+  }
+
+  interface XRViewerPose {
+    readonly transform: XRRigidTransform;
+    readonly emulatedPosition: boolean;
+    readonly views: XRView[];
+  }
+
+  interface XRFrame {
+    readonly session: XRSession;
+    getViewerPose(referenceSpace: XRReferenceSpace): XRViewerPose | null;
+    getPose(space: XRSpace, referenceSpace: XRReferenceSpace): XRPose | null;
+    getJointPose(jointSpace: XRJointSpace, referenceSpace: XRReferenceSpace): XRJointPose | null;
+    fillPoses(spaces: XRSpace[], referenceSpace: XRReferenceSpace, transforms: Float32Array): boolean;
+    fillJointRadii(jointSpaces: XRJointSpace[], radii: Float32Array): boolean;
+  }
+
+  interface XRPose {
+    readonly transform: XRRigidTransform;
+    readonly emulatedPosition: boolean;
+  }
+
+  class XRRigidTransform {
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    readonly position: DOMPointReadOnly;
+    readonly orientation: DOMPointReadOnly;
+    readonly matrix: Float32Array;
+    readonly inverse: XRRigidTransform;
+  }
+
+  class XRReferenceSpace extends EventTarget {
+    readonly type: XRReferenceSpaceType;
+    getOffsetReferenceSpace(offset: XRRigidTransform): XRReferenceSpace;
+  }
+
+  class XRReferenceSpaceEvent extends Event {
+    constructor(type: string, eventInitDict: XRReferenceSpaceEventInit);
+    readonly referenceSpace: XRReferenceSpace;
+  }
+
+  interface XRReferenceSpaceEventInit extends EventInit {
+    referenceSpace: XRReferenceSpace;
+  }
+
+  class XRSpace {
+    // Base class for reference spaces
+  }
+
+  class XRJointSpace extends XRSpace {
+    readonly jointName: string;
+  }
+
+  interface XRJointPose extends XRPose {
+    readonly radius: number;
+  }
+
+  interface XRInputSource {
+    readonly handedness: "none" | "left" | "right";
+    readonly targetRayMode: "gaze" | "tracked-pointer" | "screen";
+    readonly targetRaySpace: XRSpace;
+    readonly gripSpace?: XRSpace;
+    readonly gamepad?: Gamepad;
+    readonly profiles: string[];
+    readonly hand?: XRHand;
+  }
+
+  interface XRHand {
+    readonly size: number;
+    [key: string]: XRJointSpace;
+  }
+
+  class XRSession extends EventTarget {
+    readonly mode: XRSessionMode;
+    readonly visibilityState: XRVisibilityState;
+    readonly inputSources: XRInputSource[];
+    readonly environmentBlendMode: string;
+    renderState: XRRenderState;
+    requestReferenceSpace(type: XRReferenceSpaceType): Promise<XRReferenceSpace>;
+    updateRenderState(state: XRRenderStateInit): void;
+    requestAnimationFrame(callback: XRFrameRequestCallback): number;
+    cancelAnimationFrame(id: number): void;
+    end(): Promise<void>;
+    requestHitTestSource(options: XRHitTestOptionsInit): Promise<XRHitTestSource>;
+  }
+
+  interface XRHitTestOptionsInit {
+    space: XRSpace;
+    offsetRay?: XRRay;
+  }
+
+  class XRHitTestSource {
+    cancel(): void;
+  }
+
+  class XRRay {
+    constructor(origin?: DOMPointInit, direction?: DOMPointInit);
+    readonly origin: DOMPointReadOnly;
+    readonly direction: DOMPointReadOnly;
+    readonly matrix: Float32Array;
+  }
+
+  class XRLayer {
+    // Base class for XR layers
+  }
+
+  interface XRVisibilityChangeEvent extends Event {
+    readonly visibilityState: XRVisibilityState;
+  }
+
+  interface Navigator {
+    xr?: XRSystem;
+  }
+
+  class XRSystem extends EventTarget {
+    isSessionSupported(mode: XRSessionMode): Promise<boolean>;
+    requestSession(mode: XRSessionMode, options?: XRSessionInit): Promise<XRSession>;
+  }
+}
+
+export { };
+