locar 0.2.2 → 0.2.4

package/dist/locar.d.ts

@@ -1,375 +0,0 @@
-import { EventDispatcher } from 'three';
-import { Object3D } from 'three';
-import { Quaternion } from 'three';
-import * as THREE from 'three';
-
-/** Application class to orchestrate the interaction between the individual LocAR classes and the Three.js camera, renderer and scene. */
-export declare class App extends EventEmitter {
-    #private;
-    locar: LocAR;
-    camera: THREE.PerspectiveCamera;
-    renderer: THREE.WebGLRenderer;
-    scene: THREE.Scene;
-    webcam: Webcam;
-    deviceOrientationControls: DeviceOrientationControls | null;
-    cameraFeedDimensions: {
-        landWidth: number;
-        landHeight: number;
-    } | null; /** camera feed dimensions in LANDSCAPE  */
-    origHfov: number;
-    /**
-     * Create an App object.
-     * @param {AppOptions} - Startup options.
-     */
-    constructor({ cameraOptions, canvas, gpsOptions, videoConstraints, deviceOrientationOptions, serverLogger, projection }: AppOptions);
-    /**
-     * Start the app.
-     * Must be called after construction.
-     * @returns {Promise<LocAR>}
-     * Promise resolving with LocAR object. Rejects with object containing code and message.
-     */
-    start(): Promise<LocAR>;
-}
-
-/** Options to pass into the App object. */
-export declare interface AppOptions {
-    /** the three.js camera options to use - note however we specify horizontal, not vertical, field of view */
-    cameraOptions?: {
-        hFov: number;
-        near: number;
-        far: number;
-    };
-    /** the canvas to render the AR scene into (one will be created if omitted) */
-    canvas?: HTMLCanvasElement;
-    /** GPS options, see GpsOptions documentation for details */
-    gpsOptions?: GpsOptions;
-    /** Video constraints for Media Devices API */
-    videoConstraints?: {
-        video: {
-            facingMode: string;
-        };
-    };
-    /** Device orientation options for DeviceOrientationControls */
-    deviceOrientationOptions?: DeviceOrientationControlsOptions & {
-        enabled: boolean;
-    };
-    /** Projection to use (default: SphMercProjection) */
-    projection?: Projection;
-    /** Server logger to use - ensure you gain consent from the user if you are doing this, it's usually a Data Protection legal requirement */
-    serverLogger?: ServerLogger;
-}
-
-/**
- * Class to handle object detection via mouse clicks/touch events
- * and raycasting.
- */
-export declare class ClickHandler {
-    raycaster: THREE.Raycaster;
-    normalisedMousePosition: THREE.Vector2 | null;
-    /**
-     * Create a ClickHandler.
-     * @param {THREE.WebGLRenderer} - The Three.js renderer on which the click
-     * events will be handled.
-     */
-    constructor(renderer: THREE.WebGLRenderer);
-    /**
-     * Cast a ray into the scene to detect objects.
-     * @param {THREE.Camera} - The active Three.js camera, from which the ray
-     * will be cast.
-     * @param {THREE.Scene} - The active Three.js scene, which the ray will be
-     * cast into.
-     * @return {Array} - array of all intersected objects.
-     */
-    raycast(camera: THREE.Camera, scene: THREE.Scene): THREE.Intersection[];
-}
-
-export declare class DeviceOrientationControls extends EventDispatcher {
-    eventEmitter: EventEmitter;
-    object: Object3D;
-    enabled: boolean;
-    deviceOrientation: {
-        alpha?: number;
-        beta?: number;
-        gamma?: number;
-        webkitCompassHeading?: number;
-        absolute?: boolean;
-    } | null;
-    screenOrientation: number;
-    alphaOffset: number;
-    orientationOffset: number;
-    initialOffset: boolean | null;
-    lastQuaternion: Quaternion | null;
-    orientationChangeEventName: "deviceorientation" | "deviceorientationabsolute";
-    smoothingFactor: number;
-    enablePermissionDialog: boolean;
-    enableInlineStyling: boolean;
-    preferConfirmDialog: boolean;
-    orientationChangeThreshold: number;
-    connect: () => void;
-    disconnect: () => void;
-    requestOrientationPermissions: () => void;
-    update: () => void;
-    getCorrectedHeading: () => number;
-    updateAlphaOffset: () => void;
-    dispose: () => void;
-    getAlpha: () => number;
-    getBeta: () => number;
-    getGamma: () => number;
-    createObtainPermissionGestureDialog: () => void;
-    obtainPermissionGesture: () => void;
-    /**
-     * Create an instance of DeviceOrientationControls.
-     * @param {Object} object - the object to attach the controls to
-     * (usually your Three.js camera)
-     * @param {Object} options - options for DeviceOrientationControls:
-     * currently accepts smoothingFactor (< 1), enablePermissionDialog, orientationChangeThreshold (radians)
-     */
-    constructor(object: Object3D, options?: DeviceOrientationControlsOptions);
-    on(eventName: string, eventHandler: (event: any) => void): void;
-    /**
-     * Initialise device orientation controls.
-     * Should be called after you have created the DeviceOrientationControls
-     * object and set up the deviceorientationgranted and deviceorientationerror
-     * event handlers.
-     */
-    init: () => void;
-}
-
-/** Options to pass into DeviceOrientationControls. */
-export declare type DeviceOrientationControlsOptions = {
-    /** smoothingFactor - default 0.2. If too high, AR content movement will lag behind the sensors. If too low, the scene will be jittery. */
-    smoothingFactor?: number;
-    /** Movement threshold to detect an orientation change (radians). */
-    orientationChangeThreshold?: number;
-    /** On iOS, enable permission dialog to seek permission to use device orientation through a user gesture. Recommended to set to true */
-    enablePermissionDialog?: boolean;
-    /** Set iOS-look and feel styling for the permission dialog for device orientation */
-    enableStyling?: boolean;
-    /** Use a standard confirm dialog rather than a custom element to grant device orientation permissions */
-    preferConfirmDialog?: boolean;
-};
-
-/** Event emitted when there is an error with device orientation. */
-export declare interface DeviceOrientationErrorEvent {
-    code: string;
-    message: string;
-}
-
-/** Event emitted when device orientation permission has been granted. */
-export declare interface DeviceOrientationGrantedEvent {
-    target: DeviceOrientationControls;
-}
-
-/** Event emitter class to handle events. */
-export declare class EventEmitter {
-    eventHandlers: Record<string, ((...args: any[]) => void)[]>;
-    constructor();
-    /**
-     * Add an event handler.
-     * @param {string} eventName - the event to handle.
-     * @param {Function} eventHandler - the event handler function.
-     */
-    on: (eventName: string, eventHandler: (...args: any[]) => void) => void;
-    /**
-     * Emit an event.
-     * @param {string} eventName - the event to emit.
-     * @param ...params - parameters to pass to the event handlers.
-     */
-    emit: (eventName: string, ...params: any[]) => void;
-    /**
-     * Remove an event handler.
-     * @param {string} eventName - the event to remove a handler from.
-     * @param {Function} eventHandler - the event handler function to remove.
-     */
-    off: (eventName: string, eventHandler: (...args: any[]) => void) => void;
-}
-
-/** GPS intialisation options. */
-export declare interface GpsOptions {
-    gpsMinDistance?: number;
-    gpsMinAccuracy?: number;
-}
-
-/** Event emitted when a GPS position is received. */
-export declare interface GpsReceivedEvent {
-    /** The new GPS position */
-    position: GeolocationPosition;
-    /** distance moved in metres since last GpsReceivedEvent */
-    distMoved: number;
-}
-
-/** The main engine class for the LocAR.js system.
- * Can be obtained either via App.start() - which resolves with a LocAR object - or on its own.
- * If you use this class without App, you must set up the three.js scene yourself, as you did with locar.js 0.1.x.
- */
-export declare class LocAR extends EventEmitter {
-    #private;
-    scene: THREE.Scene;
-    camera: THREE.Camera;
-    /**
-     * @param {THREE.Scene} scene - The Three.js scene to use.
-     * @param {THREE.Camera} camera - The Three.js camera to use. Should usually
-     * be a THREE.PerspectiveCamera.
-     * @param {Object} options - Initialisation options for the GPS; see
-     * setGpsOptions() below.
-     * @param {Object} serverLogger - an object which can optionally log GPS position to a server for debugging. null by default, so no logging will be done. This object should implement a sendData() method to send data (2nd arg) to a given endpoint (1st arg). Please see source code for details. Ensure you comply with privacy laws (GDPR or equivalent) if implementing this.
-     */
-    constructor(scene: THREE.Scene, camera: THREE.Camera, options?: GpsOptions, serverLogger?: ServerLogger | null, projection?: Projection);
-    /**
-     * Set the projection to use.
-     * @param {Object} any object which includes a project() method
-     * taking longitude and latitude as arguments and returning an array
-     * containing easting and northing.
-     */
-    setProjection(proj: Projection): void;
-    /**
-     * Set the GPS options.
-     * @param {Object} object containing gpsMinDistance and/or gpsMinAccuracy
-     * properties. The former specifies the number of metres which the device
-     * must move to process a new GPS reading, and the latter specifies the
-     * minimum accuracy, in metres, for a GPS reading to be counted.
-     */
-    setGpsOptions(options?: GpsOptions): void;
-    /**
-     * Start the GPS on a real device
-     * @return {boolean} code indicating whether the GPS was started successfully.
-     * GPS errors can be handled by handling the gpserror event.
-     */
-    startGps(): Promise<boolean>;
-    /**
-     * Stop the GPS on a real device
-     * @return {boolean} true if the GPS was stopped, false if it could not be
-     * stopped (i.e. it was never started).
-     */
-    stopGps(): boolean;
-    /**
-     * Send a fake GPS signal. Useful for testing on a desktop or laptop.
-     * @param {number} lon - The longitude.
-     * @param {number} lat - The latitude.
-     * @param {number} elev - The elevation in metres. (optional, set to null
-     * for no elevation).
-     * @param {number} acc - The accuracy of the GPS reading in metres. May be
-     * ignored if lower than the specified minimum accuracy.
-     */
-    fakeGps(lon: number, lat: number, elev?: number | null, acc?: number): void;
-    /**
-     * Convert longitude and latitude to three.js/WebGL world coordinates.
-     * Uses the specified projection, and negates the northing (in typical
-     * projections, northings increase northwards, but in the WebGL coordinate
-     * system, we face negative z if the camera is at the origin with default
-     * rotation).
-     * Must not be called until an initial position is determined.
-     * @param {number} lon - The longitude.
-     * @param {number} lat - The latitude.
-     * @return {Array} a two member array containing the WebGL x and z coordinates
-     */
-    lonLatToWorldCoords(lon: number, lat: number): number[];
-    /**
-     * Add a new AR object at a given latitude, longitude and elevation.
-     * @param {THREE.Mesh} object the object
-     * @param {number} lon - the longitude.
-     * @param {number} lat - the latitude.
-     * @param {number} elev - the elevation in metres
-     * (if not specified, 0 is assigned)
-     * @param {Object} properties - properties describing the object (for example,
-     * the contents of the GeoJSON properties field).
-     */
-    add(object: THREE.Object3D, lon: number, lat: number, elev?: number | undefined, properties?: Record<string, any>): void;
-    addGeoLine(points: Array<[number, number, number?]>, material: THREE.Material, lineWidth?: number): THREE.Mesh;
-    /**
-     * Set the elevation (y coordinate) of the camera.
-     * @param {number} elev - the elevation in metres.
-     */
-    setElevation(elev: number): void;
-    /**
-     * Calculate haversine distance between two lat/lon pairs.
-     *
-     * Taken from original A-Frame AR.js location-based components
-     */
-    static haversineDist(src: LonLat, dest: LonLat): number;
-    /**
-     * Obtain the last known GPS location.
-     *
-     * @return {Object} object containing latitude and longitude fields, or null if no previous GPS location.
-     */
-    getLastKnownLocation(): LonLat | null;
-}
-
-/** Longitude and latitude. */
-export declare interface LonLat {
-    longitude: number;
-    latitude: number;
-}
-
-/** Projection interface, you can create your own custom projection by implementing project() and unproject(). */
-export declare interface Projection {
-    project: (lon: number, lat: number) => [number, number];
-    unproject: (projected: [number, number]) => [number, number];
-}
-
-/** Server logger interface. */
-export declare interface ServerLogger {
-    sendData(endpoint: string, data: any): Promise<Response> | Response;
-}
-
-export declare class SphMercProjection implements Projection {
-    #private;
-    EARTH: number;
-    HALF_EARTH: number;
-    /**
-     * Create a SphMercProjection.
-     */
-    constructor();
-    /**
-     * Project a longitude and latitude into Spherical Mercator.
-     * @param {number} lon - the longitude.
-     * @param {number} lat - the latitude.
-     * @return {Array} Two-member array containing easting and northing.
-     */
-    project: (lon: number, lat: number) => [number, number];
-    /**
-     * Unproject a Spherical Mercator easting and northing.
-     * @param {Array} projected - Two-member array containing easting and northing
-     * @return {Array} Two-member array containing longitude and latitude
-     */
-    unproject: (projected: [number, number]) => [number, number];
-    /**
-     * Return the projection's ID.
-     * @return {string} The value "epsg:3857".
-     */
-    getID: () => string;
-}
-
-/** Class to setup the webcam. */
-export declare class Webcam extends EventEmitter {
-    #private;
-    sceneWebcam: THREE.Scene;
-    /**
-     * Create a Webcam.
-     * @param constraints {Object} - options to use for initialising the camera.
-     * This is the same constraints object as used by standard MediaDevices API.
-     * @param {string} videoElementSelector - selector to obtain the HTML video
-     * element to render the webcam feed. If a falsy value (e.g. null or
-     * undefined), a video element will be created.
-     */
-    constructor(constraints?: {
-        video: {
-            facingMode: string;
-        };
-    }, videoElementSelector?: string);
-    getVideoDimensions(): string;
-}
-
-/** Event emitted when the webcam encounters an error. */
-export declare interface WebcamErrorEvent {
-    code: string;
-    message: string;
-}
-
-/** Event emitted when the webcam starts. */
-export declare interface WebcamStartedEvent {
-    videoWidth: number;
-    videoHeight: number;
-}
-
-export { }