itowns 2.45.1 → 2.45.2-next.0

package/lib/Controls/PlanarControls.d.ts

@@ -0,0 +1,339 @@
+export namespace keys {
+    let CTRL: number;
+    let SPACE: number;
+    let T: number;
+    let Y: number;
+}
+export namespace STATE {
+    let NONE: number;
+    let DRAG: number;
+    let PAN: number;
+    let ROTATE: number;
+    let TRAVEL: number;
+    let ORTHO_ZOOM: number;
+}
+export namespace PLANAR_CONTROL_EVENT {
+    let MOVED: string;
+}
+export default PlanarControls;
+/**
+ * Planar controls is a camera controller adapted for a planar view, with animated movements.
+ * Usage is as follow :
+ * <ul>
+ *     <li><b>Left mouse button:</b> drag the camera (translation on the (xy) world plane).</li>
+ *     <li><b>Right mouse button:</b> pan the camera (translation on the vertical (z) axis of the world plane).</li>
+ *     <li><b>CTRL + Left mouse button:</b> rotate the camera around the focus point.</li>
+ *     <li><b>Wheel scrolling:</b> zoom toward the cursor position.</li>
+ *     <li><b>Wheel clicking:</b> smart zoom toward the cursor position (animated).</li>
+ *     <li><b>Y key:</b> go to the starting view (animated).</li>
+ *     <li><b>T key:</b> go to the top view (animated).</li>
+ * </ul>
+ *
+ * @class   PlanarControls
+ * @param   {PlanarView}    view                                the view where the controls will be used
+ * @param   {object}        options
+ * @param   {boolean}       [options.enabled=true]              Set to false to disable this control
+ * @param   {boolean}       [options.enableRotation=true]       Enable the rotation with the `CTRL + Left mouse button`
+ * and in animations, like the smart zoom.
+ * @param   {boolean}       [options.enableSmartTravel=true]    Enable smart travel with the `wheel-click / space-bar`.
+ * @param   {boolean}       [options.enablePan=true]            Enable pan movements with the `right-click`.
+ * @param   {number}        [options.rotateSpeed=2.0]           Rotate speed.
+ * @param   {number}        [options.maxPanSpeed=15]            Pan speed when close to maxAltitude.
+ * @param   {number}        [options.minPanSpeed=0.05]          Pan speed when close to the ground.
+ * @param   {number}        [options.zoomTravelTime=0.2]        Animation time when zooming.
+ * @param   {number}        [options.zoomFactor=2]              The factor the scale is multiplied by when zooming
+ * in and divided by when zooming out. This factor can't be null.
+ * @param   {number}        [options.maxResolution=0]           The smallest size in meters a pixel at the center of the
+ * view can represent.
+ * @param   {number}        [options.minResolution=Infinity]    The biggest size in meters a pixel at the center of the
+ * view can represent.
+ * @param   {number}        [options.maxAltitude=12000]         Maximum altitude reachable when panning or zooming out.
+ * @param   {number}        [options.groundLevel=200]           Minimum altitude reachable when panning.
+ * @param   {number}        [options.autoTravelTimeMin=1.5]     Minimum duration for animated travels with the `auto`
+ * parameter.
+ * @param   {number}        [options.autoTravelTimeMax=4]       Maximum duration for animated travels with the `auto`
+ * parameter.
+ * @param   {number}        [options.autoTravelTimeDist=20000]  Maximum travel distance for animated travel with the
+ * `auto` parameter.
+ * @param   {number}        [options.smartTravelHeightMin=75]     Minimum height above ground reachable after a smart
+ * travel.
+ * @param   {number}        [options.smartTravelHeightMax=500]    Maximum height above ground reachable after a smart
+ * travel.
+ * @param   {boolean}       [options.instantTravel=false]       If set to true, animated travels will have no duration.
+ * @param   {number}        [options.minZenithAngle=0]          The minimum reachable zenith angle for a camera
+ * rotation, in degrees.
+ * @param   {number}        [options.maxZenithAngle=82.5]       The maximum reachable zenith angle for a camera
+ * rotation, in degrees.
+ * @param   {boolean}       [options.handleCollision=true]
+ */
+declare class PlanarControls extends THREE.EventDispatcher<any> {
+    constructor(view: any, options?: {});
+    view: any;
+    camera: any;
+    enabled: any;
+    enableRotation: any;
+    enablePan: any;
+    maxAltitude: any;
+    zoomTravelTime: any;
+    rotateSpeed: any;
+    minPanSpeed: any;
+    maxPanSpeed: any;
+    zoomInFactor: any;
+    zoomOutFactor: number;
+    maxResolution: any;
+    minResolution: any;
+    groundLevel: any;
+    autoTravelTimeMin: any;
+    autoTravelTimeMax: any;
+    autoTravelTimeDist: any;
+    smartTravelHeightMin: any;
+    smartTravelHeightMax: any;
+    instantTravel: any;
+    minZenithAngle: number;
+    maxZenithAngle: number;
+    handleCollision: any;
+    minDistanceCollision: number;
+    enableSmartTravel: any;
+    state: number;
+    cursor: {
+        default: string;
+        drag: string;
+        pan: string;
+        travel: string;
+        rotate: string;
+        ortho_zoom: string;
+    };
+    _handlerOnKeyDown: (event: Event) => void;
+    _handlerOnMouseDown: (event: Event) => void;
+    _handlerOnMouseUp: (event: Event) => void;
+    _handlerOnMouseMove: (event: Event) => void;
+    _handlerOnMouseWheel: (event: Event) => void;
+    _handlerContextMenu: (event: Event) => void;
+    _handlerUpdate: (dt: number, updateLoopRestarted: boolean) => void;
+    dispose(): void;
+    /**
+     * update the view and camera if needed, and handles the animated travel
+     * @param   {number}    dt                  the delta time between two updates in millisecond
+     * @param   {boolean}   updateLoopRestarted true if we just started rendering
+     * @ignore
+     */
+    update(dt: number, updateLoopRestarted: boolean): void;
+    /**
+     * Initiate a drag movement (translation on (xy) plane). The movement value is derived from the actual world
+     * point under the mouse cursor. This allows user to 'grab' a world point and drag it to move.
+     *
+     * @ignore
+     */
+    initiateDrag(): void;
+    /**
+     * Handle the drag movement (translation on (xy) plane) when user moves the mouse while in STATE.DRAG. The
+     * drag movement is previously initiated by [initiateDrag]{@link PlanarControls#initiateDrag}. Compute the
+     * drag value and update the camera controls. The movement value is derived from the actual world point under
+     * the mouse cursor. This allows the user to 'grab' a world point and drag it to move.
+     *
+     * @ignore
+     */
+    handleDragMovement(): void;
+    /**
+     * Initiate a pan movement (local translation on (xz) plane).
+     *
+     * @ignore
+     */
+    initiatePan(): void;
+    /**
+     * Handle the pan movement (translation on local x / world z plane) when user moves the mouse while
+     * STATE.PAN. The drag movement is previously initiated by [initiatePan]{@link PlanarControls#initiatePan}.
+     * Compute the pan value and update the camera controls.
+     *
+     * @ignore
+     */
+    handlePanMovement(): void;
+    /**
+     * Initiate a rotate (orbit) movement.
+     *
+     * @ignore
+     */
+    initiateRotation(): void;
+    /**
+     * Handle the rotate movement (orbit) when user moves the mouse while in STATE.ROTATE. The movement is an
+     * orbit around `centerPoint`, the camera focus point (ground point at screen center). The rotate movement
+     * is previously initiated in [initiateRotation]{@link PlanarControls#initiateRotation}.
+     * Compute the new position value and update the camera controls.
+     *
+     * @ignore
+     */
+    handleRotation(): void;
+    /**
+     * Triggers a Zoom animated movement (travel) toward / away from the world point under the mouse cursor. The
+     * zoom intensity varies according to the distance between the camera and the point. The closer to the ground,
+     * the lower the intensity. Orientation will not change (null parameter in the call to
+     * [initiateTravel]{@link PlanarControls#initiateTravel} function).
+     *
+     * @param   {Event} event   the mouse wheel event.
+     * @ignore
+     */
+    initiateZoom(event: Event): void;
+    /**
+     * Handle the animated zoom change for an orthographic camera, when state is `ZOOM`.
+     *
+     * @param   {number}    dt  the delta time between two updates in milliseconds
+     * @ignore
+     */
+    handleZoomOrtho(dt: number): void;
+    /**
+     * Triggers a 'smart zoom' animated movement (travel) toward the point under mouse cursor. The camera will be
+     * smoothly moved and oriented close to the target, at a determined height and distance.
+     *
+     * @ignore
+     */
+    initiateSmartTravel(): void;
+    /**
+     * Triggers an animated movement and rotation for the camera.
+     *
+     * @param   {THREE.Vector3} targetPos   The target position of the camera (reached at the end).
+     * @param   {number|string}        travelTime  Set to `auto` or set to a duration in seconds. If set to `auto`,
+     * travel time will be set to a duration between `autoTravelTimeMin` and `autoTravelTimeMax` according to
+     * the distance and the angular difference between start and finish.
+     * @param   {(string|THREE.Vector3|THREE.Quaternion)}   targetOrientation   define the target rotation of
+     * the camera :
+     * <ul>
+     *     <li>if targetOrientation is a world point (Vector3) : the camera will lookAt() this point</li>
+     *     <li>if targetOrientation is a quaternion : this quaternion will define the final camera orientation </li>
+     *     <li>if targetOrientation is neither a world point nor a quaternion : the camera will keep its starting
+     *     orientation</li>
+     * </ul>
+     * @param   {boolean}       useSmooth   animation is smoothed using the `smooth(value)` function (slower
+     * at start and finish).
+     *
+     * @ignore
+     */
+    initiateTravel(targetPos: THREE.Vector3, travelTime: number | string, targetOrientation: (string | THREE.Vector3 | THREE.Quaternion), useSmooth: boolean): void;
+    /**
+     * Handle the animated movement and rotation of the camera in `travel` state.
+     *
+     * @param   {number}    dt  the delta time between two updates in milliseconds
+     * @ignore
+     */
+    handleTravel(dt: number): void;
+    /**
+     * Test if the currently running animation is finished (travelAlpha reached 1).
+     * If it is, reset controls to state NONE.
+     *
+     * @ignore
+     */
+    testAnimationEnd(): void;
+    /**
+     * Triggers an animated movement (travel) to set the camera to top view, above the focus point,
+     * at altitude = distanceToFocusPoint.
+     *
+     * @ignore
+     */
+    goToTopView(): void;
+    /**
+     * Triggers an animated movement (travel) to set the camera to starting view
+     *
+     * @ignore
+     */
+    goToStartView(): void;
+    /**
+     * Returns the world point (xyz) under the posXY screen point. The point belong to an abstract mathematical
+     * plane of specified altitude (does not us actual geometry).
+     *
+     * @param   {THREE.Vector2} posXY       the mouse position in screen space (unit : pixel)
+     * @param   {number}        altitude    the altitude (z) of the mathematical plane
+     * @param   {THREE.Vector3} target      the target vector3
+     * @return  {THREE.Vector3}
+     * @ignore
+     */
+    getWorldPointFromMathPlaneAtScreenXY(posXY: THREE.Vector2, altitude: number, target?: THREE.Vector3): THREE.Vector3;
+    /**
+     * Returns the world point (xyz) under the posXY screen point. If geometry is under the cursor, the point is
+     * obtained with getPickingPositionFromDepth. If no geometry is under the cursor, the point is obtained with
+     * [getWorldPointFromMathPlaneAtScreenXY]{@link PlanarControls#getWorldPointFromMathPlaneAtScreenXY}.
+     *
+     * @param   {THREE.Vector2} posXY   the mouse position in screen space (unit : pixel)
+     * @param   {THREE.Vector3} target  the target World coordinates.
+     * @return  {THREE.Vector3}
+     * @ignore
+     */
+    getWorldPointAtScreenXY(posXY: THREE.Vector2, target?: THREE.Vector3): THREE.Vector3;
+    /**
+     * Add all the input event listeners (activate the controls).
+     *
+     * @ignore
+     */
+    addInputListeners(): void;
+    /**
+     * Removes all the input listeners (deactivate the controls).
+     *
+     * @ignore
+     */
+    removeInputListeners(): void;
+    /**
+     * Update the cursor image according to the control state.
+     *
+     * @ignore
+     */
+    updateMouseCursorType(): void;
+    updateMousePositionAndDelta(event: any): void;
+    /**
+     * cursor modification for a specifique state.
+     *
+     * @param   {string} state   the state in which we want to change the cursor ('default', 'drag', 'pan', 'travel', 'rotate').
+     * @param   {string} newCursor   the css cursor we want to have for the specified state.
+     * @ignore
+     */
+    setCursor(state: string, newCursor: string): void;
+    /**
+     * Catch and manage the event when a touch on the mouse is downs.
+     *
+     * @param   {Event} event   the current event (mouse left or right button clicked, mouse wheel button actioned).
+     * @ignore
+     */
+    onMouseDown(event: Event): void;
+    /**
+     * Catch and manage the event when a touch on the mouse is released.
+     *
+     * @param   {Event} event   the current event
+     * @ignore
+     */
+    onMouseUp(event: Event): void;
+    /**
+     * Catch and manage the event when the mouse is moved.
+     *
+     * @param   {Event} event   the current event.
+     * @ignore
+     */
+    onMouseMove(event: Event): void;
+    /**
+     * Catch and manage the event when a key is down.
+     *
+     * @param   {Event} event   the current event
+     * @ignore
+     */
+    onKeyDown(event: Event): void;
+    /**
+     * Catch and manage the event when the mouse wheel is rolled.
+     *
+     * @param   {Event} event   the current event
+     * @ignore
+     */
+    onMouseWheel(event: Event): void;
+    /**
+     * Catch and manage the event when the context menu is called (by a right-click on the window). We use this
+     * to prevent the context menu from appearing so we can use right click for other inputs.
+     *
+     * @param   {Event} event   the current event
+     * @ignore
+     */
+    onContextMenu(event: Event): void;
+    /**
+     * Smoothing function (sigmoid) : based on h01 Hermite function.
+     *
+     * @param   {number}    value   the value to be smoothed, between 0 and 1.
+     * @return  {number}            a value between 0 and 1.
+     * @ignore
+     */
+    smooth(value: number): number;
+}
+import * as THREE from 'three';

