@splnlss/3d-story-viewer 0.8.0 → 0.8.2

package/build/{spark.module-B1FWS-vq.js → spark.module-T7c-X7OV.js}

@@ -1,5 +1,5 @@
-import { V as Vector3, a as Vector2, ak as Euler, M as Matrix4, Q as Quaternion, k as Color, aF as Vector4, bx as DataArrayTexture, by as RGIntegerFormat, bz as UnsignedIntType, bA as RGBAIntegerFormat, bB as WebGLArrayRenderTarget, y as NearestFilter, au as DataTexture, e as Raycaster, aO as RGBAFormat, at as UnsignedByteType, O as Object3D, b as Mesh, c as ShaderMaterial, W as DoubleSide, bC as GLSL3, bD as Timer, az as WebGLRenderTarget, m as SRGBColorSpace, ap as Matrix3, af as ColorManagement, a3 as PerspectiveCamera, a4 as OrthographicCamera, bE as WebGLCubeRenderTarget, l as LinearSRGBColorSpace, x as LinearFilter, av as LinearMipMapLinearFilter, bF as CubeCamera, bG as Camera, bH as PMREMGenerator, U as MeshStandardMaterial, L as Loader, F as FileLoader, ai as Box3, bh as UnsignedShortType, aI as FloatType, S as ShaderChunk, bI as InstancedBufferGeometry, s as BufferAttribute, aE as Matrix2, aK as REVISION, bJ as RawShaderMaterial } from "./index-Hz3jbrou.js";
-import { F as FullScreenQuad } from "./main-Bdopx4KL.js";
+import { V as Vector3, a as Vector2, ak as Euler, M as Matrix4, Q as Quaternion, k as Color, bb as Vector4, bz as DataArrayTexture, bA as RGIntegerFormat, bB as UnsignedIntType, bC as RGBAIntegerFormat, bD as WebGLArrayRenderTarget, y as NearestFilter, aX as DataTexture, e as Raycaster, aQ as RGBAFormat, aR as UnsignedByteType, O as Object3D, b as Mesh, c as ShaderMaterial, W as DoubleSide, bE as GLSL3, bF as Timer, b5 as WebGLRenderTarget, m as SRGBColorSpace, ap as Matrix3, af as ColorManagement, a3 as PerspectiveCamera, a4 as OrthographicCamera, bG as WebGLCubeRenderTarget, l as LinearSRGBColorSpace, x as LinearFilter, b1 as LinearMipMapLinearFilter, bH as CubeCamera, bI as Camera, bJ as PMREMGenerator, U as MeshStandardMaterial, L as Loader, F as FileLoader, ai as Box3, aV as UnsignedShortType, aW as FloatType, S as ShaderChunk, bK as InstancedBufferGeometry, s as BufferAttribute, ba as Matrix2, be as REVISION, bL as RawShaderMaterial } from "./index-BgprA821.js";
+import { F as FullScreenQuad } from "./main-BUCkukV4.js";
 const LN_SCALE_MIN = -12;
 const LN_SCALE_MAX = 9;
 const SCALE_MIN = Math.exp(LN_SCALE_MIN);

package/build/types/src/viewer/ContentLayer/TilesLayer.d.ts

@@ -4,11 +4,11 @@ export class TilesLayer extends ContentLayer {
     firstSet: any;
     camera: any;
     renderer: any;
-    dracoLoader: DRACOLoader;
-    ktx2loader: KTX2Loader;
+    ownsDecoders: boolean;
+    decoders: any;
+    dracoLoader: any;
+    ktx2loader: any;
     tiles: TilesRenderer<import("3d-tiles-renderer").TilesRendererEventMap>;
 }
 import { ContentLayer } from '.';
