@splnlss/3d-story-viewer 0.8.1 → 0.8.3

package/build/types/src/viewer/GlobeManager.d.ts

@@ -4,14 +4,24 @@ export class GlobeManager extends EventDispatcher {
     camera: any;
     renderer: any;
     tiles: TilesRenderer<import("3d-tiles-renderer").TilesRendererEventMap>;
+    destinationTileCamera: PerspectiveCamera;
+    destinationTileResolution: number;
+    destinationTileTimeout: number;
+    previousAutoDisableRendererCulling: boolean;
     dracoLoader: any;
     ownsDecoders: boolean;
     decoders: any;
     apiToken: any;
     googleMapsToken: any;
     initTiles(): void;
+    attachTileLoadListener(): void;
+    /** The renderer shares one cache and request scheduler between both registered cameras. */
+    setDestinationTilePrefetch(target: any): void;
+    updateDestinationTileResolution(): void;
+    clearDestinationTilePrefetch(): void;
     update(): void;
     dispose(): void;
 }
 import { EventDispatcher } from '../modules/EventDispatcher';
 import { TilesRenderer } from '3d-tiles-renderer';
+import { PerspectiveCamera } from 'three';

package/build/types/src/viewer/WebXRSession.d.ts

@@ -0,0 +1,77 @@
+/** @typedef {{ lodSplatCount?: number, lodRenderScale?: number }} SparkProfile */
+/** Owns one immersive session for a Viewer, including every desktop restoration path. */
+export class WebXRSession {
+    /** @param {import('./index.js').default} viewer @param {{ onFrame?: (input: { time: number, frame: XRFrame, pose: XRViewerPose }) => void, onStateChange?: (active: boolean) => void, showAttribution?: boolean }} [options] */
+    constructor(viewer: import("./index.js").default, options?: {
+        onFrame?: (input: {
+            time: number;
+            frame: XRFrame;
+            pose: XRViewerPose;
+        }) => void;
+        onStateChange?: (active: boolean) => void;
+        showAttribution?: boolean;
+    });
+    viewer: import("./index.js").default;
+    onFrame: (input: {
+        time: number;
+        frame: XRFrame;
+        pose: XRViewerPose;
+    }) => void;
+    onStateChange: (active: boolean) => void;
+    showAttribution: boolean;
+    session: any;
+    starting: any;
+    bridge: {
+        getHeadPose: () => import("./XRPlayerRig.js").XRHeadPose;
+        getHeadForward: () => import("three").Vector3Tuple;
+        getControllerWorldRay: (controller: any) => {
+            origin: import("three").Vector3Tuple;
+            direction: import("three").Vector3Tuple;
+        };
+        setNavigationCue: (cue: any) => void;
+        setTerrainCredits: (credits: any) => void;
+        setPlayerPose(pose: any): void;
+        setVisualBlend(blend: any): void;
+        hasUi(): boolean;
+        setNavigationLimit(reason: any): void;
+        setComfortMoving(moving: any): void;
+        setFade(opacity: any): void;
+        updateHeadPose(pose: any): void;
+        dispose(): void;
+    };
+    desktop: {
+        cameraWorld: import("three").Matrix4;
+        near: number;
+        far: number;
+        globeEnabled: boolean;
+        keysEnabled: boolean;
+        xrEnabled: boolean;
+        foveation: number;
+        referenceSpaceType: any;
+        framebufferScaleFactor: any;
+        labelRender: (scene: import("three").Scene, camera: import("three").Camera) => void;
+        ensureSparkRenderer: () => Promise<any>;
+        transitionAnimateTo: (position: any, quaternion: any, duration?: number) => Promise<any>;
+        tilesSchedulerSession: any;
+    };
+    /** @type {Map<object, SparkProfile>} */
+    sparkProfiles: Map<object, SparkProfile>;
+    disposed: boolean;
+    stopping: boolean;
+    endRequested: boolean;
+    active: boolean;
+    handleSessionEnd: () => void;
+    handleFrame: (time: any, frame: any) => void;
+    start(): any;
+    activate(requested: any): Promise<void>;
+    frame(time: any, frame: any): void;
+    applySparkProfile(spark: any): void;
+    cleanup(): void;
+    endSessionOnce(session: any): Promise<void>;
+    stop(): Promise<void>;
+    dispose(): Promise<void>;
+}
+export type SparkProfile = {
+    lodSplatCount?: number;
+    lodRenderScale?: number;
+};