package/lib/Controls/StateControl.d.ts

@@ -0,0 +1,140 @@
+export default StateControl;
+/**
+ * ~State
+ */
+export type StateControl = {
+    /**
+     * =true Indicate whether the state is enabled or not.
+     */
+    enable: boolean;
+    /**
+     * The mouse button bound to this state.
+     */
+    mouseButton?: number | undefined;
+    /**
+     * The keyCode of the keyboard input bound to this state.
+     */
+    keyboard?: number | undefined;
+    /**
+     * The number of fingers on the pad bound to this state.
+     */
+    finger?: number | undefined;
+    /**
+     * True if the mouse button bound to this state must be pressed twice. For
+     *  * example, if `double` is set to true with a `mouseButton` set to left click,
+     *  * the State will be bound to a double click mouse button.
+     */
+    double?: boolean | undefined;
+};
+/**
+ * @typedef {Object} StateControl~State
+ * @property {boolean} enable=true Indicate whether the state is enabled or not.
+ * @property {Number} [mouseButton] The mouse button bound to this state.
+ * @property {Number} [keyboard] The keyCode of the keyboard input bound to this state.
+ * @property {Number} [finger] The number of fingers on the pad bound to this state.
+ * @property {boolean} [double] True if the mouse button bound to this state must be pressed twice. For
+                                * example, if `double` is set to true with a `mouseButton` set to left click,
+                                * the State will be bound to a double click mouse button.
+ */
+/**
+ * It represents the control's states.
+ * Each {@link State} is a control mode of the camera and how to interact with
+ * the interface to activate this mode.
+ * @class StateControl
+ *
+ * @property {State}    NONE        {@link State} when camera is idle.
+ * @property {State}    ORBIT       {@link State} describing camera orbiting movement : the camera moves around its
+                                    * target at a constant distance from it.
+ * @property {State}    DOLLY       {@link State} describing camera dolly movement : the camera moves forward or
+                                    * backward from its target.
+ * @property {State}    PAN         {@link State} describing camera pan movement : the camera moves parallel to the
+                                    * current view plane.
+ * @property {State}    MOVE_GLOBE  {@link State} describing camera drag movement : the camera is moved around the view
+                                    * to give the feeling that the view is dragged under a static camera.
+ * @property {State}    PANORAMIC   {@link State} describing camera panoramic movement : the camera is rotated around
+                                    * its own position.
+ * @property {State}    TRAVEL_IN   {@link State} describing camera travel in movement : the camera is zoomed in toward
+                                    * a given position. The target position depends on the key/mouse binding of this
+                                    * state. If bound to a mouse button, the target position is the mouse position.
+                                    * Otherwise, it is the center of the screen.
+ * @property {State}    TRAVEL_OUT  {@link State} describing camera travel out movement : the camera is zoomed out from
+                                    * a given position. The target position depends on the key/mouse binding of this
+                                    * state. If bound to a mouse button, the target position is the mouse position.
+                                    * Otherwise, it is the center of the screen. It is disabled by default.
+ * @property {State}    ZOOM        {@link State} describing camera zoom in and out movement.
+ * @property {boolean}  enable      Defines whether all input will be communicated to the associated `Controls` or not.
+                                    * Default is true.
+ * @property {boolean}  enableKeys  Defines whether keyboard input will be communicated to the associated `Controls` or
+                                    * not. Default is true.
+ */
+declare class StateControl extends THREE.EventDispatcher<any> {
+    constructor(view: any, options?: {});
+    _view: any;
+    _domElement: any;
+    NONE: {};
+    _clickTimeStamp: number;
+    _lastMousePressed: {
+        viewCoords: THREE.Vector2;
+    };
+    _currentMousePressed: any;
+    _currentKeyPressed: any;
+    _onPointerDown: (event: any) => void;
+    _onPointerMove: (event: any) => void;
+    _onPointerUp: () => void;
+    _onMouseWheel: (event: any) => void;
+    _onKeyDown: (event: any) => void;
+    _onKeyUp: () => void;
+    _onBlur: () => void;
+    _onContextMenu: (event: any) => void;
+    /**
+     * get the state corresponding to the mouse button and the keyboard key. If the input relates to a trigger - a
+     * single event which triggers movement, without the move of the mouse for instance -, dispatch a relevant event.
+     * @param      {Number}  mouseButton  The mouse button
+     * @param      {Number}  keyboard     The keyboard
+     * @param      {Boolean} [double]     Value of the searched state `double` property
+     * @return     {State}  the state corresponding
+     */
+    inputToState(mouseButton: number, keyboard: number, double?: boolean): State;
+    /**
+     * get the state corresponding to the number of finger on the pad
+     *
+     * @param      {Number}  finger  The number of finger
+     * @return     {state}  the state corresponding
+     */
+    touchToState(finger: number): state;
+    /**
+     * Set the current StateControl {@link State} properties to given values.
+     * @param {Object}  options     Object containing the `State` values to set current `StateControl` properties to.
+                                    * The `enable` property do not necessarily need to be specified. In that case, the
+                                    * previous value of this property will be kept for the new {@link State}.
+     *
+     * @example
+     * // Switch bindings for PAN and MOVE_GLOBE actions, and disabling PANORAMIC movement :
+     * view.controls.states.setFromOptions({
+     *     PAN: {
+     *         mouseButton: itowns.THREE.MOUSE.LEFT,
+     *     },
+     *     MOVE_GLOBE: {
+     *         mouseButton: itowns.THREE.MOUSE.RIGHT,
+     *     },
+     *     PANORAMIC: {
+     *         enable: false,
+     *     },
+     * };
+     */
+    setFromOptions(options: Object): void;
+    onPointerDown(event: any): void;
+    currentState: any;
+    onPointerMove(event: any): void;
+    onPointerUp(): void;
+    onMouseWheel(event: any): void;
+    onKeyDown(event: any): void;
+    onKeyUp(): void;
+    onBlur(): void;
+    onContextMenu(event: any): void;
+    /**
+     * Remove all event listeners created within this instance of `StateControl`
+     */
+    dispose(): void;
+}
+import * as THREE from 'three';