-import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
-import { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader.js';
 import { TilesRenderer } from '3d-tiles-renderer';

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

@@ -4,7 +4,9 @@ export class GlobeManager extends EventDispatcher {
     camera: any;
     renderer: any;
     tiles: TilesRenderer<import("3d-tiles-renderer").TilesRendererEventMap>;
-    dracoLoader: DRACOLoader;
+    dracoLoader: any;
+    ownsDecoders: boolean;
+    decoders: any;
     apiToken: any;
     googleMapsToken: any;
     initTiles(): void;
@@ -13,4 +15,3 @@ export class GlobeManager extends EventDispatcher {
 }
 import { EventDispatcher } from '../modules/EventDispatcher';
 import { TilesRenderer } from '3d-tiles-renderer';
-import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';

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

@@ -0,0 +1,11 @@
+/** One lazy decoder owner per Viewer/WebGLRenderer. No tile queue or cache ownership. */
+export class TileDecoders {
+    constructor(renderer: any);
+    renderer: any;
+    draco: any;
+    ktx2: any;
+    disposed: boolean;
+    getDraco(): any;
+    getKTX2(): any;
+    dispose(): void;
+}

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

@@ -0,0 +1,75 @@
+/** @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;
+        getControllerWorldRay: (controller: any) => {
+            origin: import("three").Vector3Tuple;
+            direction: import("three").Vector3Tuple;
+        };
+        setNavigationCue: (cue: any) => void;
+        setTerrainCredits: (credits: any) => void;
+        setPlayerPose(pose: 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,48 @@
+/** @typedef {{worldEcef: [number, number, number], geodetic: {longitude: number, latitude: number, altitude: number}, headingDegrees: number, localHeadOffset: [number, number, number]}} XRHeadPose */
+/** 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;
+    worldFromLocal: Matrix4;
+    anchor: {
+        longitude: number;
+        latitude: number;
+        altitude: number;
+    };
+    /** @param {XRRigidTransform} pose */
+    updateHeadPose(pose: XRRigidTransform): void;
+    getWorldFromLocalMatrix(): Matrix4;
+    getWorldHeadMatrix(): Matrix4;
+    /** @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.
+     */
+    setPose({ anchor, east, north, up, headingDegrees }: {
+        anchor: any;
+        east?: number;
+        north?: number;
+        up?: number;
+        headingDegrees: 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];
+};
+import { Matrix4 } from 'three';

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

@@ -0,0 +1,25 @@
+/**
+ * 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;
+    getControllerWorldRay: (controller: any) => {
+        origin: import("three").Vector3Tuple;
+        direction: import("three").Vector3Tuple;
+    };
+    setNavigationCue: (cue: any) => void;
+    setTerrainCredits: (credits: any) => void;
+    setPlayerPose(pose: 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;
@@ -43,6 +44,7 @@ declare class Viewer extends EventDispatcher {
     globeControls: GlobeControls;
     _onGlobeControlsStart: () => void;
     transitionControls: TransitionControls;
+    tileDecoders: TileDecoders;
     globeManager: GlobeManager;
     /** @type {ViewerCoords} */
     cameraCoords: ViewerCoords;
@@ -79,6 +81,86 @@ 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 {{ anchor: { longitude: number, latitude: number, altitude: number }, east?: number, north?: number, up?: number, headingDegrees: number }} pose */
+    setXRPlayerPose(pose: {
+        anchor: {
+            longitude: number;
+            latitude: number;
+            altitude: number;
+        };
+        east?: number;
+        north?: number;
+        up?: number;
+        headingDegrees: number;
+    }): void;
+    /** @returns {import('./XRPlayerRig.js').XRHeadPose | null} */
+    getXRHeadPose(): import("./XRPlayerRig.js").XRHeadPose | 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;
@@ -196,6 +278,7 @@ export namespace ViewerEvents {
     let CONTENT_LAYER_ERROR: "content-layer-error";
 }
 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';
@@ -206,6 +289,7 @@ import { Scene } from 'three';
 import { Group } from 'three';
 import { GlobeControls } from './GlobeControls';
 import { TransitionControls } from './TransitionControls';
+import { TileDecoders } from './TileDecoders.js';
 import { GlobeManager } from './GlobeManager';
 import { Sky } from './Sky';
 import { Raycaster } from 'three';

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-CaYKxosA.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-yri0wVzb.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-Bdopx4KL.js";
-import { bw } from "./index-Hz3jbrou.js";
+import { V, a } from "./main-BUCkukV4.js";
+import { by } from "./index-BgprA821.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.0",
+    "version": "0.8.2",
     "publishConfig": {
         "access": "public",
         "registry": "https://registry.npmjs.org/"