package/build/types/src/viewer/XRAttributionPanel.d.ts

@@ -0,0 +1,23 @@
+/** The renderer's current tile copyrights and the app's terrain credits. */
+export function attributionText(tileAttributions?: any[], terrainCredits?: any[]): any[];
+export function layoutAttributionLines(ctx: any, values: any): any;
+/** One lightweight head-local texture is composited into both XR eye views. */
+export class XRAttributionPanel {
+    canvas: HTMLCanvasElement;
+    context: CanvasRenderingContext2D;
+    texture: CanvasTexture<HTMLCanvasElement>;
+    mesh: Mesh<PlaneGeometry, MeshBasicMaterial, import("three").Object3DEventMap>;
+    terrainCredits: any[];
+    lastText: string;
+    lastTileCheckMs: number;
+    tileCredits: any[];
+    logos: HTMLImageElement[];
+    setTerrainCredits(credits: any): void;
+    update(headMatrix: any, tiles: any, timeMs: any): void;
+    draw(): void;
+    dispose(): void;
+}
+import { CanvasTexture } from 'three';
+import { PlaneGeometry } from 'three';
+import { MeshBasicMaterial } from 'three';
+import { Mesh } from 'three';

package/build/types/src/viewer/XRComfortOverlay.d.ts

@@ -0,0 +1,15 @@
+/** Head-local peripheral motion vignette, drawn after the scene in both eyes. */
+export class XRComfortOverlay {
+    material: ShaderMaterial;
+    mesh: Mesh<PlaneGeometry, ShaderMaterial, import("three").Object3DEventMap>;
+    moving: boolean;
+    navigationLimit: any;
+    fade: number;
+    setNavigationLimit(reason: any): boolean;
+    setFade(opacity: any): void;
+    update(headMatrix: any): void;
+    dispose(): void;
+}
+import { ShaderMaterial } from 'three';
+import { PlaneGeometry } from 'three';
+import { Mesh } from 'three';

package/build/types/src/viewer/XRFrameInput.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Copy the current WebXR input sample before the browser reuses its frame objects.
+ * Positions are local-reference-space metres; orientation is an XR quaternion.
+ * @param {XRFrame} frame
+ * @param {XRReferenceSpace | null} referenceSpace
+ */
+export function readXRFrameInput(frame: XRFrame, referenceSpace: XRReferenceSpace | null): {
+    head: {
+        position: number[];
+        orientation: number[];
+    };
+    controllers: {
+        handedness: XRHandedness;
+        mapping: GamepadMappingType;
+        axes: number[];
+        buttons: {
+            pressed: boolean;
+            touched: boolean;
+            value: number;
+        }[];
+        ray: {
+            position: number[];
+            orientation: number[];
+        };
+        grip: {
+            position: number[];
+            orientation: number[];
+        };
+    }[];
+};

package/build/types/src/viewer/XRNavigationCue.d.ts

@@ -0,0 +1,10 @@
+/** Small, ordinary depth-tested scene geometry; never samples streamed visual layers. */
+export class XRNavigationCue {
+    constructor(scene: any);
+    scene: any;
+    group: Group<import("three").Object3DEventMap>;
+    set(cue: any): void;
+    clearChildren(): void;
+    dispose(): void;
+}
+import { Group } from 'three';

package/build/types/src/viewer/XRPlayerRig.d.ts

