@lumiscaphe/viewer 4.0.12 → 4.1.1

package/.prettierrc

@@ -0,0 +1,6 @@
+{
+  "arrowParens": "avoid",
+  "printWidth": 1000,
+  "singleQuote": true,
+  "trailingComma": "none"
+}

package/dist/Canvas2D.d.ts

@@ -1,15 +1,18 @@
+import { Resolution } from './Resolution';
 export declare class Canvas2D {
     element: HTMLCanvasElement;
     image?: HTMLImageElement;
-    private fit;
+    fit: 'contain' | 'cover' | 'fill';
     private context;
     private backCanvas;
     private backContext;
+    private pixelRatio;
     private requestAnimationId?;
     constructor(fit: 'contain' | 'cover' | 'fill');
     destroy(): void;
     show(useDisplay: boolean): void;
     hide(useDisplay: boolean): void;
+    get resolution(): Resolution;
     resize(width: number, height: number, pixelRatio: number): void;
     draw(img: HTMLImageElement, fade: boolean, speed?: number): void;
     private fadeLoop;

package/dist/Database.d.ts

@@ -0,0 +1,25 @@
+import { PointOfView } from './PointOfView';
+interface Camera {
+    id: string;
+    name: string;
+    pointOfView: PointOfView;
+}
+interface CameraGroup {
+    id: string;
+    name: string;
+    cameras: Camera[];
+}
+export declare class Database {
+    xmlDoc: Document;
+    constructor(xmlDoc: Document);
+    get id(): string | null | undefined;
+    getCameraId(cameraName: string, cameraGroup?: string): string | null | undefined;
+    getCameraById(cameraId: string, groupId?: string): Camera | null;
+    getCameraByName(cameraName: string, groupName?: string): Camera | null;
+    getCameraGroupId(cameraGroup: string): string | null | undefined;
+    getCameraGroupById(id: string): CameraGroup | null;
+    getCameraGroupByName(name: string): CameraGroup | null;
+    private mapElementToCamera;
+    private mapElementToCameraGroup;
+}
+export {};

package/dist/Loader.d.ts

@@ -1,12 +1,15 @@
 import { Hotspot } from './Hotspot';
 import { LoaderDelegate } from './LoaderDelegate';
 import { Snapshot } from './Snapshot';
+import { WRAPIv2 } from './WRAPIv2';
 export declare class Loader {
     private webrender;
+    private webrenderV2?;
     private delegate?;
     private loadingId;
     private loaded;
     private total;
+    private databases;
     constructor(server: string, api: string, delegate: LoaderDelegate);
     get progress(): number;
     loadImageSnapshot(snapshot: Snapshot): Promise<HTMLImageElement>;
@@ -18,9 +21,15 @@ export declare class Loader {
     private loadVideo;
     private loadVideoFrame;
     private loadVideoFrames;
-    loadImageHotspots(snapshot: Snapshot, tags: string[]): Promise<Hotspot[]>;
-    loadVRCubeHotspots(snapshot: Snapshot, tags: string[]): Promise<Hotspot[][]>;
-    loadVRObjectHotspots(snapshot: Snapshot, tags: string[]): Promise<Hotspot[][]>;
+    loadImageHotspots(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>): Promise<Hotspot[]>;
+    loadVRCubeHotspots(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>): Promise<Hotspot[][]>;
+    loadVRObjectHotspots(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>): Promise<Hotspot[][]>;
+    loadImagePick(snapshot: Snapshot, position: WRAPIv2.Vector2D): Promise<WRAPIv2.PickResult>;
+    loadVRObjectPick(snapshot: Snapshot, position: WRAPIv2.Vector2D, index: number, frames: number): Promise<WRAPIv2.PickResult>;
+    loadVRCubePick(snapshot: Snapshot, position: WRAPIv2.Vector2D, face: string): Promise<WRAPIv2.PickResult>;
+    private convert;
+    private vrObjectFrameSnapshot;
+    private vrCubeFrameSnapshot;
     private onLoadStart;
     private onLoadProgress;
     private onLoadEnd;

package/dist/Maths.d.ts

@@ -1,6 +1,7 @@
 import { m4 } from 'twgl.js';
 export declare class Maths {
     static accelerate(v: number, f: number): number;
+    static clamp(v: number, min: number, max: number): number;
     static degreesToRadians(a: number): number;
     static radiansToDegrees(a: number): number;
     static mod(x: number, y: number): number;

package/dist/PointOfView.d.ts

@@ -4,6 +4,7 @@ export declare class PointOfView {
     eye: v3.Vec3;
     up: v3.Vec3;
     static readonly default: PointOfView;
+    static initCubeFace(eye: v3.Vec3, target: v3.Vec3, face: string): PointOfView;
     constructor(target: v3.Vec3, eye: v3.Vec3, up: v3.Vec3);
     get viewVector(): v3.Vec3;
     get rightVector(): v3.Vec3;

package/dist/Spherical.d.ts

@@ -0,0 +1,11 @@
+import { v3 } from 'twgl.js';
+import { PointOfView } from './PointOfView';
+export declare class Spherical {
+    target: v3.Vec3;
+    longitude: number;
+    latitude: number;
+    distance: number;
+    constructor(pov: PointOfView);
+    get vector(): v3.Vec3;
+    pointOfView(target: v3.Vec3): PointOfView;
+}

package/dist/View.d.ts

@@ -1,6 +1,6 @@
 export interface View {
     mode: string;
-    camera?: string;
+    camera?: string | any;
     background?: string;
     animation?: string;
     frames?: number;

package/dist/Viewer.d.ts

@@ -7,6 +7,7 @@ import { Transition } from './Transition';
 import { View } from './View';
 import { WidgetVRCube } from './WidgetVRCube';
 import { WidgetVRObject } from './WidgetVRObject';
+import { WRAPIv2 } from './WRAPIv2';
 import './index.css';
 export declare class Viewer {
     options: Options;
@@ -21,7 +22,7 @@ export declare class Viewer {
     private view?;
     private parameters;
     private encoder;
-    private tags?;
+    private hotspots;
     private resolution;
     private widget;
     private widgetImage;
@@ -34,13 +35,14 @@ export declare class Viewer {
     load(scene: Scene | Scene[], transition?: Transition): Promise<void>;
     setEncoder(encoder: Encoder): Promise<void>;
     setParameters(parameters: Parameters): Promise<void>;
-    setTags(tags: string[]): void;
+    setHotspots(hotspots: Array<string | WRAPIv2.Vector3D>): void;
     setView(view: View, transition?: Transition): Promise<void>;
     setVrcube(data: Partial<WidgetVRCube>): void;
     setVrobject(data: Partial<WidgetVRObject>): void;
     private loadAnimation;
     playAnimation(animation: Animation): Promise<void>;
     stopAnimation(): void;
+    pick(position: WRAPIv2.Vector2D): Promise<WRAPIv2.PickResult>;
     snapshot(type: string, quality: number): string;
     private loadWidget;
     private get viewWidget();

package/dist/Viewport.d.ts

@@ -1,3 +1,4 @@
+import { Position } from './Position';
 import { Resolution } from './Resolution';
 export declare class Viewport {
     top: number;
@@ -6,6 +7,8 @@ export declare class Viewport {
     height: number;
     constructor(top: number, left: number, width: number, height: number);
     static fit(resolution: Resolution, viewportResolution: Resolution, fit: 'contain' | 'cover' | 'fill'): Viewport;
+    static project(resolution: Resolution, viewportResolution: Resolution, fit: 'contain' | 'cover' | 'fill', position: Position): Position;
+    static unproject(resolution: Resolution, viewportResolution: Resolution, fit: 'contain' | 'cover' | 'fill', position: Position): Position;
     static getStandardAspectRatio(width: number, height: number): number;
     static getStandardResolution(width: number, height: number): Resolution;
     private static getStandardQuality;

package/dist/WRAPIv2.d.ts

@@ -49,7 +49,8 @@ export declare namespace WRAPIv2 {
         scene: Scene;
         mode: AnimationMode | ImageMode | ImagesMode | VrCubeMode | VrObjectMode;
         renderParameters?: RenderParameters;
-        tags: string[];
+        positions?: Vector3D[];
+        tags?: string[];
     }
     interface ImageMode {
         image: {

package/dist/WebRenderStatic.d.ts

@@ -1,7 +1,9 @@
+import { Database } from './Database';
 import { Snapshot } from './Snapshot';
 export declare class WebRenderStatic {
     constructor();
     animation(snapshot: Snapshot): Promise<string[]>;
+    database(databaseId: string): Promise<Database>;
     image(snapshot: Snapshot): Promise<string>;
     video(snapshot: Snapshot): Promise<string>;
     vrCube(snapshot: Snapshot): Promise<string[]>;

package/dist/WebRenderV1.d.ts

@@ -1,3 +1,4 @@
+import { Database } from './Database';
 import { Snapshot } from './Snapshot';
 export declare class WebRenderV1 {
     private server;
@@ -9,6 +10,7 @@ export declare class WebRenderV1 {
     private static encoderParameters;
     private static fetch;
     animation(snapshot: Snapshot): Promise<string[]>;
+    database(databaseId: string): Promise<Database>;
     image(snapshot: Snapshot): Promise<string>;
     video(snapshot: Snapshot): Promise<string>;
     vrCube(snapshot: Snapshot): Promise<string[]>;

package/dist/WebRenderV2.d.ts

@@ -1,5 +1,7 @@
+import { Database } from './Database';
 import { Hotspot } from './Hotspot';
 import { Snapshot } from './Snapshot';
+import { WRAPIv2 } from './WRAPIv2';
 export declare class WebRenderV2 {
     private server;
     constructor(server: string);
@@ -10,11 +12,15 @@ export declare class WebRenderV2 {
     private static fetchFrameArray;
     private static fetchHotspots;
     private static fetchHotspotsArray;
+    private static fetchPick;
+    database(databaseId: string): Promise<Database>;
     image(snapshot: Snapshot): Promise<string>;
     vrCube(snapshot: Snapshot): Promise<string[]>;
     vrObject(snapshot: Snapshot): Promise<string[]>;
     animation(snapshot: Snapshot): Promise<string[]>;
-    imageHotspots(snapshot: Snapshot, tags: string[]): Promise<Hotspot[]>;
-    vrCubeHotspots(snapshot: Snapshot, tags: string[]): Promise<Hotspot[][]>;
-    vrObjectHotspots(snapshot: Snapshot, tags: string[]): Promise<Hotspot[][]>;
+    imageHotspots(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>): Promise<Hotspot[]>;
+    imagePick(snapshot: Snapshot, position: WRAPIv2.Vector2D): Promise<WRAPIv2.PickResult>;
+    vrCubeHotspots(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>): Promise<Hotspot[][]>;
+    vrObjectHotspots(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>): Promise<Hotspot[][]>;
+    private hotspotsBody;
 }

package/dist/Widget.d.ts

@@ -1,10 +1,14 @@
 import { Hotspot } from './Hotspot';
+import { Resolution } from './Resolution';
 import { Snapshot } from './Snapshot';
+import { WRAPIv2 } from './WRAPIv2';
 export interface Widget {
     destroy(): void;
     show(): void;
     hide(): void;
-    load(snapshot: Snapshot, tags: string[], reset: boolean, fade: boolean): Promise<Hotspot[]>;
+    load(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>, reset: boolean, fade: boolean): Promise<void>;
+    hotspots(resolution: Resolution): Hotspot[];
+    pick(snapshot: Snapshot, position: WRAPIv2.Vector2D): Promise<WRAPIv2.PickResult>;
     snapshot(type: string, quality: number): string;
     onMouseDown(e: MouseEvent): void;
     onMouseEnter(e: MouseEvent): void;

package/dist/WidgetImage.d.ts

@@ -1,21 +1,25 @@
 import { Canvas2D } from './Canvas2D';
 import { Hotspot } from './Hotspot';
 import { Loader } from './Loader';
+import { Resolution } from './Resolution';
 import { Snapshot } from './Snapshot';
 import { Widget } from './Widget';
+import { WRAPIv2 } from './WRAPIv2';
 export declare class WidgetImage implements Widget {
     private container;
     private canvas;
     private loader;
     private image?;
-    private hotspots;
+    private hotspotList;
+    private hotspotsHash?;
     private snapshotHash?;
-    private tagsHash?;
     constructor(container: HTMLElement, canvas: Canvas2D, loader: Loader);
     destroy(): void;
     show(): void;
     hide(): void;
-    load(snapshot: Snapshot, tags: string[], reset: boolean, fade: boolean): Promise<Hotspot[]>;
+    load(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>, reset: boolean, fade: boolean): Promise<void>;
+    pick(snapshot: Snapshot, position: WRAPIv2.Vector2D): Promise<WRAPIv2.PickResult>;
+    hotspots(resolution: Resolution): Hotspot[];
     snapshot(type: string, quality: number): string;
     onMouseDown(e: MouseEvent): void;
     onMouseMove(e: MouseEvent): void;

package/dist/WidgetVRCube.d.ts

@@ -4,6 +4,7 @@ import { Loader } from './Loader';
 import { PointOfView } from './PointOfView';
 import { Snapshot } from './Snapshot';
 import { Widget } from './Widget';
+import { WRAPIv2 } from './WRAPIv2';
 export declare class WidgetVRCube implements Widget {
     private container;
     private canvas;
@@ -16,8 +17,8 @@ export declare class WidgetVRCube implements Widget {
     private programInfo;
     private quad;
     private uniforms;
+    private hotspotsHash?;
     private snapshotHash?;
-    private tagsHash?;
     private animationFrameId?;
     constructor(container: HTMLElement, canvas: Canvas3D, loader: Loader, onInteraction: (...args: any[]) => void);
     destroy(): void;
@@ -27,8 +28,9 @@ export declare class WidgetVRCube implements Widget {
     set pov(pov: PointOfView);
     get fov(): number;
     set fov(fov: number);
-    get hotspots(): Hotspot[];
-    load(snapshot: Snapshot, tags: string[], reset: boolean, fade: boolean): Promise<Hotspot[]>;
+    load(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>, reset: boolean, fade: boolean): Promise<void>;
+    pick(snapshot: Snapshot, position: WRAPIv2.Vector2D): Promise<WRAPIv2.PickResult>;
+    hotspots(): Hotspot[];
     snapshot(type: string, quality: number): string;
     private get modelViewProjectionMatrix();
     render(): void;

package/dist/WidgetVRObject.d.ts

@@ -1,8 +1,10 @@
 import { Canvas2D } from './Canvas2D';
 import { Hotspot } from './Hotspot';
 import { Loader } from './Loader';
+import { Resolution } from './Resolution';
 import { Snapshot } from './Snapshot';
 import { Widget } from './Widget';
+import { WRAPIv2 } from './WRAPIv2';
 export declare class WidgetVRObject implements Widget {
     private container;
     private canvas;
@@ -12,8 +14,8 @@ export declare class WidgetVRObject implements Widget {
     private hotspotsList;
     private interaction;
     private onInteraction;
+    private hotspotsHash?;
     private snapshotHash?;
-    private tagsHash?;
     private animationFrameId?;
     constructor(container: HTMLElement, canvas: Canvas2D, loader: Loader, onInteraction: (...args: any[]) => void);
     destroy(): void;
@@ -23,8 +25,9 @@ export declare class WidgetVRObject implements Widget {
     get position(): number;
     set position(position: number);
     get image(): HTMLImageElement;
-    get hotspots(): Hotspot[];
-    load(snapshot: Snapshot, tags: string[], reset: boolean, fade: boolean): Promise<Hotspot[]>;
+    load(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>, reset: boolean, fade: boolean): Promise<void>;
+    pick(snapshot: Snapshot, position: WRAPIv2.Vector2D): Promise<WRAPIv2.PickResult>;
+    hotspots(resolution: Resolution): Hotspot[];
     snapshot(type: string, quality: number): string;
     onMouseDown(e: MouseEvent): void;
     onMouseMove(e: MouseEvent): void;

package/dist/WidgetVideo.d.ts

@@ -1,8 +1,10 @@
 import { Hotspot } from './Hotspot';
 import { Loader } from './Loader';
+import { Resolution } from './Resolution';
 import { Snapshot } from './Snapshot';
 import { Video } from './Video';
 import { Widget } from './Widget';
+import { WRAPIv2 } from './WRAPIv2';
 export declare class WidgetVideo implements Widget {
     private container;
     private loader;
@@ -12,7 +14,9 @@ export declare class WidgetVideo implements Widget {
     destroy(): void;
     show(): void;
     hide(): void;
-    load(snapshot: Snapshot): Promise<Hotspot[]>;
+    load(snapshot: Snapshot): Promise<void>;
+    pick(snapshot: Snapshot, position: WRAPIv2.Vector2D): Promise<WRAPIv2.PickResult>;
+    hotspots(resolution: Resolution): Hotspot[];
     snapshot(type: string, quality: number): string;
     play(): Promise<void>;
     onMouseDown(e: MouseEvent): void;

package/dist/index.d.ts

@@ -9,8 +9,8 @@ export * from './View';
 export * from './Viewer';
 export * from './Widget';
 export * from './WidgetImage';
-export * from './WidgetVideo';
 export * from './WidgetVRCube';
 export * from './WidgetVRObject';
+export * from './WidgetVideo';
 export * from './WRAPIv1';
 export * from './WRAPIv2';