itowns 2.45.1 → 2.45.2-next.0

package/lib/ThreeExtended/loaders/KTX2Loader.d.ts

@@ -0,0 +1,116 @@
+export class KTX2Loader extends Loader<any, string> {
+    constructor(manager: any);
+    transcoderPath: string;
+    transcoderBinary: string | ArrayBuffer | null;
+    transcoderPending: Promise<void> | null;
+    workerPool: WorkerPool;
+    workerSourceURL: string;
+    workerConfig: {
+        astcSupported: any;
+        astcHDRSupported: boolean;
+        etc1Supported: any;
+        etc2Supported: any;
+        dxtSupported: any;
+        bptcSupported: any;
+        pvrtcSupported: any;
+    } | {
+        astcSupported: any;
+        astcHDRSupported: boolean;
+        etc1Supported: any;
+        etc2Supported: any;
+        dxtSupported: any;
+        bptcSupported: any;
+        pvrtcSupported: any;
+    } | {
+        astcSupported: any;
+        astcHDRSupported: any;
+        etc1Supported: any;
+        etc2Supported: any;
+        dxtSupported: any;
+        bptcSupported: any;
+        pvrtcSupported: any;
+    } | null;
+    setTranscoderPath(path: any): this;
+    setWorkerLimit(num: any): this;
+    detectSupportAsync(renderer: any): Promise<this>;
+    detectSupport(renderer: any): this;
+    init(): Promise<void>;
+    load(url: any, onLoad: any, onProgress: any, onError: any): void;
+    parse(buffer: any, onLoad: any, onError: any): any;
+    _createTextureFrom(transcodeResult: any, container: any): Promise<never> | CompressedTexture;
+    /**
+     * @param {ArrayBuffer} buffer
+     * @param {?Object} config
+     * @return {Promise<CompressedTexture|CompressedArrayTexture|DataTexture|Data3DTexture>}
+     */
+    _createTexture(buffer: ArrayBuffer, config?: Object | null): Promise<CompressedTexture | CompressedArrayTexture | DataTexture | Data3DTexture>;
+    dispose(): this;
+}
+export namespace KTX2Loader {
+    namespace BasisFormat {
+        let ETC1S: number;
+        let UASTC: number;
+        let UASTC_HDR: number;
+    }
+    namespace TranscoderFormat {
+        let ETC1: number;
+        let ETC2: number;
+        let BC1: number;
+        let BC3: number;
+        let BC4: number;
+        let BC5: number;
+        let BC7_M6_OPAQUE_ONLY: number;
+        let BC7_M5: number;
+        let PVRTC1_4_RGB: number;
+        let PVRTC1_4_RGBA: number;
+        let ASTC_4x4: number;
+        let ATC_RGB: number;
+        let ATC_RGBA_INTERPOLATED_ALPHA: number;
+        let RGBA32: number;
+        let RGB565: number;
+        let BGR565: number;
+        let RGBA4444: number;
+        let BC6H: number;
+        let RGB_HALF: number;
+        let RGBA_HALF: number;
+    }
+    namespace EngineFormat {
+        export { RGBAFormat };
+        export { RGBA_ASTC_4x4_Format };
+        export { RGB_BPTC_UNSIGNED_Format };
+        export { RGBA_BPTC_Format };
+        export { RGBA_ETC2_EAC_Format };
+        export { RGBA_PVRTC_4BPPV1_Format };
+        export { RGBA_S3TC_DXT5_Format };
+        export { RGB_ETC1_Format };
+        export { RGB_ETC2_Format };
+        export { RGB_PVRTC_4BPPV1_Format };
+        export { RGBA_S3TC_DXT1_Format };
+    }
+    namespace EngineType {
+        export { UnsignedByteType };
+        export { HalfFloatType };
+        export { FloatType };
+    }
+    function BasisWorker(): void;
+}
+import { Loader } from 'three';
+import { WorkerPool } from '../utils/WorkerPool.js';
+import { CompressedTexture } from 'three';
+import { CompressedArrayTexture } from 'three';
+import { DataTexture } from 'three';
+import { Data3DTexture } from 'three';
+import { RGBAFormat } from 'three';
+import { RGBA_ASTC_4x4_Format } from 'three';
+import { RGB_BPTC_UNSIGNED_Format } from 'three';
+import { RGBA_BPTC_Format } from 'three';
+import { RGBA_ETC2_EAC_Format } from 'three';
+import { RGBA_PVRTC_4BPPV1_Format } from 'three';
+import { RGBA_S3TC_DXT5_Format } from 'three';
+import { RGB_ETC1_Format } from 'three';
+import { RGB_ETC2_Format } from 'three';
+import { RGB_PVRTC_4BPPV1_Format } from 'three';
+import { RGBA_S3TC_DXT1_Format } from 'three';
+import { UnsignedByteType } from 'three';
+import { HalfFloatType } from 'three';
+import { FloatType } from 'three';