@@ -0,0 +1,92 @@
+/** Keeps metre-scale tracked poses separate from double-precision WGS84 ECEF positions. */
+export class XRPlayerRig {
+    /** @param {Matrix4} initialCameraWorld @param {XRRigidTransform} initialHeadPose */
+    constructor(initialCameraWorld: Matrix4, initialHeadPose: XRRigidTransform);
+    headLocal: Matrix4;
+    /** @type {Matrix4 | null} */
+    trackingReference: Matrix4 | null;
+    /** @type {Matrix4 | null} */
+    visualReference: Matrix4 | null;
+    /** @type {{pitchDegrees: number, rollDegrees: number} | null} */
+    visualOrientation: {
+        pitchDegrees: number;
+        rollDegrees: number;
+    } | null;
+    visualBlend: number;
+    worldFromLocal: Matrix4;
+    anchor: {
+        longitude: number;
+        latitude: number;
+        altitude: number;
+    };
+    /** @param {XRRigidTransform} pose */
+    updateHeadPose(pose: XRRigidTransform): void;
+    getWorldFromLocalMatrix(): Matrix4;
+    getWorldHeadMatrix(): Matrix4;
+    getVisualWorldFromLocalMatrix(): Matrix4;
+    getVisualWorldHeadMatrix(): Matrix4;
+    getVisualHeadForward(): import("three").Vector3Tuple;
+    poseFromWorld(world: any): {
+        worldEcef: import("three").Vector3Tuple;
+        geodetic: {
+            longitude: number;
+            latitude: number;
+            altitude: number;
+        };
+        headingDegrees: number;
+    };
+    /** @returns {XRHeadPose} WGS84 degrees, ellipsoidal altitude metres, ECEF metres, local-floor metres. */
+    getHeadPose(): XRHeadPose;
+    getNavigationFrame(): Matrix4;
+    /** Convert the copied WebXR target-ray transform to ECEF metres. */
+    getControllerWorldRay(controller: any): {
+        origin: import("three").Vector3Tuple;
+        direction: import("three").Vector3Tuple;
+    };
+    /**
+     * Places the tracked head at a WGS84 ellipsoidal position plus ENU metres.
+     * Heading is clockwise degrees from true north. Physical room-scale motion remains tracked.
+     */
+    /** @param {XRPlayerPose} pose */
+    setPose({ anchor, east, north, up, headingDegrees, trackingReference, visualOrientation }: XRPlayerPose): void;
+    /** Fade the authored camera correction while retaining live six-degree head tracking. */
+    setVisualBlend(blend: any): void;
+    reanchor(headingDegrees: any): void;
+}
+export type XRHeadPose = {
+    worldEcef: [number, number, number];
+    geodetic: {
+        longitude: number;
+        latitude: number;
+        altitude: number;
+    };
+    headingDegrees: number;
+    localHeadOffset: [number, number, number];
+    localHeadOrientation: [number, number, number, number];
+    displayedOrientation: {
+        pitch: number;
+        yaw: number;
+        roll: number;
+    };
+};
+export type XRTrackingReference = {
+    position: [number, number, number];
+    orientation: [number, number, number, number];
+};
+export type XRPlayerPose = {
+    anchor: {
+        longitude: number;
+        latitude: number;
+        altitude: number;
+    };
+    east?: number;
+    north?: number;
+    up?: number;
+    headingDegrees: number;
+    trackingReference?: XRTrackingReference;
+    visualOrientation?: {
+        pitchDegrees: number;
+        rollDegrees: number;
+    } | null;
+};
+import { Matrix4 } from 'three';