package/lib/Controls/StreetControls.d.ts

@@ -0,0 +1,134 @@
+export default StreetControls;
+/**
+ * Camera controls that can follow a path.
+ * It is used to simulate a street view.
+ * It stores a currentPosition and nextPosition, and do a camera traveling to go to next position.
+ * It also manages picking on the ground and on other object, like building.
+ * <ul> It manages 2 surfaces, used as helpers for the end user :
+ * <li> a circle is shown when mouse is moving on the ground </li>
+ * <li> a rectangle is shown when mouse is moving on other 3d object </li>
+ * </ul>
+ * <ul>
+ * This controls is designed
+ * <li> to move forward when user click on the ground (click and go) </li>
+ * <li> to rotate the camera when user click on other object (click to look at) </li>
+ * </ul>
+ * <ul> Bindings inherited from FirstPersonControls
+ * <li><b> up + down keys : </b> forward/backward </li>
+ * <li><b> left + right keys: </b> strafing movements </li>
+ * <li><b> pageUp + pageDown: </b> vertical movements </li>
+ * <li><b> mouse click+drag: </b> pitch and yaw movements (as looking at a panorama) </li>
+ * </ul>
+ * <ul> Bindings added
+ * <li><b> keys Z : </b> Move camera to the next position </li>
+ * <li><b> keys S : </b> Move camera to the previous position </li>
+ * <li><b> keys A : </b> Set camera to current position and look at next position</li>
+ * <li><b> keys Q : </b> Set camera to current position and look at previous position</li>
+ * </ul>
+ * Note that it only works in globe view.
+ * @property {number} keyGoToNextPosition key code to go to next position, default to 90 for key Z
+ * @property {number} keyGoToPreviousPosition key code to go to previous position, default to 83 for key S
+ * @property {number} keySetCameraToCurrentPositionAndLookAtNext key code set camera to current position, default to 65 for key  A
+ * @property {number} keySetCameraToCurrentPositionAndLookAtPrevious key code set camera to current position, default to 81 for key  Q
+ * @extends FirstPersonControls
+ */
+declare class StreetControls extends FirstPersonControls {
+    /**
+     * @param { View } view - View where this control will be used
+     * @param { Object } options - Configuration of this controls
+     * @param { number } [options.wallMaxDistance=1000] - Maximum distance to click on a wall, in meter.
+     * @param { number } [options.animationDurationWall=200] - Time in millis for the animation when clicking on a wall.
+     * @param { THREE.Mesh } [options.surfaceGround] - Surface helper to see when mouse is on the ground, default is a transparent circle.
+     * @param { THREE.Mesh } [options.surfaceWall] - Surface helper to see when mouse is on a wall, default is a transparent rectangle.
+     * @param { string } [options.buildingsLayer='Buildings'] - Name of the building layer (used to pick on wall).
+     * @param { function } [options.computeTime] - Function to compute time (in millis), used for the animation to move to a distance (in meter)
+     * @param { number } [options.offset=4] - Altitude in meter up to the ground to move to when click on a target on the ground.
+     */
+    constructor(view: View, options?: {
+        wallMaxDistance?: number | undefined;
+        animationDurationWall?: number | undefined;
+        surfaceGround?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap> | undefined;
+        surfaceWall?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap> | undefined;
+        buildingsLayer?: string | undefined;
+        computeTime?: Function | undefined;
+        offset?: number | undefined;
+    });
+    isStreetControls: boolean;
+    _onMouseOut: () => void;
+    previousPosition: any;
+    currentPosition: any;
+    nextPosition: any;
+    keyGoToNextPosition: number;
+    keyGoToPreviousPosition: number;
+    keySetCameraToCurrentPositionAndLookAtNext: number;
+    keySetCameraToCurrentPositionAndLookAtPrevious: number;
+    tweenGroup: import("@tweenjs/tween.js").Group;
+    surfaceGround: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
+    surfaceWall: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
+    surfaces: THREE.Object3D<THREE.Object3DEventMap>;
+    wallMaxDistance: number;
+    animationDurationWall: number;
+    buildingsLayer: string | undefined;
+    computeTime: Function;
+    offset: number;
+    transformationPositionPickOnTheGround: any;
+    end: any;
+    setCurrentPosition(newCurrentPosition: any): void;
+    setNextPosition(newNextPosition: any): void;
+    setPreviousPosition(newPreviousPosition: any): void;
+    onMouseUp(event: any): void;
+    _stateOnMouseDrag: boolean | undefined;
+    /**
+     * Sets the camera to the current position (stored in this controls), looking at the next position (also stored in this controls).
+     *
+     * @param      { boolean }  lookAtPrevious   look at the previous position rather than the next one
+     */
+    setCameraToCurrentPosition(lookAtPrevious: boolean): void;
+    /**
+     * Set the camera on a position, looking at another position.
+     *
+     * @param      { THREE.Vector3 }  position   The position to set the camera
+     * @param      { THREE.Vector3 }  lookAt      The position where the camera look at.
+     */
+    setCameraOnPosition(position: THREE.Vector3, lookAt: THREE.Vector3): void;
+    /**
+     * Method called when user click on the ground.</br>
+     * Note that this funtion contains default values that can be overrided, by overriding this class.
+     *
+     * @param {THREE.Vector3} position - The position
+     */
+    onClickOnGround(position: THREE.Vector3): void;
+    /**
+     * Method called when user click on oject that is not the ground.</br>
+     * Note that this function contains default values that can be overrided, by overriding this class.
+     *
+     * @param {THREE.Vector3} position - The position
+     */
+    onClickOnWall(position: THREE.Vector3): void;
+    /**
+     * Animate the camera to make it look at a position, in a given time
+     *
+     * @param { THREE.Vector3 }  position - Position to look at
+     * @param { number } time - Time in millisecond
+     */
+    animateCameraLookAt(position: THREE.Vector3, time: number): void;
+    tween: import("@tweenjs/tween.js").Tween<{
+        t: number;
+    }> | import("@tweenjs/tween.js").Tween<any> | undefined;
+    animationFrameRequester: (() => void) | (() => void) | null | undefined;
+    /**
+     * Move the camera smoothly to the position, in a given time.
+     *
+     * @param { THREE.Vector3 }  position - Destination of the movement.
+     * @param { number } time - Time in millisecond
+     * @return { Promise }
+     */
+    moveCameraTo(position: THREE.Vector3, time?: number): Promise<any>;
+    stopAnimations(): void;
+    /**
+     * Move the camera to the 'currentPosition' stored in this control.
+     */
+    moveCameraToCurrentPosition(): void;
+}
+import FirstPersonControls from '../Controls/FirstPersonControls';
+import * as THREE from 'three';