package/lib/ThreeExtended/loaders/KTX2Loader.js

@@ -175,7 +175,7 @@ class KTX2Loader extends Loader {
 
   /**
    * @param {ArrayBuffer} buffer
-   * @param {object?} config
+   * @param {?Object} config
    * @return {Promise<CompressedTexture|CompressedArrayTexture|DataTexture|Data3DTexture>}
    */
   async _createTexture(buffer) {
@@ -566,7 +566,12 @@ KTX2Loader.BasisWorker = function () {
     return (value & value - 1) === 0 && value !== 0;
   }
 
-  /** Concatenates N byte arrays. */
+  /**
+   * Concatenates N byte arrays.
+   *
+   * @param {Uint8Array[]} arrays
+   * @return {Uint8Array}
+   */
   function concat(arrays) {
     if (arrays.length === 1) return arrays[0];
     let totalByteLength = 0;
@@ -682,6 +687,8 @@ async function createRawTexture(container) {
   } else {
     if (container.pixelDepth > 0) throw new Error('THREE.KTX2Loader: Unsupported pixelDepth.');
     texture = new CompressedTexture(mipmaps, container.pixelWidth, container.pixelHeight);
+    texture.minFilter = mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter;
+    texture.magFilter = LinearFilter;
   }
   texture.mipmaps = mipmaps;
   texture.type = TYPE_MAP[vkFormat];

package/lib/ThreeExtended/math/ColorSpaces.d.ts

@@ -0,0 +1,56 @@
+export const DisplayP3ColorSpace: "display-p3";
+export const LinearDisplayP3ColorSpace: "display-p3-linear";
+export namespace DisplayP3ColorSpaceImpl {
+    export { P3_PRIMARIES as primaries };
+    export { D65 as whitePoint };
+    export { SRGBTransfer as transfer };
+    export { LINEAR_DISPLAY_P3_TO_XYZ as toXYZ };
+    export { XYZ_TO_LINEAR_DISPLAY_P3 as fromXYZ };
+    export { P3_LUMINANCE_COEFFICIENTS as luminanceCoefficients };
+    export namespace outputColorSpaceConfig {
+        export { DisplayP3ColorSpace as drawingBufferColorSpace };
+    }
+}
+export namespace LinearDisplayP3ColorSpaceImpl {
+    export { P3_PRIMARIES as primaries };
+    export { D65 as whitePoint };
+    export { LinearTransfer as transfer };
+    export { LINEAR_DISPLAY_P3_TO_XYZ as toXYZ };
+    export { XYZ_TO_LINEAR_DISPLAY_P3 as fromXYZ };
+    export { P3_LUMINANCE_COEFFICIENTS as luminanceCoefficients };
+    export namespace workingColorSpaceConfig {
+        export { DisplayP3ColorSpace as unpackColorSpace };
+    }
+    export namespace outputColorSpaceConfig_1 {
+        export { DisplayP3ColorSpace as drawingBufferColorSpace };
+    }
+    export { outputColorSpaceConfig_1 as outputColorSpaceConfig };
+}
+export const LinearRec2020ColorSpace: "rec2020-linear";
+export namespace LinearRec2020ColorSpaceImpl {
+    export { REC2020_PRIMARIES as primaries };
+    export { D65 as whitePoint };
+    export { LinearTransfer as transfer };
+    export { LINEAR_REC2020_TO_XYZ as toXYZ };
+    export { XYZ_TO_LINEAR_REC2020 as fromXYZ };
+    export { REC2020_LUMINANCE_COEFFICIENTS as luminanceCoefficients };
+}
+declare const P3_PRIMARIES: number[];
+declare const D65: number[];
+import { SRGBTransfer } from 'three';
+/******************************************************************************
+ * Display P3 definitions
+ */
+declare const LINEAR_DISPLAY_P3_TO_XYZ: Matrix3;
+declare const XYZ_TO_LINEAR_DISPLAY_P3: Matrix3;
+declare const P3_LUMINANCE_COEFFICIENTS: number[];
+import { LinearTransfer } from 'three';
+declare const REC2020_PRIMARIES: number[];
+/******************************************************************************
+ * Rec. 2020 definitions
+ */
+declare const LINEAR_REC2020_TO_XYZ: Matrix3;
+declare const XYZ_TO_LINEAR_REC2020: Matrix3;
+declare const REC2020_LUMINANCE_COEFFICIENTS: number[];
+import { Matrix3 } from 'three';
+export {};

package/lib/ThreeExtended/utils/BufferGeometryUtils.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @param {BufferAttribute} attribute
+ * @return {BufferAttribute}
+ */
+export function deepCloneAttribute(attribute: BufferAttribute): BufferAttribute;
+export function deinterleaveAttribute(attribute: any): BufferAttribute;
+export function deinterleaveGeometry(geometry: any): void;
+import { BufferAttribute } from 'three';
+export function computeMikkTSpaceTangents(geometry: any, MikkTSpace: any, negateSign?: boolean): any;
+/**
+ * @param  {Array<BufferGeometry>} geometries
+ * @param  {boolean} useGroups
+ * @return {BufferGeometry}
+ */
+export function mergeGeometries(geometries: Array<BufferGeometry>, useGroups?: boolean): BufferGeometry;
+/**
+ * @param {Array<BufferAttribute>} attributes
+ * @return {BufferAttribute}
+ */
+export function mergeAttributes(attributes: Array<BufferAttribute>): BufferAttribute;
+/**
+ * @param {Array<BufferAttribute>} attributes
+ * @return {Array<InterleavedBufferAttribute>}
+ */
+export function interleaveAttributes(attributes: Array<BufferAttribute>): Array<InterleavedBufferAttribute>;
+/**
+ * @param {BufferGeometry} geometry
+ * @return {number}
+ */
+export function estimateBytesUsed(geometry: BufferGeometry): number;
+/**
+ * @param {BufferGeometry} geometry
+ * @param {number} tolerance
+ * @return {BufferGeometry}
+ */
+export function mergeVertices(geometry: BufferGeometry, tolerance?: number): BufferGeometry;
+/**
+ * @param {BufferGeometry} geometry
+ * @param {number} drawMode
+ * @return {BufferGeometry}
+ */
+export function toTrianglesDrawMode(geometry: BufferGeometry, drawMode: number): BufferGeometry;
+/**
+ * Calculates the morphed attributes of a morphed/skinned BufferGeometry.
+ * Helpful for Raytracing or Decals.
+ * @param {Mesh | Line | Points} object An instance of Mesh, Line or Points.
+ * @return {Object} An Object with original position/normal attributes and morphed ones.
+ */
+export function computeMorphedAttributes(object: Mesh | Line | Points): Object;
+export function mergeGroups(geometry: any): any;
+/**
+ * Modifies the supplied geometry if it is non-indexed, otherwise creates a new,
+ * non-indexed geometry. Returns the geometry with smooth normals everywhere except
+ * faces that meet at an angle greater than the crease angle.
+ *
+ * @param {BufferGeometry} geometry
+ * @param {number} [creaseAngle]
+ * @return {BufferGeometry}
+ */
+export function toCreasedNormals(geometry: BufferGeometry, creaseAngle?: number): BufferGeometry;
+import { BufferGeometry } from 'three';
+import { InterleavedBufferAttribute } from 'three';

package/lib/ThreeExtended/utils/BufferGeometryUtils.js

@@ -53,7 +53,7 @@ function computeMikkTSpaceTangents(geometry, MikkTSpace) {
 
 /**
  * @param  {Array<BufferGeometry>} geometries
- * @param  {Boolean} useGroups
+ * @param  {boolean} useGroups
  * @return {BufferGeometry}
  */
 function mergeGeometries(geometries) {
@@ -233,7 +233,7 @@ function mergeAttributes(attributes) {
 }
 
 /**
- * @param {BufferAttribute}
+ * @param {BufferAttribute} attribute
  * @return {BufferAttribute}
  */
 export function deepCloneAttribute(attribute) {

package/lib/ThreeExtended/utils/WorkerPool.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @author Deepkolos / https://github.com/deepkolos
+ */
+export class WorkerPool {
+    constructor(pool?: number);
+    pool: number;
+    queue: any[];
+    workers: any[];
+    workersResolve: any[];
+    workerStatus: number;
+    _initWorker(workerId: any): void;
+    _getIdleWorker(): number;
+    _onMessage(workerId: any, msg: any): void;
+    setWorkerCreator(workerCreator: any): void;
+    workerCreator: any;
+    setWorkerLimit(pool: any): void;
+    postMessage(msg: any, transfer: any): Promise<any>;
+    dispose(): void;
+}

package/lib/ThreeExtended/webxr/XRControllerModelFactory.d.ts

@@ -0,0 +1,25 @@
+export class XRControllerModelFactory {
+    constructor(gltfLoader?: null, onLoad?: null);
+    gltfLoader: GLTFLoader;
+    path: string;
+    _assetCache: {};
+    onLoad: any;
+    setPath(path: any): this;
+    createControllerModel(controller: any): XRControllerModel;
+}
+import { GLTFLoader } from '../loaders/GLTFLoader.js';
+declare class XRControllerModel extends Object3D<import("three").Object3DEventMap> {
+    constructor();
+    motionController: any;
+    envMap: any;
+    setEnvironmentMap(envMap: any): this;
+    /**
+     * Polls data from the XRInputSource and updates the model's components to match
+     * the real world data
+     *
+     * @param {boolean} force
+     */
+    updateMatrixWorld(force: boolean): void;
+}
+import { Object3D } from 'three';
+export {};

package/lib/ThreeExtended/webxr/XRControllerModelFactory.js

@@ -0,0 +1,209 @@
+import { Mesh, MeshBasicMaterial, Object3D, SphereGeometry } from 'three';
+import { GLTFLoader } from "../loaders/GLTFLoader.js";
+import { Constants as MotionControllerConstants, fetchProfile, MotionController } from "../libs/motion-controllers.module.js";
+const DEFAULT_PROFILES_PATH = 'https://cdn.jsdelivr.net/npm/@webxr-input-profiles/assets@1.0/dist/profiles';
+const DEFAULT_PROFILE = 'generic-trigger';
+class XRControllerModel extends Object3D {
+  constructor() {
+    super();
+    this.motionController = null;
+    this.envMap = null;
+  }
+  setEnvironmentMap(envMap) {
+    if (this.envMap == envMap) {
+      return this;
+    }
+    this.envMap = envMap;
+    this.traverse(child => {
+      if (child.isMesh) {
+        child.material.envMap = this.envMap;
+        child.material.needsUpdate = true;
+      }
+    });
+    return this;
+  }
+
+  /**
+   * Polls data from the XRInputSource and updates the model's components to match
+   * the real world data
+   *
+   * @param {boolean} force
+   */
+  updateMatrixWorld(force) {
+    super.updateMatrixWorld(force);
+    if (!this.motionController) return;
+
+    // Cause the MotionController to poll the Gamepad for data
+    this.motionController.updateFromGamepad();
+
+    // Update the 3D model to reflect the button, thumbstick, and touchpad state
+    Object.values(this.motionController.components).forEach(component => {
+      // Update node data based on the visual responses' current states
+      Object.values(component.visualResponses).forEach(visualResponse => {
+        const {
+          valueNode,
+          minNode,
+          maxNode,
+          value,
+          valueNodeProperty
+        } = visualResponse;
+
+        // Skip if the visual response node is not found. No error is needed,
+        // because it will have been reported at load time.
+        if (!valueNode) return;
+
+        // Calculate the new properties based on the weight supplied
+        if (valueNodeProperty === MotionControllerConstants.VisualResponseProperty.VISIBILITY) {
+          valueNode.visible = value;
+        } else if (valueNodeProperty === MotionControllerConstants.VisualResponseProperty.TRANSFORM) {
+          valueNode.quaternion.slerpQuaternions(minNode.quaternion, maxNode.quaternion, value);
+          valueNode.position.lerpVectors(minNode.position, maxNode.position, value);
+        }
+      });
+    });
+  }
+}
+
+/**
+ * Walks the model's tree to find the nodes needed to animate the components and
+ * saves them to the motionController components for use in the frame loop. When
+ * touchpads are found, attaches a touch dot to them.
+ *
+ * @param {MotionController} motionController
+ * @param {Object3D} scene
+ */
+function findNodes(motionController, scene) {
+  // Loop through the components and find the nodes needed for each components' visual responses
+  Object.values(motionController.components).forEach(component => {
+    const {
+      type,
+      touchPointNodeName,
+      visualResponses
+    } = component;
+    if (type === MotionControllerConstants.ComponentType.TOUCHPAD) {
+      component.touchPointNode = scene.getObjectByName(touchPointNodeName);
+      if (component.touchPointNode) {
+        // Attach a touch dot to the touchpad.
+        const sphereGeometry = new SphereGeometry(0.001);
+        const material = new MeshBasicMaterial({
+          color: 0x0000FF
+        });
+        const sphere = new Mesh(sphereGeometry, material);
+        component.touchPointNode.add(sphere);
+      } else {
+        console.warn(`Could not find touch dot, ${component.touchPointNodeName}, in touchpad component ${component.id}`);
+      }
+    }
+
+    // Loop through all the visual responses to be applied to this component
+    Object.values(visualResponses).forEach(visualResponse => {
+      const {
+        valueNodeName,
+        minNodeName,
+        maxNodeName,
+        valueNodeProperty
+      } = visualResponse;
+
+      // If animating a transform, find the two nodes to be interpolated between.
+      if (valueNodeProperty === MotionControllerConstants.VisualResponseProperty.TRANSFORM) {
+        visualResponse.minNode = scene.getObjectByName(minNodeName);
+        visualResponse.maxNode = scene.getObjectByName(maxNodeName);
+
+        // If the extents cannot be found, skip this animation
+        if (!visualResponse.minNode) {
+          console.warn(`Could not find ${minNodeName} in the model`);
+          return;
+        }
+        if (!visualResponse.maxNode) {
+          console.warn(`Could not find ${maxNodeName} in the model`);
+          return;
+        }
+      }
+
+      // If the target node cannot be found, skip this animation
+      visualResponse.valueNode = scene.getObjectByName(valueNodeName);
+      if (!visualResponse.valueNode) {
+        console.warn(`Could not find ${valueNodeName} in the model`);
+      }
+    });
+  });
+}
+function addAssetSceneToControllerModel(controllerModel, scene) {
+  // Find the nodes needed for animation and cache them on the motionController.
+  findNodes(controllerModel.motionController, scene);
+
+  // Apply any environment map that the mesh already has set.
+  if (controllerModel.envMap) {
+    scene.traverse(child => {
+      if (child.isMesh) {
+        child.material.envMap = controllerModel.envMap;
+        child.material.needsUpdate = true;
+      }
+    });
+  }
+
+  // Add the glTF scene to the controllerModel.
+  controllerModel.add(scene);
+}
+class XRControllerModelFactory {
+  constructor() {
+    let gltfLoader = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    let onLoad = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    this.gltfLoader = gltfLoader;
+    this.path = DEFAULT_PROFILES_PATH;
+    this._assetCache = {};
+    this.onLoad = onLoad;
+
+    // If a GLTFLoader wasn't supplied to the constructor create a new one.
+    if (!this.gltfLoader) {
+      this.gltfLoader = new GLTFLoader();
+    }
+  }
+  setPath(path) {
+    this.path = path;
+    return this;
+  }
+  createControllerModel(controller) {
+    const controllerModel = new XRControllerModel();
+    let scene = null;
+    controller.addEventListener('connected', event => {
+      const xrInputSource = event.data;
+      if (xrInputSource.targetRayMode !== 'tracked-pointer' || !xrInputSource.gamepad || xrInputSource.hand) return;
+      fetchProfile(xrInputSource, this.path, DEFAULT_PROFILE).then(_ref => {
+        let {
+          profile,
+          assetPath
+        } = _ref;
+        controllerModel.motionController = new MotionController(xrInputSource, profile, assetPath);
+        const cachedAsset = this._assetCache[controllerModel.motionController.assetUrl];
+        if (cachedAsset) {
+          scene = cachedAsset.scene.clone();
+          addAssetSceneToControllerModel(controllerModel, scene);
+          if (this.onLoad) this.onLoad(scene);
+        } else {
+          if (!this.gltfLoader) {
+            throw new Error('GLTFLoader not set.');
+          }
+          this.gltfLoader.setPath('');
+          this.gltfLoader.load(controllerModel.motionController.assetUrl, asset => {
+            this._assetCache[controllerModel.motionController.assetUrl] = asset;
+            scene = asset.scene.clone();
+            addAssetSceneToControllerModel(controllerModel, scene);
+            if (this.onLoad) this.onLoad(scene);
+          }, null, () => {
+            throw new Error(`Asset ${controllerModel.motionController.assetUrl} missing or malformed.`);
+          });
+        }
+      }).catch(err => {
+        console.warn(err);
+      });
+    });
+    controller.addEventListener('disconnected', () => {
+      controllerModel.motionController = null;
+      controllerModel.remove(scene);
+      scene = null;
+    });
+    return controllerModel;
+  }
+}
+export { XRControllerModelFactory };

package/lib/Utils/CameraUtils.d.ts

@@ -0,0 +1,132 @@
+export function getLookAtFromMath(view: any, camera: any): false | THREE.Vector3;
+export function getRig(camera: any): any;
+declare namespace _default {
+    let defaultStopPlaceOnGroundAtEnd: boolean;
+    let Easing: Readonly<{
+        Linear: Readonly<{
+            In: (amount: number) => number;
+            Out: (amount: number) => number;
+            InOut: (amount: number) => number;
+        } & {
+            None: (amount: number) => number;
+        }>;
+        Quadratic: Readonly<{
+            In: (amount: number) => number;
+            Out: (amount: number) => number;
+            InOut: (amount: number) => number;
+        }>;
+        Cubic: Readonly<{
+            In: (amount: number) => number;
+            Out: (amount: number) => number;
+            InOut: (amount: number) => number;
+        }>;
+        Quartic: Readonly<{
+            In: (amount: number) => number;
+            Out: (amount: number) => number;
+            InOut: (amount: number) => number;
+        }>;
+        Quintic: Readonly<{
+            In: (amount: number) => number;
+            Out: (amount: number) => number;
+            InOut: (amount: number) => number;
+        }>;
+        Sinusoidal: Readonly<{
+            In: (amount: number) => number;
+            Out: (amount: number) => number;
+            InOut: (amount: number) => number;
+        }>;
+        Exponential: Readonly<{
+            In: (amount: number) => number;
+            Out: (amount: number) => number;
+            InOut: (amount: number) => number;
+        }>;
+        Circular: Readonly<{
+            In: (amount: number) => number;
+            Out: (amount: number) => number;
+            InOut: (amount: number) => number;
+        }>;
+        Elastic: Readonly<{
+            In: (amount: number) => number;
+            Out: (amount: number) => number;
+            InOut: (amount: number) => number;
+        }>;
+        Back: Readonly<{
+            In: (amount: number) => number;
+            Out: (amount: number) => number;
+            InOut: (amount: number) => number;
+        }>;
+        Bounce: Readonly<{
+            In: (amount: number) => number;
+            Out: (amount: number) => number;
+            InOut: (amount: number) => number;
+        }>;
+        generatePow(power?: number): {
+            In: (amount: number) => number;
+            Out: (amount: number) => number;
+            InOut: (amount: number) => number;
+        };
+    }>;
+    /**
+     * Stop camera's animation
+     *
+     * @param      {View}  view    The camera view
+     * @param      {Camera}  camera  The camera to stop animation
+     */
+    function stop(view: View, camera: Camera): void;
+    /**
+     * Gets the current parameters transform camera looking at target.
+     *
+     * @param      {View}  view    The camera view
+     * @param      {Camera}  camera  The camera to get transform
+     * @param      {THREE.Vector3} [target] - The optional target
+     * @return     {CameraUtils~CameraTransformOptions}  The transform camera looking at target
+     */
+    function getTransformCameraLookingAtTarget(view: View, camera: Camera, target?: THREE.Vector3): CameraUtils;
+    /**
+     * Apply transform to camera
+     *
+     * @param      {View}  view    The camera view
+     * @param      {Camera}  camera  The camera to transform
+     * @param      {CameraUtils~CameraTransformOptions|Extent}  params  The parameters
+     * @return     {Promise} promise with resolve final CameraUtils~CameraTransformOptions
+     */
+    function transformCameraToLookAtTarget(view: View, camera: Camera, params?: {}): Promise<any>;
+    /**
+     * Compute the CameraTransformOptions that allow a given camera to display a given extent in its entirety.
+     *
+     * @param   {View}    view    The camera view
+     * @param   {THREE.Camera}  camera  The camera to get the CameraTransformOptions from
+     * @param   {Extent}  extent  The extent the camera must display
+     *
+     * @return  {CameraUtils~CameraTransformOptions}   The CameraTransformOptions allowing camera to display the extent.
+     */
+    function getCameraTransformOptionsFromExtent(view: View, camera: THREE.Camera, extent: Extent): CameraUtils;
+    /**
+     * Apply transform to camera with animation
+     *
+     * @param      {View}  view    The camera view
+     * @param      {Camera}  camera  The camera to animate
+     * @param      {CameraUtils~CameraTransformOptions}  params  The parameters
+     * @return     {Promise} promise with resolve final CameraUtils~CameraTransformOptions
+     */
+    function animateCameraToLookAtTarget(view: View, camera: Camera, params?: {}): Promise<any>;
+    /**
+     * chain animation transform to camera
+     *
+     * @param      {View}  view    The camera view
+     * @param      {Camera}  camera  The camera to animate
+     * @param      {CameraUtils~CameraTransformOptions[]}  params  array parameters, each parameters transforms are apply to camera, in serial
+     * @return     {Promise} promise with resolve final CameraUtils~CameraTransformOptions
+     */
+    function sequenceAnimationsToLookAtTarget(view: View, camera: Camera, params?: {}[]): Promise<any>;
+    /**
+     * Gets the difference camera transformation
+     *
+     * @param      {CameraUtils~CameraTransformOptions}  first  param to compare with the second
+     * @param      {CameraUtils~CameraTransformOptions}  second param to compare with the first
+     * @return     {object} The difference parameters
+     */
+    function getDiffParams(first: any, second: any): object;
+}
+export default _default;
+import * as THREE from 'three';