package/build/types/src/viewer/XRRenderBridge.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Places a metre-scale WebXR head under a double-precision ECEF anchor only
+ * while Three renders. The viewer's ordinary ECEF camera stays the scene camera.
+ * @param {import('./index.js').default} viewer
+ * @param {XRRigidTransform} initialHeadPose
+ * @param {{ showAttribution?: boolean }} [options]
+ */
+export function createXRRenderBridge(viewer: import("./index.js").default, initialHeadPose: XRRigidTransform, { showAttribution }?: {
+    showAttribution?: boolean;
+}): {
+    getHeadPose: () => import("./XRPlayerRig.js").XRHeadPose;
+    getHeadForward: () => import("three").Vector3Tuple;
+    getControllerWorldRay: (controller: any) => {
+        origin: import("three").Vector3Tuple;
+        direction: import("three").Vector3Tuple;
+    };
+    setNavigationCue: (cue: any) => void;
+    setTerrainCredits: (credits: any) => void;
+    setPlayerPose(pose: any): void;
+    setVisualBlend(blend: any): void;
+    hasUi(): boolean;
+    setNavigationLimit(reason: any): void;
+    setComfortMoving(moving: any): void;
+    setFade(opacity: any): void;
+    updateHeadPose(pose: any): void;
+    dispose(): void;
+};

package/build/types/src/viewer/index.d.ts