package/lib/Controls/VRControls.d.ts

@@ -0,0 +1,56 @@
+export default VRControls;
+/**
+ * @property {Array} controllers - WebXR controllers list
+ * */
+declare class VRControls {
+    static MIN_DELTA_ALTITUDE: number;
+    static MAX_NUMBER_CONTROLLERS: number;
+    static init(view: any, vrHeadSet: any): VRControls;
+    /**
+     * Requires a contextXR variable.
+     * @param {*} _view itowns view object
+     * @param {*} _groupXR XR 3D object group
+     */
+    constructor(_view: any, _groupXR?: any);
+    view: any;
+    groupXR: any;
+    webXRManager: any;
+    rightButtonPressed: boolean;
+    controllers: any[];
+    initControllers(): void;
+    bindGripController(controllerModelFactory: any, gripController: any, vrHeadSet: any): void;
+    setupEventListeners(controller: any): void;
+    listenGamepad(): void;
+    clampAndApplyTransformationToXR(trans: any, offsetRotation: any): void;
+    applyTransformationToXR(trans: any, offsetRotation: any): void;
+    /**
+   * Clamp the given translation vector so that the camera remains at or above ground level.
+   * @param {THREE.Vector3} trans - The translation vector.
+   * @returns {THREE.Vector3} The clamped coordinates as a Vector3.
+   */
+    clampToGround(trans: THREE.Vector3): THREE.Vector3;
+    getSpeedFactor(): number;
+    getRotationYaw(axisValue: any): any;
+    getRotationPitch(axisValue: any): any;
+    getTranslationElevation(axisValue: any, speedFactor: any): any;
+    cameraOnFly(ctrl: any): void;
+    onSelectRightEnd(): void;
+    onSelectRightStart(): void;
+    onSelectLeftStart(): void;
+    onSelectLeftEnd(): void;
+    onSelectStart(data: any): void;
+    onSelectEnd(data: any): void;
+    onButtonPressed(data: any): void;
+    onRightButtonPressed(data: any): void;
+    onLeftButtonPressed(): void;
+    onAxisChanged(data: any): void;
+    onRightAxisChanged(ctrl: any): void;
+    onLeftAxisChanged(ctrl: any): void;
+    onAxisStop(data: any): void;
+    onRightAxisStop(): void;
+    onLeftAxisStop(): void;
+    onButtonReleased(data: any): void;
+    onRightButtonReleased(): void;
+    onLeftButtonReleased(): void;
+}
+import * as THREE from 'three';