itowns 2.45.1 → 2.45.2-next.0

package/lib/Renderer/WebXR.js

@@ -1,51 +1,132 @@
 import * as THREE from 'three';
-async function shutdownXR(session) {
-  if (session) {
-    await session.end();
-  }
+import VRControls from "../Controls/VRControls.js";
+
+// TODO handle xr session end
+export const VR_EVENTS = {
+  CONTROLS_INITIALIZED: 'vrControls-initialized'
+};
+function updateCamera3D(xr, view) {
+  /* This is what's done in updateUserCamera the WebXRManager.js of threejs
+          Update projectionMatrix, could be replaced by:
+         camera.projectionMatrix.copy( cameraXR.projectionMatrix );
+        camera.projectionMatrixInverse.copy( cameraXR.projectionMatrixInverse );
+         But it safer to also change all the attributes, in case of another call to updateProjectionMatrix
+  */
+
+  const {
+    near,
+    far,
+    aspect,
+    fov
+  } = extractCameraAttributesFromProjectionMatrix(view._camXR.projectionMatrix);
+  view.camera3D.near = near;
+  view.camera3D.far = far;
+  view.camera3D.aspect = aspect;
+  view.camera3D.fov = fov;
+  view.camera3D.zoom = 1;
+  view.camera3D.updateProjectionMatrix();
+  xr.getCamera().getWorldPosition(view.camera3D.position);
+  xr.getCamera().getWorldQuaternion(view.camera3D.quaternion);
+
+  // Update the local transformation matrix for the object itself
+  view.camera3D.updateMatrix();
+
+  // // Update the world transformation matrix, ensuring it reflects global transforms
+  view.camera3D.updateMatrixWorld(true);
+  view.notifyChange(view.camera3D, true);
 }
-const initializeWebXR = (view, options) => {
-  const scale = options.scale || 1.0;
-  const xr = view.mainLoop.gfxEngine.renderer.xr;
-  xr.addEventListener('sessionstart', () => {
-    const camera = view.camera.camera3D;
-    const exitXRSession = event => {
-      if (event.key === 'Escape') {
-        document.removeEventListener('keydown', exitXRSession);
-        xr.enabled = false;
-        view.camera.camera3D = camera;
-        view.scene.scale.multiplyScalar(1 / scale);
-        view.scene.updateMatrixWorld();
-        shutdownXR(xr.getSession());
-        view.notifyChange(view.camera.camera3D, true);
-      }
-    };
-    view.scene.scale.multiplyScalar(scale);
-    view.scene.updateMatrixWorld();
-    xr.enabled = true;
-    xr.getReferenceSpace('local');
-    const position = view.camera.position();
-    const geodesicNormal = new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 0, 1), position.geodesicNormal).invert();
-    const quat = new THREE.Quaternion(-1, 0, 0, 1).normalize().multiply(geodesicNormal);
-    const trans = camera.position.clone().multiplyScalar(-scale).applyQuaternion(quat);
-    const transform = new XRRigidTransform(trans, quat);
-    const baseReferenceSpace = xr.getReferenceSpace();
-    const teleportSpaceOffset = baseReferenceSpace.getOffsetReferenceSpace(transform);
-    xr.setReferenceSpace(teleportSpaceOffset);
-    view.camera.camera3D = xr.getCamera();
-    view.camera.resize(view.camera.width, view.camera.height);
-    document.addEventListener('keydown', exitXRSession, false);
-
-    // TODO Fix asynchronization between xr and MainLoop render loops.
-    // (see MainLoop#scheduleViewUpdate).
-    xr.setAnimationLoop(timestamp => {
-      if (xr.isPresenting && view.camera.camera3D.cameras[0]) {
-        view.camera.camera3D.updateMatrix();
-        view.camera.camera3D.updateMatrixWorld(true);
-        view.notifyChange(view.camera.camera3D, true);
+// Note: WebXR cameras are perspective cameras
+function extractCameraAttributesFromProjectionMatrix(projectionMatrix) {
+  const m = projectionMatrix.elements;
+
+  // Extract near and far
+  const near = m[14] / (m[10] - 1);
+  const far = m[14] / (m[10] + 1);
+
+  // Extract vertical FOV
+  const fovY = 2 * Math.atan(1 / m[5]); // m[5] = 1 / tan(fovY / 2)
+  const fov = THREE.MathUtils.radToDeg(fovY); // Convert to degrees
+
+  // Extract aspect ratio
+  const aspect = m[5] / m[0]; // m[0] = 1 / (tan(fovY / 2) * aspect)
+
+  return {
+    near,
+    far,
+    aspect,
+    fov
+  };
+}
+/**
+ * @property {VRControls} vrControls - WebXR controllers handler
+ * */
+class WebXR extends THREE.EventDispatcher {
+  /**
+   * Handler of a webXR session
+   *
+   *
+   * @param {GlobeView} view - The view where the webXR session will be started
+   * @param {Object} [options] - WebXR configuration - its presence alone
+   * enable WebXR to switch on VR visualization.
+   * @param {function} [options.callback] - WebXR rendering callback (optional).
+   * @param {boolean} [options.controllers] - Enable the webXR controllers handling (optional).
+   */
+  constructor(view, options) {
+    super();
+    this.view = view;
+    this.options = options;
+    this.renderCb = options.callback;
+    this.vrControls = null;
+  }
+
+  // Start the webXR handler
+  initializeWebXR = () => {
+    const xr = this.view.renderer.xr;
+    xr.addEventListener('sessionstart', () => {
+      xr.enabled = true;
+      xr.getReferenceSpace('local');
+
+      // To avoid controllers precision issues, headset should handle camera position
+      const vrHeadSet = new THREE.Object3D();
+      vrHeadSet.name = 'xrHeadset';
+      this.view.scene.add(vrHeadSet);
+      this.view.camera3D.getWorldPosition(vrHeadSet.position);
+      this.view.camera3D.getWorldQuaternion(vrHeadSet.quaternion);
+      vrHeadSet.updateMatrixWorld(true);
+      vrHeadSet.add(xr.getCamera());
+
+      // Placeholder camera to initialize correctly the vr, which needs a parent
+      this.view._camXR = this.view.camera3D.clone();
+
+      // Important to see the controllers -> maybe could be improved
+      this.view._camXR.far = 2000000;
+      this.view._camXR.near = 0.1;
+      this.view._camXR.updateProjectionMatrix();
+      vrHeadSet.add(this.view._camXR);
+      this.view.notifyChange();
+      if (this.options.controllers) {
+        this.vrControls = new VRControls(this.view, vrHeadSet);
+        this.dispatchEvent({
+          type: 'vrControls-initialized'
+        });
       }
-      view.mainLoop.step(view, timestamp);
+      xr.setAnimationLoop(timestamp => {
+        if (xr.isPresenting && xr.getCamera().cameras.length > 0) {
+          // TODO should be called only once, but the first values are wrong because the camL&camR weren't updated
+          updateCamera3D(xr, this.view);
+
+          // This will also update the controllers position
+          vrHeadSet.updateMatrixWorld(true);
+          if (this.vrControls) {
+            this.vrControls.listenGamepad();
+          }
+          if (this.renderCb) {
+            this.renderCb();
+          }
+        }
+        this.view.mainLoop.step(this.view, timestamp);
+      });
     });
-  });
-};
-export default initializeWebXR;
+  };
+}
+export default WebXR;

package/lib/Renderer/c3DEngine.d.ts

@@ -0,0 +1,55 @@
+export default c3DEngine;
+declare class c3DEngine {
+    constructor(rendererOrDiv: any, options?: {});
+    width: any;
+    height: any;
+    positionBuffer: any;
+    _nextThreejsLayer: number;
+    fullSizeRenderTarget: THREE.WebGLRenderTarget<THREE.Texture>;
+    renderView: (view: any) => void;
+    /**
+     * @type {function}
+     * @param {number} w
+     * @param {number} h
+     */
+    onWindowResize: Function;
+    label2dRenderer: Label2DRenderer;
+    renderer: any;
+    getWindowSize(): THREE.Vector2;
+    /**
+     * return renderer THREE.js
+     * @returns {THREE.WebGLRenderer}
+     */
+    getRenderer(): THREE.WebGLRenderer;
+    /**
+     * Render view to a Uint8Array.
+     *
+     * @param {View} view - The view to render
+     * @param {object} [zone] - partial zone to render
+     * @param {number} zone.x - x (in view coordinate)
+     * @param {number} zone.y - y (in view coordinate)
+     * @param {number} zone.width - width of area to render (in pixels)
+     * @param {number} zone.height - height of area to render (in pixels)
+     * @return {THREE.RenderTarget} - Uint8Array, 4 bytes per pixel. The first pixel in
+     * the array is the bottom-left pixel.
+     */
+    renderViewToBuffer(view: View, zone?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): THREE.RenderTarget;
+    /**
+     * Render view to a THREE.RenderTarget.
+     *
+     * @param {View} view - The view to render
+     * @param {THREE.RenderTarget} [target] - destination render target. Default value: full size render target owned by c3DEngine.
+     * @param {object} [zone] - partial zone to render (zone x/y uses view coordinates) Note: target must contain complete zone
+     * @return {THREE.RenderTarget} - the destination render target
+     */
+    renderViewToRenderTarget(view: View, target?: THREE.RenderTarget, zone?: object): THREE.RenderTarget;
+    bufferToImage(pixelBuffer: any, width: any, height: any): HTMLImageElement;
+    depthBufferRGBAValueToOrthoZ(depthBufferRGBA: any, camera: any): number;
+}
+import * as THREE from 'three';
+import Label2DRenderer from '../Renderer/Label2DRenderer';

package/lib/Renderer/c3DEngine.js

@@ -51,7 +51,11 @@ class c3DEngine {
     this.fullSizeRenderTarget.depthTexture.type = THREE.UnsignedShortType;
     this.renderView = function (view) {
       this.renderer.clear();
-      this.renderer.render(view.scene, view.camera3D);
+      if (view._camXR) {
+        this.renderer.render(view.scene, view._camXR);
+      } else {
+        this.renderer.render(view.scene, view.camera3D);
+      }
       if (view.tileLayer) {
         this.label2dRenderer.render(view.tileLayer.object3d, view.camera3D);
       }

package/lib/Source/C3DTilesGoogleSource.d.ts

@@ -0,0 +1,38 @@
+export default C3DTilesGoogleSource;
+/**
+ * An object defining the source connection to a 3DTiles asset from a [Google api](https://tile.googleapis.com).
+ *
+ * @extends C3DTilesSource
+ *
+ * @property {boolean} isC3DTilesGoogleSource - Used to checkout whether this source is a C3DTilesGoogleSource. Default is
+ * true. You should not change this, as it is used internally for optimisation.
+ * @property {string} url - The URL to the tileset json.
+ * @property {string} baseUrl - The base URL to access tiles.
+ */
+declare class C3DTilesGoogleSource extends C3DTilesSource {
+    /**
+     * Create a new Source for 3D Tiles data from Google api (experimental).
+     *
+     * @extends C3DTilesSource
+     *
+     * @property {boolean} isC3DTilesGoogleSource - Used to checkout whether this source is a C3DTilesGoogleSource. Default is
+     * true. You should not change this, as it is used internally for optimisation.
+     * @param {Object} source An object that can contain all properties of a C3DTilesGoogleSource and {@link Source}.
+     * @param {String} source.key Your google tiles map API access key
+     */
+    constructor(source: {
+        key: string;
+    });
+    isC3DTilesGoogleSource: boolean;
+    baseUrl: string;
+    key: string;
+    sessionId: any;
+    /**
+     * Adds the key and session to the tile url (non-standard behaviour, that is specific to Google 3D tiles),
+     * see https://github.com/CesiumGS/3d-tiles/issues/746
+     * @param {String} url the tile url
+     * @returns {String} the tile url with Google map tiles api key and session parameters added at the end of the url
+     */
+    getTileUrl(url: string): string;
+}
+import C3DTilesSource from './C3DTilesSource';

package/lib/Source/C3DTilesIonSource.d.ts

@@ -0,0 +1,31 @@
+export default C3DTilesIonSource;
+/**
+ * An object defining the source connection to a 3DTiles asset of a [Cesium ion server](https://cesium.com/learn/ion/).
+ *
+ * @extends Source
+ *
+ * @property {boolean} isC3DTilesIonSource - Used to checkout whether this source is a C3DTilesIonSource. Default is
+ * true. You should not change this, as it is used internally for optimisation.
+ * @property {string} url - The URL of the tileset json.
+ * @property {string} baseUrl - The base URL to access tiles.
+ * @property {string} accessToken - The Cesium ion access token used to retrieve the resource.
+ * @property {string} assetId - The id of the asset on Cesium ion.
+ */
+declare class C3DTilesIonSource {
+    /**
+     * Create a new Source for 3D Tiles data from Cesium ion.
+     *
+     * @extends Source
+     *
+     * @param {Object} source An object that can contain all properties of a C3DTilesIonSource and {@link Source}.
+     * Only `accessToken` and `assetId` are mandatory.
+     */
+    constructor(source: Object);
+    isC3DTilesIonSource: boolean;
+    accessToken: any;
+    assetId: any;
+    whenReady: Promise<Object>;
+    url: any;
+    baseUrl: any;
+    attribution: any;
+}

package/lib/Source/C3DTilesSource.d.ts

@@ -0,0 +1,17 @@
+export default C3DTilesSource;
+/**
+ * An object defining the source connection to a 3DTiles dataset from a web server.
+ *
+ * @extends Source
+ *
+ * @property {boolean} isC3DTilesSource - Used to checkout whether this source is a isC3DTilesSource. Default is
+ * true. You should not change this, as it is used internally for optimisation.
+ * @property {string} url - The URL of the tileset json.
+ * @property {string} baseUrl - The base URL to access tiles.
+ */
+declare class C3DTilesSource extends Source {
+    isC3DTilesSource: boolean;
+    baseUrl: any;
+    whenReady: Promise<Object>;
+}
+import Source from '../Source/Source';

package/lib/Source/CopcSource.d.ts

@@ -0,0 +1,79 @@
+export default CopcSource;
+/**
+ * A source for [Cloud Optimised Point Cloud](https://copc.io/) (COPC) data.
+ * Such data consists of a [LAZ 1.4](https://www.ogc.org/standard/las/) file
+ * that stores compressed points data organized in a clustered octree.
+ *
+ * A freshly created source fetches and parses portions of the file
+ * corresponding to the LAS 1.4 header, all the Variable Length Record (VLR)
+ * headers as well the following VLRs:
+ * - COPC [`info`](https://copc.io/#info-vlr) record (mandatory)
+ * - LAS 1.4 `OGC Coordinate System WKT` record (mandatory, see [Las 1.4
+ *   spec](https://portal.ogc.org/files/?artifact_id=74523))
+ * - LAS 1.4 `Extra Bytes` record (optional, see [Las 1.4
+ *   spec](https://portal.ogc.org/files/?artifact_id=74523))
+ *
+ * @extends {Source}
+ *
+ * @property {boolean} isCopcSource - Read-only flag to check that a given
+ * object is of type CopcSource.
+ * @property {Object} header - LAS header of the source.
+ * @property {Object[]} eb - List of headers of each Variable Length Records
+ * (VLRs).
+ * @property {Object} info - COPC `info` VLR.
+ * @property {number[]} info.cube - Bounding box of the octree as a 6-elements.
+ * tuple `[minX, minY, minZ, maxX, maxY, maxZ]`. Computed from `center_x`,
+ * `center_y`, `center_z` and `halfSize` properties.
+ * @property {Object} info.rootHierarchyPage - Hierarchy page of the root node.
+ * @property {number} info.rootHierarchyPage.pageOffset - Absolute Offset to the
+ * root node data chunk.
+ * @property {number} info.rootHierarchyPage.pageOffset - Size (in bytes) of the
+ * root node data chunk.
+ * @property {number[]} gpsTimeRange - A 2-element tuple denoting the minimum
+ * and maximum values of attribute `gpsTime`.
+ */
+declare class CopcSource extends Source {
+    /**
+     * @param {Object} config - Source configuration
+     * @param {string} config.url - URL of the COPC resource.
+     * @param {8 | 16} [config.colorDepth=16] - Encoding of the `color`
+     * attribute. Either `8` or `16` bits.
+     * @param {string} [config._lazPerfBaseUrl] - (experimental) Overrides base
+     * url of the `las-zip.wasm` file of the `laz-perf` library.
+     * @param {string} [config.crs='EPSG:4326'] - Native CRS of the COPC
+     * ressource. Note that this is not for now inferred from the COPC header.
+     * @param {RequestInit} [config.networkOptions] - Fetch options (passed
+     * directly to `fetch()`), see [the syntax for more information](
+     * https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Syntax).
+     * @param {Object} [config.attribution] - Attribution of the data.
+     */
+    constructor(config: {
+        url: string;
+        colorDepth?: 8 | 16 | undefined;
+        _lazPerfBaseUrl?: string | undefined;
+        crs?: string | undefined;
+        networkOptions?: RequestInit | undefined;
+        attribution?: Object | undefined;
+    });
+    isCopcSource: boolean;
+    parser: (data: ArrayBuffer, options?: {
+        in: {
+            pointCount: number;
+            header: {
+                pointDataRecordFormat: number;
+                pointDataRecordLength: number;
+            };
+        };
+        eb?: Object | undefined;
+    }) => Promise<THREE.BufferGeometry>;
+    fetcher: (url: any, options?: {}) => Promise<ArrayBuffer>;
+    colorDepth: 8 | 16;
+    whenReady: Promise<this>;
+    header: Las.Header;
+    info: Info;
+    eb: Las.ExtraBytes[];
+}
+import Source from '../Source/Source';
+import * as THREE from 'three';
+import { Las } from 'copc';
+import { Info } from 'copc';

package/lib/Source/EntwinePointTileSource.d.ts

@@ -0,0 +1,40 @@
+export default EntwinePointTileSource;
+/**
+ * An object defining the source of Entwine Point Tile data. It fetches and
+ * parses the main configuration file of Entwine Point Tile format,
+ * [`ept.json`](https://entwine.io/entwine-point-tile.html#ept-json).
+ *
+ * @extends Source
+ *
+ * @property {boolean} isEntwinePointTileSource - Used to checkout whether this
+ * source is a EntwinePointTileSource. Default is true. You should not change
+ * this, as it is used internally for optimisation.
+ * @property {string} url - The URL of the directory containing the whole
+ * Entwine Point Tile structure.
+ */
+declare class EntwinePointTileSource extends Source {
+    /**
+     * @param {Object} config - The configuration, see {@link Source} for
+     * available values.
+     * @param {number|string} [config.colorDepth='auto'] - Does the color
+     * encoding is known ? Is it `8` or `16` bits ? By default it is to
+     * `'auto'`, but it will be more performant if a specific value is set.
+     */
+    constructor(config: {
+        colorDepth?: string | number | undefined;
+    });
+    isEntwinePointTileSource: boolean;
+    colorDepth: string | number | undefined;
+    whenReady: Promise<this>;
+    parse: ((buffer: ArrayBuffer, options: Object) => Promise<any>) | ((data: ArrayBuffer, options?: {
+        in?: {
+            colorDepth?: 8 | 16 | undefined;
+        } | undefined;
+    }) => Promise<any>);
+    extension: string;
+    boundsConforming: any;
+    bounds: any;
+    span: any;
+    fetcher: (url: any, options?: {}) => Promise<ArrayBuffer>;
+}
+import Source from '../Source/Source';

package/lib/Source/EntwinePointTileSource.js

@@ -56,11 +56,6 @@ class EntwinePointTileSource extends Source {
           console.warn('EntwinePointTileSource: Vertical coordinates system code is not yet supported.');
         }
       }
-
-      // NOTE: this spacing is kinda arbitrary here, we take the width and
-      // length (height can be ignored), and we divide by the specified
-      // span in ept.json. This needs improvements.
-      this.spacing = (Math.abs(metadata.boundsConforming[3] - metadata.boundsConforming[0]) + Math.abs(metadata.boundsConforming[4] - metadata.boundsConforming[1])) / (2 * metadata.span);
       this.boundsConforming = metadata.boundsConforming;
       this.bounds = metadata.bounds;
       this.span = metadata.span;

package/lib/Source/FileSource.d.ts

@@ -0,0 +1,118 @@
+export default FileSource;
+/**
+ * An object defining the source of a single resource to get from a direct
+ * access. It inherits from {@link Source}. There is multiple ways of adding a
+ * resource here:
+ * <ul>
+ *  <li>add the file like any other sources, using the `url` property.</li>
+ *  <li>fetch the file, and give the data to the source using the `fetchedData`
+ *  property.</li>
+ *  <li>fetch the file, parse it and git the parsed data to the source using the
+ *  `features` property.</li>
+ * </ul>
+ * See the examples below for real use cases.
+ *
+ * @extends Source
+ *
+ * @property {boolean} isFileSource - Used to checkout whether this source is a
+ * FileSource. Default is true. You should not change this, as it is used
+ * internally for optimisation.
+ * @property {*} fetchedData - Once the file has been loaded, the resulting data
+ * is stored in this property.
+ * @property {*} features - Once the file has been loaded and parsed, the
+ * resulting data is stored in this property.
+ *
+ * @example <caption>Simple: create a source, a layer, and let iTowns taking
+ * care of everything.</caption>
+ * const kmlSource = new itowns.FileSource({
+ *     url: 'https://raw.githubusercontent.com/iTowns/iTowns2-sample-data/master/croquis.kml',
+ *     crs: 'EPSG:4326',
+ *     fetcher: itowns.Fetcher.xml,
+ *     parser: itowns.KMLParser.parse,
+ * });
+ *
+ * const kmlLayer = new itowns.ColorLayer('Kml', {
+ *     name: 'kml',
+ *     transparent: true,
+ *     crs: view.tileLayer.extent.crs,
+ *     source: kmlSource,
+ * });
+ *
+ * view.addLayer(kmlLayer);
+ *
+ * @example <caption>Advanced: fetch some data, create a source, a layer, and
+ * let iTowns do the parsing and converting.</caption>
+ * // Parse and Convert by iTowns
+ * itowns.Fetcher.xml('https://raw.githubusercontent.com/iTowns/iTowns2-sample-data/master/ULTRA2009.gpx')
+ *     .then(function _(gpx) {
+ *         const gpxSource = new itowns.FileSource({
+ *             data: gpx,
+ *             crs: 'EPSG:4326',
+ *             parser: itowns.GpxParser.parse,
+ *         });
+ *
+ *         const gpxLayer = new itowns.ColorLayer('Gpx', {
+ *             name: 'Ultra 2009',
+ *             transparent: true,
+ *             source: gpxSource,
+ *         });
+ *
+ *         return view.addLayer(gpxLayer);
+ *     });
+ *
+ * @example <caption>More advanced: create a layer, fetch some data, parse the
+ * data, append a source to the layer and add the layer to iTowns.</caption>
+ * // Create a layer
+ * const ariege = new itowns.GeometryLayer('ariege', new itowns.THREE.Group());
+ *
+ * // Specify update method and conversion
+ * ariege.update = itowns.FeatureProcessing.update;
+ * ariege.convert = itowns.Feature2Mesh.convert({
+ *     color: () => new itowns.THREE.Color(0xffcc00),
+ *     extrude: () => 5000,
+ * });
+ *
+ * itowns.Fetcher.json('https://raw.githubusercontent.com/gregoiredavid/france-geojson/master/departements/09-ariege/departement-09-ariege.geojson')
+ *     .then(function _(geojson) {
+ *         return itowns.GeoJsonParser.parse(geojson, {
+ *             in: { crs: 'EPSG:4326' },
+ *             out: { crs: view.tileLayer.extent.crs,
+ *                      style: new itowns.Style({
+ *                          fill: {
+ *                              color: new itowns.THREE.Color(0xffcc00),
+ *                              extrusion_height: () => 5000,
+ *                      }),
+ *                  },
+ *             },
+ *         });
+ *     }).then(function _(features) {
+ *         ariege.source = new itowns.FileSource({
+ *             crs: 'EPSG:4326',
+ *             features,
+ *         });
+ *
+ *         return view.addLayer(ariegeLayer);
+ *     });
+ */
+declare class FileSource extends Source {
+    isFileSource: boolean;
+    fetchedData: any;
+    whenReady: any;
+    zoom: {
+        min: number;
+        max: number;
+    };
+    urlFromExtent(): any;
+    onLayerAdded(options: any): void;
+    /**
+     * load  data from cache or Fetch/Parse data.
+     * The loaded data is a Feature or Texture.
+     *
+     * @param      {Extent}  extent   extent requested parsed data.
+     * @param      {FeatureBuildingOptions|Layer}  out  The feature returned options
+     * @return     {FeatureCollection|Texture}  The parsed data.
+     */
+    loadData(extent: Extent, out: FeatureBuildingOptions | Layer): FeatureCollection | Texture;
+    extentInsideLimit(extent: any): any;
+}
+import Source from '../Source/Source';

package/lib/Source/OGC3DTilesGoogleSource.d.ts

@@ -0,0 +1,24 @@
+export default OGC3DTilesGoogleSource;
+declare class OGC3DTilesGoogleSource extends OGC3DTilesSource {
+    /**
+     * An object defining the source connection to a 3D Tiles asset from [Google Tiles API](https://tile.googleapis.com).
+     *
+     * @extends OGC3DTilesSource
+     *
+     * @property {boolean} isOGC3DTilesGoogleSource - Used to check if this source is an OGC3DTilesGoogleSource. Set to true.
+     * You should not change this, as it is used internally for optimisation.
+     * @property {string} url - The URL to the tileset json.
+     * @property {string} baseUrl - The base URL to access tiles.
+     *
+     * @property {boolean} isOGC3DTilesGoogleSource - Used to check if this source is an OGC3DTilesGoogleSource. Set to
+     * true. You should not change this, as it is used internally for optimisation.
+     * @param {Object} source An object that can contain all properties of an OGC3DTilesGoogleSource and {@link Source}.
+     * @param {String} source.key Your google tiles map API access key
+     */
+    constructor(source: {
+        key: string;
+    });
+    isOGC3DTilesGoogleSource: boolean;
+    key: string;
+}
+import OGC3DTilesSource from './OGC3DTilesSource';

package/lib/Source/OGC3DTilesIonSource.d.ts

@@ -0,0 +1,26 @@
+export default OGC3DTilesIonSource;
+declare class OGC3DTilesIonSource extends OGC3DTilesSource {
+    /**
+     * An object defining the source connection to a 3DTiles asset of a [Cesium ion server](https://cesium.com/learn/ion/).
+     *
+     * @extends Source
+     *
+     * @property {boolean} isOGC3DTilesIonSource - Used to check if this source is an OGC3DTilesIonSource. Set to true.
+     * You should not change this, as it is used internally for optimisation.
+     * @property {string} accessToken - The Cesium ion access token used to retrieve the resource.
+     * @property {string} assetId - The id of the asset on Cesium ion.
+     *
+     * @param {Object} source An object that can contain all properties of an OGC3DTilesIonSource and {@link Source}.
+     * Only `accessToken` and `assetId` are mandatory.
+     * @param {string} source.accessToken - The Cesium ion access token used to retrieve the resource.
+     * @param {string} source.assetId - The id of the asset on Cesium ion.
+     */
+    constructor(source: {
+        accessToken: string;
+        assetId: string;
+    });
+    isOGC3DTilesIonSource: boolean;
+    accessToken: string;
+    assetId: string;
+}
+import OGC3DTilesSource from './OGC3DTilesSource';

package/lib/Source/OGC3DTilesSource.d.ts

@@ -0,0 +1,21 @@
+export default OGC3DTilesSource;
+declare class OGC3DTilesSource extends Source {
+    /**
+     * An object defining the source connection to a 3DTiles dataset from a web server.
+     *
+     * @extends Source
+     *
+     * @property {boolean} isOGC3DTilesSource - Used to check if this source is an isOGC3DTilesSource. Set to true.
+     * You should not change this, as it is used internally for optimisation.
+     * @property {string} url - The URL of the tileset json.
+     *
+     * @param {Object} source An object that can contain all properties of OGC3DTilesSource and of {@link Source}.
+     * Only `url` is mandatory.
+     * @param {string} source.url - The URL of the tileset json.
+     */
+    constructor(source: {
+        url: string;
+    });
+    isOGC3DTilesSource: boolean;
+}
+import Source from '../Source/Source';