@@ -24,6 +24,7 @@ declare class Viewer extends EventDispatcher {
     isViewer: boolean;
     type: string;
     disposed: boolean;
+    xrSession: WebXRSession;
     sparkRenderer: any;
     transparentBackground: boolean;
     state: StateDispatcher;
@@ -45,6 +46,7 @@ declare class Viewer extends EventDispatcher {
     transitionControls: TransitionControls;
     tileDecoders: TileDecoders;
     globeManager: GlobeManager;
+    _onGlobeTileLoaded: () => void;
     /** @type {ViewerCoords} */
     cameraCoords: ViewerCoords;
     /** @type {ViewerCoords} */
@@ -80,6 +82,80 @@ declare class Viewer extends EventDispatcher {
     sky: Sky;
     pointerRaycaster: Raycaster;
     _onPointerMove: (event: any) => void;
+    get xrActive(): boolean;
+    /** @param {{ onFrame?: (input: { time: number, frame: XRFrame, pose: XRViewerPose }) => void, onStateChange?: (active: boolean) => void, showAttribution?: boolean }} [options] */
+    startXRSession(options?: {
+        onFrame?: (input: {
+            time: number;
+            frame: XRFrame;
+            pose: XRViewerPose;
+        }) => void;
+        onStateChange?: (active: boolean) => void;
+        showAttribution?: boolean;
+    }): any;
+    endXRSession(): Promise<void>;
+    /** @param {XRFrame} frame */
+    getXRFrameInput(frame: XRFrame): {
+        head: {
+            position: number[];
+            orientation: number[];
+        };
+        controllers: {
+            handedness: XRHandedness;
+            mapping: GamepadMappingType;
+            axes: number[];
+            buttons: {
+                pressed: boolean;
+                touched: boolean;
+                value: number;
+            }[];
+            ray: {
+                position: number[];
+                orientation: number[];
+            };
+            grip: {
+                position: number[];
+                orientation: number[];
+            };
+        }[];
+    };
+    /** @param {import('./XRPlayerRig.js').XRPlayerPose} pose */
+    setXRPlayerPose(pose: import("./XRPlayerRig.js").XRPlayerPose): void;
+    /** @param {number} blend 1 keeps the saved camera pitch, 0 restores natural tracked orientation. */
+    setXRVisualBlend(blend: number): void;
+    /** @returns {import('./XRPlayerRig.js').XRHeadPose | null} */
+    getXRHeadPose(): import("./XRPlayerRig.js").XRHeadPose | null;
+    /** @returns {number[] | null} Displayed head-forward unit vector in WGS84 ECEF axes. */
+    getXRHeadForward(): number[] | null;
+    /** @param {{ray: {position: number[], orientation: number[]} | null}} controller @returns {{origin: number[], direction: number[]} | null} */
+    getXRControllerWorldRay(controller: {
+        ray: {
+            position: number[];
+            orientation: number[];
+        } | null;
+    }): {
+        origin: number[];
+        direction: number[];
+    } | null;
+    /** @param {boolean} moving */
+    setXRComfortMoving(moving: boolean): void;
+    /** @param {'floor' | 'unknown' | 'loading' | null} reason */
+    setXRNavigationLimit(reason: "floor" | "unknown" | "loading" | null): void;
+    /** @param {{anchor: {longitude: number, latitude: number, altitude: number}, arc: readonly (readonly [number, number, number])[], marker: readonly [number, number, number] | null, state: 'valid' | 'blocked' | 'unknown'} | null} cue */
+    setXRNavigationCue(cue: {
+        anchor: {
+            longitude: number;
+            latitude: number;
+            altitude: number;
+        };
+        arc: readonly (readonly [number, number, number])[];
+        marker: readonly [number, number, number] | null;
+        state: "valid" | "blocked" | "unknown";
+    } | null): void;
+    /** @param {readonly string[]} credits Current Cesium World Terrain asset credits. */
+    setXRAttribution(credits: readonly string[]): void;
+    /** @param {number} opacity Black headset fade, 0 to 1. */
+    setXRNavigationFade(opacity: number): void;
     set keysEnabled(enabled: boolean);
     get keysEnabled(): boolean;
     updateMovementState(): void;
@@ -175,6 +251,20 @@ declare class Viewer extends EventDispatcher {
      * @param {number} [duration]
      */
     focusCamera(lon: number, lat: number, alt: number, distance?: number, pitch?: number, duration?: number): Promise<void>;
+    /**
+     * Temporarily load Google 3D tiles around a WGS84 destination without changing the live view.
+     * Position and altitude use degrees and WGS84 ellipsoidal metres; rotation uses degrees.
+     * @param {{longitude:number, latitude:number, altitude:number, pitch:number, yaw:number, roll:number, resolutionPixels:128|256} | null} target
+     */
+    setDestinationTilePrefetch(target: {
+        longitude: number;
+        latitude: number;
+        altitude: number;
+        pitch: number;
+        yaw: number;
+        roll: number;
+        resolutionPixels: 128 | 256;
+    } | null): void;
     /**
      * @param {number} [pitch]
      * @param {number} [yaw]
@@ -195,8 +285,10 @@ export namespace ViewerEvents {
     let CONTENT_LAYER_LOAD_PROGRESS: "content-layer-load-progress";
     let CONTENT_LAYER_READY: "content-layer-ready";
     let CONTENT_LAYER_ERROR: "content-layer-error";
+    let GLOBE_TILE_LOADED: "globe-tile-loaded";
 }
 import { EventDispatcher } from '../modules/EventDispatcher';
+import { WebXRSession } from './WebXRSession.js';
 import { StateDispatcher } from '../modules/StateDispatcher';
 import { WebGLRenderer } from 'three';
 import { CSS2DRenderer } from 'three/examples/jsm/renderers/CSS2DRenderer.js';

package/build/types/src/viewer/updateTilesCamera.d.ts

@@ -0,0 +1,2 @@
+/** Keep tile screen-space error tied to the current headset eye viewport. */
+export function updateTilesCamera(tiles: any, camera: any, renderer: any): void;

package/build/viewer.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./main-DFAyOsl5.cjs"),t=require("./index-D87IZDc6.cjs");exports.Viewer=e.Viewer,exports.ViewerEvents=e.ViewerEvents,exports.computeElevation=t.computeElevation;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./main-DOWS9MQ7.cjs"),t=require("./index-XZNzHig1.cjs");exports.Viewer=e.Viewer,exports.ViewerEvents=e.ViewerEvents,exports.computeElevation=t.computeElevation;

package/build/viewer.js

@@ -1,7 +1,7 @@
-import { V, a } from "./main-CY1MzgxV.js";
-import { bw } from "./index-DaqGSC4W.js";
+import { V, a } from "./main-CEG3MR57.js";
+import { by } from "./index-a8PLKOvo.js";
 export {
   V as Viewer,
   a as ViewerEvents,
-  bw as computeElevation
+  by as computeElevation
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@splnlss/3d-story-viewer",
-    "version": "0.8.1",
+    "version": "0.8.3",
     "publishConfig": {
         "access": "public",
         "registry": "https://registry.npmjs.org/"