itowns 2.45.1 → 2.45.2-next.1

package/lib/Main.d.ts

@@ -0,0 +1,89 @@
+export const REVISION: string;
+export { default as GeoidGrid } from "./Core/Geographic/GeoidGrid";
+export { default as PlanarView } from "./Core/Prefab/PlanarView";
+export { default as Fetcher } from "./Provider/Fetcher";
+export { MAIN_LOOP_EVENTS } from "./Core/MainLoop";
+export { default as FeatureProcessing } from "./Process/FeatureProcessing";
+export { default as ObjectRemovalHelper } from "./Process/ObjectRemovalHelper";
+export { default as OrientedImageCamera } from "./Renderer/OrientedImageCamera";
+export { default as FlyControls } from "./Controls/FlyControls";
+export { default as FirstPersonControls } from "./Controls/FirstPersonControls";
+export { default as StreetControls } from "./Controls/StreetControls";
+export { default as VRControls } from "./Controls/VRControls";
+export { VR_EVENTS } from "./Renderer/WebXR";
+export { default as Feature2Mesh } from "./Converter/Feature2Mesh";
+export { default as FeaturesUtils } from "./Utils/FeaturesUtils";
+export { default as DEMUtils } from "./Utils/DEMUtils";
+export { default as CameraUtils } from "./Utils/CameraUtils";
+export { default as ShaderChunk } from "./Renderer/Shader/ShaderChunk";
+export { default as Capabilities } from "./Core/System/Capabilities";
+export { CAMERA_TYPE } from "./Renderer/Camera";
+export { default as OBB } from "./Renderer/OBB";
+export { default as Style } from "./Core/Style";
+export { default as Label } from "./Core/Label";
+export { default as ColorLayer } from "./Layer/ColorLayer";
+export { default as ElevationLayer } from "./Layer/ElevationLayer";
+export { default as GeometryLayer } from "./Layer/GeometryLayer";
+export { default as FeatureGeometryLayer } from "./Layer/FeatureGeometryLayer";
+export { default as PointCloudLayer } from "./Layer/PointCloudLayer";
+export { default as PotreeLayer } from "./Layer/PotreeLayer";
+export { default as Potree2Layer } from "./Layer/Potree2Layer";
+export { default as TiledGeometryLayer } from "./Layer/TiledGeometryLayer";
+export { default as OrientedImageLayer } from "./Layer/OrientedImageLayer";
+export { default as ColorLayersOrdering } from "./Renderer/ColorLayersOrdering";
+export { default as GlobeLayer } from "./Core/Prefab/Globe/GlobeLayer";
+export { default as PlanarLayer } from "./Core/Prefab/Planar/PlanarLayer";
+export { default as LabelLayer } from "./Layer/LabelLayer";
+export { default as EntwinePointTileLayer } from "./Layer/EntwinePointTileLayer";
+export { default as CopcLayer } from "./Layer/CopcLayer";
+export { default as GeoidLayer } from "./Layer/GeoidLayer";
+export { default as Source } from "./Source/Source";
+export { default as FileSource } from "./Source/FileSource";
+export { default as TMSSource } from "./Source/TMSSource";
+export { default as WFSSource } from "./Source/WFSSource";
+export { default as WMSSource } from "./Source/WMSSource";
+export { default as WMTSSource } from "./Source/WMTSSource";
+export { default as VectorTilesSource } from "./Source/VectorTilesSource";
+export { default as OrientedImageSource } from "./Source/OrientedImageSource";
+export { default as PotreeSource } from "./Source/PotreeSource";
+export { default as Potree2Source } from "./Source/Potree2Source";
+export { default as C3DTilesSource } from "./Source/C3DTilesSource";
+export { default as C3DTilesIonSource } from "./Source/C3DTilesIonSource";
+export { default as C3DTilesGoogleSource } from "./Source/C3DTilesGoogleSource";
+export { default as OGC3DTilesSource } from "./Source/OGC3DTilesSource";
+export { default as OGC3DTilesIonSource } from "./Source/OGC3DTilesIonSource";
+export { default as OGC3DTilesGoogleSource } from "./Source/OGC3DTilesGoogleSource";
+export { default as EntwinePointTileSource } from "./Source/EntwinePointTileSource";
+export { default as CopcSource } from "./Source/CopcSource";
+export { default as GpxParser } from "./Parser/GpxParser";
+export { default as GeoJsonParser } from "./Parser/GeoJsonParser";
+export { default as KMLParser } from "./Parser/KMLParser";
+export { default as CameraCalibrationParser } from "./Parser/CameraCalibrationParser";
+export { default as ShapefileParser } from "./Parser/ShapefileParser";
+export { default as LASParser } from "./Parser/LASParser";
+export { default as ISGParser } from "./Parser/ISGParser";
+export { default as GDFParser } from "./Parser/GDFParser";
+export { default as GTXParser } from "./Parser/GTXParser";
+export { default as B3dmParser } from "./Parser/B3dmParser";
+export { default as iGLTFLoader } from "./Parser/iGLTFLoader";
+export { default as C3DTFeature } from "./Core/3DTiles/C3DTFeature";
+export { default as C3DTileset } from "./Core/3DTiles/C3DTileset";
+export { default as C3DTBoundingVolume } from "./Core/3DTiles/C3DTBoundingVolume";
+export { default as C3DTBatchTable } from "./Core/3DTiles/C3DTBatchTable";
+export { default as C3DTExtensions } from "./Core/3DTiles/C3DTExtensions";
+export { default as C3DTBatchTableHierarchyExtension } from "./Core/3DTiles/C3DTBatchTableHierarchyExtension";
+export { Coordinates, Extent, CRS, Ellipsoid, ellipsoidSizes, OrientationUtils } from "@itowns/geographic";
+export { default as GlobeView, GLOBE_VIEW_EVENTS } from "./Core/Prefab/GlobeView";
+export { default as View, VIEW_EVENTS } from "./Core/View";
+export { updateLayeredMaterialNodeImagery, updateLayeredMaterialNodeElevation } from "./Process/LayeredMaterialNodeProcessing";
+export { default as PointsMaterial, PNTS_MODE, PNTS_SHAPE, PNTS_SIZE_MODE, ClassificationScheme } from "./Renderer/PointsMaterial";
+export { default as GlobeControls, CONTROL_EVENTS } from "./Controls/GlobeControls";
+export { default as PlanarControls, PLANAR_CONTROL_EVENT } from "./Controls/PlanarControls";
+export { getMaxColorSamplerUnitsCount, colorLayerEffects } from "./Renderer/LayeredMaterial";
+export { default as Feature, FeatureCollection, FeatureGeometry, FEATURE_TYPES } from "./Core/Feature";
+export { default as Layer, ImageryLayers } from "./Layer/Layer";
+export { default as C3DTilesLayer, C3DTILES_LAYER_EVENTS } from "./Layer/C3DTilesLayer";
+export { default as OGC3DTilesLayer, OGC3DTILES_LAYER_EVENTS, enableDracoLoader, enableKtx2Loader, enableMeshoptDecoder } from "./Layer/OGC3DTilesLayer";
+export { STRATEGY_MIN_NETWORK_TRAFFIC, STRATEGY_GROUP, STRATEGY_PROGRESSIVE, STRATEGY_DICHOTOMY } from "./Layer/LayerUpdateStrategy";
+export { C3DTilesTypes, C3DTilesBoundingVolumeTypes } from "./Core/3DTiles/C3DTilesEnums";
+export { process3dTilesNode, $3dTilesCulling, $3dTilesSubdivisionControl } from "./Process/3dTilesProcessing";

package/lib/Main.js

@@ -1,5 +1,5 @@
 const conf = {
-  version: '2.45.1'
+  version: '2.45.2-next.1'
 };
 export const REVISION = conf.version;
 
@@ -22,6 +22,8 @@ export { default as FlyControls } from "./Controls/FlyControls.js";
 export { default as FirstPersonControls } from "./Controls/FirstPersonControls.js";
 export { default as StreetControls } from "./Controls/StreetControls.js";
 export { default as PlanarControls } from "./Controls/PlanarControls.js";
+export { default as VRControls } from "./Controls/VRControls.js";
+export { VR_EVENTS } from "./Renderer/WebXR.js";
 export { CONTROL_EVENTS } from "./Controls/GlobeControls.js";
 export { PLANAR_CONTROL_EVENT } from "./Controls/PlanarControls.js";
 export { default as Feature2Mesh } from "./Converter/Feature2Mesh.js";

package/lib/Parser/B3dmParser.d.ts

@@ -0,0 +1,26 @@
+declare namespace _default {
+    /** Parse b3dm buffer and extract THREE.Scene and batch table
+     * @param {ArrayBuffer} buffer - the b3dm buffer.
+     * @param {Object} options - additional properties.
+     * @param {string=} [options.gltfUpAxis='Y'] - embedded glTF model up axis.
+     * @param {string} options.urlBase - the base url of the b3dm file (used to fetch textures for the embedded glTF model).
+     * @param {boolean=} [options.doNotPatchMaterial=false] - disable patching material with logarithmic depth buffer support.
+     * @param {float} [options.opacity=1.0] - the b3dm opacity.
+     * @param {boolean=} [options.frustumCulled=false] - enable frustum culling.
+     * @param {boolean|Material=} [options.overrideMaterials=false] - override b3dm's embedded glTF materials. If
+     * true, a threejs [MeshBasicMaterial](https://threejs.org/docs/index.html?q=meshbasic#api/en/materials/MeshBasicMaterial)
+     * is set up. config.overrideMaterials can also be a threejs [Material](https://threejs.org/docs/index.html?q=material#api/en/materials/Material)
+     * in which case it will be the material used to override.
+     * @return {Promise} - a promise that resolves with an object containig a THREE.Scene (gltf) and a batch table (batchTable).
+     *
+     */
+    function parse(buffer: ArrayBuffer, options: {
+        gltfUpAxis?: string | undefined;
+        urlBase: string;
+        doNotPatchMaterial?: boolean | undefined;
+        opacity?: any;
+        frustumCulled?: boolean | undefined;
+        overrideMaterials?: (boolean | Material) | undefined;
+    }): Promise<any>;
+}
+export default _default;

package/lib/Parser/CameraCalibrationParser.d.ts

@@ -0,0 +1,32 @@
+declare namespace _default {
+    /**
+     * Description of a camera calibration in a JSON file.
+     *
+     * @typedef CameraCalibrationJson
+     * @type {Object}
+     *
+     * @property {number[]} projection - projection matrix,
+     * @property {number[]} size - image size in pixel.
+     * @property {number[]} position - position of the camera.
+     * @property {number[]} rotation - rotation matrix
+     * @property {Object} [distorsion={}] - distorsion
+     * @property {number[]} [distorsion.pps]
+     * @property {number[]} [distorsion.poly357]
+     * @property {number[]} [distorsion.limit]
+     * @property {number[]} [distorsion.l1l2]
+     * @property {number[]} [distorsion.etat]
+     */
+    /**
+     * Parser a JSON array of camera calibrations and return an array of {@link OrientedImageCamera}.
+     * @param {string|JSON} json - the json content of the calibration file.
+     * @param {Object} [options={}] - Options controlling the parsing.
+     * @param {string} [options.near=0.1] - Near of the created cameras. Default value comes from created {@link OrientedImageCamera}
+     * @param {string} [options.far=1000] - Far of the created cameras. Default value comes from created {@link OrientedImageCamera}
+     * @return {Promise} - A promise resolving with an array of {@link OrientedImageCamera}.
+     */
+    function parse(json: string | JSON, options?: {
+        near?: string | undefined;
+        far?: string | undefined;
+    }): Promise<any>;
+}
+export default _default;

package/lib/Parser/GDFParser.d.ts

@@ -0,0 +1,24 @@
+export function getHeaderAttribute(header: any, attributeName: any): number;
+declare namespace _default {
+    /**
+     * Parses a GDF file content and returns a corresponding {@link GeoidGrid}.
+     *
+     * @param   {string}    gdf                             The content of the GDF file to parse.
+     * @param   {Object}    options                         An object gathering the optional parameters to pass to
+                                                            * the parser.
+     * @param   {Object}    [options.in={}]                 Information on the GDF data.
+     * @param   {string}    [options.in.crs='EPSG:4326']    The Coordinates Reference System (CRS) of the GDF data.
+                                                            * It must be a geographic CRS, and must be given as an EPSG
+                                                            * code.
+     *
+     * @returns {Promise<GeoidGrid>}    A promise resolving with a {@link GeoidGrid}, which contains all the necessary
+                                        * attributes and methods to access GDF file data.
+     */
+    function parse(gdf: string, options?: {
+        in?: {
+            crs?: string | undefined;
+        } | undefined;
+    }): Promise<GeoidGrid>;
+}
+export default _default;
+import GeoidGrid from '../Core/Geographic/GeoidGrid';

package/lib/Parser/GTXParser.d.ts

@@ -0,0 +1,28 @@
+export const BYTES_PER_DOUBLE: 8;
+export const BYTES_PER_FLOAT: 4;
+declare namespace _default {
+    /**
+     * Parses a GTX file content and returns a corresponding {@link GeoidGrid}.
+     *
+     * @param   {ArrayBuffer}   gtx                             The content of the GTX file to parse.
+     * @param   {Object}        options                         An object gathering the optional parameters to pass to
+                                                                * the parser.
+     * @param   {Object}        [options.in={}]                 Information on the GTX data.
+     * @param   {string}        [options.in.crs='EPSG:4326']    The Coordinates Reference System (CRS) of the GTX data.
+                                                                * It must be a geographic CRS, and must be given as an
+                                                                * EPSG code.
+     * @param   {string}        [options.in.dataType='float']   The encoding of geoid height data within the GTX file.
+                                                                * Must be `'float'` or `'double'`.
+     *
+     * @returns {Promise<GeoidGrid>}    A promise resolving with a {@link GeoidGrid}, which contains all the necessary
+                                        * attributes and methods to access GTX file data.
+     */
+    function parse(gtx: ArrayBuffer, options?: {
+        in?: {
+            crs?: string | undefined;
+            dataType?: string | undefined;
+        } | undefined;
+    }): Promise<GeoidGrid>;
+}
+export default _default;
+import GeoidGrid from '../Core/Geographic/GeoidGrid';

package/lib/Parser/GeoJsonParser.d.ts

@@ -0,0 +1,12 @@
+declare namespace _default {
+    /**
+     * Parse a GeoJSON file content and return a {@link FeatureCollection}.
+     *
+     * @param {string} json - The GeoJSON file content to parse.
+     * @param {ParsingOptions} options - Options controlling the parsing.
+
+     * @return {Promise} A promise resolving with a {@link FeatureCollection}.
+     */
+    function parse(json: string, options?: ParsingOptions): Promise<any>;
+}
+export default _default;

package/lib/Parser/GpxParser.d.ts

@@ -0,0 +1,12 @@
+declare namespace _default {
+    /**
+     * Parse a GPX file content and return a {@link FeatureCollection}.
+     *
+     * @param {XMLDocument} gpxFile - The GPX file content to parse.
+     * @param {ParsingOptions} options - Options controlling the parsing.
+     *
+     * @return {Promise} A promise resolving with a {@link FeatureCollection}.
+     */
+    function parse(gpxFile: XMLDocument, options: ParsingOptions): Promise<any>;
+}
+export default _default;

package/lib/Parser/ISGParser.d.ts

@@ -0,0 +1,23 @@
+declare namespace _default {
+    /**
+     * Parses an ISG file content and returns a corresponding {@link GeoidGrid}.
+     *
+     * @param   {string}    isg                             The content of the ISG file to parse.
+     * @param   {Object}    options                         An object gathering the optional parameters to pass to
+                                                            * the parser.
+     * @param   {Object}    [options.in={}]                 Information on the ISG data.
+     * @param   {string}    [options.in.crs='EPSG:4326']    The Coordinates Reference System (CRS) of the ISG data.
+                                                            * It must be a geographic CRS, and must be given as an EPSG
+                                                            * code.
+     *
+     * @returns {Promise<GeoidGrid>}    A promise resolving with a {@link GeoidGrid}, which contains all the necessary
+                                        * attributes and methods to access ISG file data.
+     */
+    function parse(isg: string, options?: {
+        in?: {
+            crs?: string | undefined;
+        } | undefined;
+    }): Promise<GeoidGrid>;
+}
+export default _default;
+import GeoidGrid from '../Core/Geographic/GeoidGrid';

package/lib/Parser/KMLParser.d.ts

@@ -0,0 +1,12 @@
+declare namespace _default {
+    /**
+     * Parse a KML file content and return a {@link FeatureCollection}.
+     *
+     * @param {XMLDocument} kmlFile - The KML file content to parse.
+     * @param {ParsingOptions} options - Options controlling the parsing.
+     *
+     * @return {Promise} A promise resolving with a {@link FeatureCollection}.
+     */
+    function parse(kmlFile: XMLDocument, options: ParsingOptions): Promise<any>;
+}
+export default _default;

package/lib/Parser/LASParser.d.ts

@@ -0,0 +1,61 @@
+declare namespace _default {
+    function enableLazPerf(path: any): void;
+    /**
+     * Terminate all worker instances.
+     * @returns {Promise<void>}
+     */
+    function terminate(): Promise<void>;
+    /**
+     * Parses a chunk of a LAS or LAZ (LASZip) and returns the corresponding
+     * `THREE.BufferGeometry`.
+     *
+     * @param {ArrayBuffer} data - The file content to parse.
+     * @param {Object} options
+     * @param {Object} options.in - Options to give to the parser.
+     * @param {number} options.in.pointCount - Number of points encoded in this
+     * data chunk.
+     * @param {Object} options.in.header - Partial LAS file header.
+     * @param {number} options.in.header.pointDataRecordFormat - Type of Point
+     * Data Record contained in the LAS file.
+     * @param {number} options.in.header.pointDataRecordLength - Size (in bytes)
+     * of the Point Data Record.
+     * @param {Object} [options.eb] - Extra bytes LAS VLRs headers.
+     * @param { 8 | 16 } [options.in.colorDepth] - Color depth (in bits).
+     * Defaults to 8 bits for LAS 1.2 and 16 bits for later versions
+     * (as mandatory by the specification)
+     *
+     * @return {Promise<THREE.BufferGeometry>} A promise resolving with a
+     * `THREE.BufferGeometry`.
+     */
+    function parseChunk(data: ArrayBuffer, options?: {
+        in: {
+            pointCount: number;
+            header: {
+                pointDataRecordFormat: number;
+                pointDataRecordLength: number;
+            };
+        };
+        eb?: Object | undefined;
+    }): Promise<THREE.BufferGeometry>;
+    /**
+     * Parses a LAS file or a LAZ (LASZip) file and return the corresponding
+     * `THREE.BufferGeometry`.
+     *
+     * @param {ArrayBuffer} data - The file content to parse.
+     * @param {Object} [options]
+     * @param {Object} [options.in] - Options to give to the parser.
+     * @param { 8 | 16 } [options.in.colorDepth] - Color depth (in bits).
+     * Defaults to 8 bits for LAS 1.2 and 16 bits for later versions
+     * (as mandatory by the specification)
+     *
+     * @return {Promise} A promise resolving with a `THREE.BufferGeometry`. The
+     * header of the file is contained in `userData`.
+     */
+    function parse(data: ArrayBuffer, options?: {
+        in?: {
+            colorDepth?: 8 | 16 | undefined;
+        } | undefined;
+    }): Promise<any>;
+}
+export default _default;
+import * as THREE from 'three';

package/lib/Parser/MapBoxUrlParser.d.ts

@@ -0,0 +1,9 @@
+declare namespace _default {
+    export { normalizeStyleURL };
+    export { normalizeSourceURL };
+    export { normalizeSpriteURL };
+}
+export default _default;
+declare function normalizeStyleURL(url: any, accessToken: any): any;
+declare function normalizeSourceURL(url: any, accessToken: any): any;
+declare function normalizeSpriteURL(url: any, format: any, extension: any, accessToken: any): string;

package/lib/Parser/PntsParser.d.ts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function parse(buffer: ArrayBuffer, registeredExtensions: Object): Promise<any>;
+}
+export default _default;

package/lib/Parser/Potree2BinParser.d.ts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    /**
+     * @return {Promise<void>}
+     */
+    function terminate(): Promise<void>;
+    function parse(buffer: ArrayBuffer, options: Object): Promise<any>;
+}
+export default _default;

package/lib/Parser/PotreeBinParser.d.ts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function parse(buffer: ArrayBuffer, options: Object): Promise<any>;
+}
+export default _default;

package/lib/Parser/PotreeCinParser.d.ts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function parse(buffer: ArrayBuffer): Promise<any>;
+}
+export default _default;

package/lib/Parser/ShapefileParser.d.ts

@@ -0,0 +1,25 @@
+declare namespace _default {
+    /**
+     * Parse a bunch of Shapefile files and return a {@link FeatureCollection}.
+     *
+     * @param {Object} data - All the data that can be specified in a shapefile.
+     * @param {ArrayBuffer} data.shp - Data from the shapefile itself,
+     * containing the feature geometry itself.
+     * @param {ArrayBuffer} data.shx - A positional index of the feature
+     * geometry.
+     * @param {ArrayBuffer} data.dbf - Columnar attributes for each shape, in
+     * [dBase](https://en.wikipedia.org/wiki/DBase) IV format.
+     * @param {string} [data.prj] - The coordinate system and crs projection
+     * information.
+     * @param {ParsingOptions} [options]
+     *
+     * @return {Promise} A promise resolving with a {@link FeatureCollection}.
+     */
+    function parse(data: {
+        shp: ArrayBuffer;
+        shx: ArrayBuffer;
+        dbf: ArrayBuffer;
+        prj?: string | undefined;
+    }, options?: ParsingOptions): Promise<any>;
+}
+export default _default;

package/lib/Parser/VectorTileParser.d.ts

@@ -0,0 +1,34 @@
+declare namespace _default {
+    /**
+     * Parse a vector tile file and return a [Feature]{@link module:GeoJsonParser.Feature}
+     * or an array of Features. While multiple formats of vector tile are
+     * available, the only one supported for the moment is the
+     * [Mapbox Vector Tile](https://www.mapbox.com/vector-tiles/specification/).
+     *
+     * @param {ArrayBuffer} file - The vector tile file to parse.
+     *
+     * @param {Object} options - Options controlling the parsing {@link ParsingOptions}.
+     *
+     * @param {Object} options.in - Object containing all styles,
+     * layers and informations data, see {@link InformationsData}.
+     *
+     * @param {Object} options.in.styles - Object containing subobject with
+     * informations on a specific style layer. Styles available is by `layer.id` and by zoom.
+     *
+     * @param {Object} options.in.layers - Object containing subobject with
+     *
+     * @param {FeatureBuildingOptions} options.out - options indicates how the features should be built,
+     * see {@link FeatureBuildingOptions}.
+     *
+     * @return {Promise} A Promise resolving with a Feature or an array a
+     * Features.
+     */
+    function parse(file: ArrayBuffer, options: {
+        in: {
+            styles: Object;
+            layers: Object;
+        };
+        out: FeatureBuildingOptions;
+    }): Promise<any>;
+}
+export default _default;

package/lib/Parser/XbilParser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Calculates the minimum maximum texture elevation with xbil data
+ *
+ * @param      {THREE.Texture}   texture                     The texture to parse
+ * @param      {THREE.Vector4}   pitch                       The pitch,  restrict zone to parse
+ * @param      {Object}          options                     No data value and clamp values
+ * @param      {number}          options.noDataValue         No data value
+ * @param      {number}          [options.zmin]   The minimum elevation value after which it will be clamped
+ * @param      {number}          [options.zmax]   The maximum elevation value after which it will be clamped
+ * @return     {Object}  The minimum and maximum elevation.
+ */
+export function computeMinMaxElevation(texture: THREE.Texture, pitch: THREE.Vector4, options: {
+    noDataValue: number;
+    zmin?: number | undefined;
+    zmax?: number | undefined;
+}): Object;
+export function checkNodeElevationTextureValidity(data: any, noDataValue: any): boolean;
+export function insertSignificantValuesFromParent(data: any, dataParent: () => number, noDataValue: any): void;

package/lib/Parser/deprecated/LegacyGLTFLoader.d.ts

@@ -0,0 +1,32 @@
+export default threeExamples.LegacyGLTFLoader;
+declare var LegacyGLTFLoader: {
+    new (manager: any): {
+        load(url: any, onLoad: any, onProgress: any, onError: any): void;
+        parse(data: any, path: any, callback: any): void;
+        crossOrigin: string;
+        withCredentials: boolean;
+        path: string;
+        resourcePath: string;
+        manager: THREE.LoadingManager;
+        requestHeader: {
+            [header: string]: string;
+        };
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<any>;
+        setCrossOrigin(crossOrigin: string): /*elided*/ any;
+        setWithCredentials(value: boolean): /*elided*/ any;
+        setPath(path: string): /*elided*/ any;
+        setResourcePath(resourcePath: string): /*elided*/ any;
+        setRequestHeader(requestHeader: {
+            [header: string]: string;
+        }): /*elided*/ any;
+    };
+    Shaders: {
+        update: () => void;
+    };
+    Animations: {
+        update: () => void;
+    };
+    DEFAULT_MATERIAL_NAME: string;
+};
+declare namespace threeExamples { }
+import * as THREE from 'three';

package/lib/Parser/iGLTFLoader.d.ts

@@ -0,0 +1,104 @@
+export default iGLTFLoader;
+declare class iGLTFLoader extends THREE.Loader<any, string> {
+    /**
+     * Parses [glTF](https://www.khronos.org/gltf/) 1.0 and 2.0 files.
+     *
+     * Under the hood, glTF 2.0 files are parsed with THREE.GLTFLoader and GLTF 1.0 are parsed with the previous THREE
+     * GltfLoader (for 1.0 glTF) that has been kept and maintained in iTowns.
+     *
+     * Beware that gltf convention is y-up while itowns is z-up. You can apply a PI/2 rotation around the X axis to the
+     * loaded model to transform from y-up to z-up. Note that you can also use Coordinates.geodesicNormal to get the normal
+     * to a position on the globe (i.e. in GlobeView) to correctly orient a model on a GlobeView.
+     *
+     * @param {THREE.LoadingManager} [manager] - The loadingManager for the loader to use. Default is THREE.DefaultLoadingManager.
+     */
+    constructor(manager?: THREE.LoadingManager);
+    legacyGLTFLoader: {
+        load(url: any, onLoad: any, onProgress: any, onError: any): void;
+        parse(data: any, path: any, callback: any): void;
+        crossOrigin: string;
+        withCredentials: boolean;
+        path: string;
+        resourcePath: string;
+        manager: THREE.LoadingManager;
+        requestHeader: {
+            [header: string]: string;
+        };
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<any>;
+        setCrossOrigin(crossOrigin: string): /*elided*/ any;
+        setWithCredentials(value: boolean): /*elided*/ any;
+        setPath(path: string): /*elided*/ any;
+        setResourcePath(resourcePath: string): /*elided*/ any;
+        setRequestHeader(requestHeader: {
+            [header: string]: string;
+        }): /*elided*/ any;
+    };
+    glTFLoader: GLTFLoader;
+    /**
+     * Loads a gltf model from url and call the callback function with the parsed response content.
+     * Adapted from threejs.
+     * @param {String} url - the path/URL of the .gltf or .glb file.
+     * @param {Function} onLoad - A function to be called after the loading is successfully completed. The function
+     * receives the loaded JSON response returned from {@link parse}.
+     * @param {Function} onProgress
+     * @param {Function} onError
+     */
+    load(url: string, onLoad: Function, onProgress: Function, onError: Function): void;
+    /**
+     * Sets the draco loader instance for this gltf parser. Enable loading files with
+     * [Draco](https://google.github.io/draco/) geometry extension. See Threejs
+     * [DracoLoader](https://threejs.org/docs/index.html#examples/en/loaders/DRACOLoader) for more information.
+     * Only works for GLTF 2.0 files.
+     * @param {THREE.DracoLoader} dracoLoader - the threejs DracoLoader instance.
+     */
+    setDRACOLoader(dracoLoader: THREE.DracoLoader): void;
+    /**
+     * Sets the KTX2 loader instance for this gltf parser. Enable loading files with
+     * [KTX2](https://www.khronos.org/ktx/) texture extension. See Threejs
+     * [KTX2Loader](https://threejs.org/docs/index.html?q=KTX2#examples/en/loaders/KTX2Loader) for more information.
+     * Only works for GLTF 2.0 files.
+     * @param {THREE.KTX2Loader} ktx2Loader - the threejs KTX2Loader instance.
+     */
+    setKTX2Loader(ktx2Loader: THREE.KTX2Loader): void;
+    /**
+     * Sets the Mesh Optimizer decoder instance for this gltf parser. Enable loading files with
+     * [MeshOptimizer](https://meshoptimizer.org/) geometry extension.
+     * Only works for GLTF 2.0 files.
+     * @param {Object} meshoptDecoder - the threejs meshopt decoder instance.
+     */
+    setMeshoptDecoder(meshoptDecoder: Object): void;
+    /**
+     * Registers a callback to load specific unknown or not standard GLTF extensions.
+     * See Threejs [GltfLoader](https://threejs.org/docs/?q=gltflo#examples/en/loaders/GLTFLoader) for more
+     * information.
+     * @param {Function} callback - the callback function
+     */
+    register(callback: Function): void;
+    /**
+     * Unregisters a load callback.
+     * See Threejs [GltfLoader](https://threejs.org/docs/?q=gltflo#examples/en/loaders/GLTFLoader) for more
+     * information.
+     * @param {Function} callback - the callback function
+     */
+    unregister(callback: Function): void;
+    /** Parse a glTF-based ArrayBuffer, JSON string or object and fire onLoad callback when complete.
+     * Calls Threejs [GLTFLoader.parse](https://threejs.org/docs/?q=gltflo#examples/en/loaders/GLTFLoader.parse) for
+     * glTF 2.0 files and LegacyGLTFLoader.parse for gtTF 1.0 files.
+     * @param {ArrayBuffer|String|Object} buffer - the glTF asset to parse, as an ArrayBuffer, JSON string or object.
+     * @param {String} path - the base path from which to find subsequent glTF resources such as textures and .bin data files.
+     * @param {Function} onLoad — A function to be called when parse completes. The argument to the onLoad function will
+     * be an Object that contains loaded parts: .scene, .scenes, .cameras, .animations, and .asset.
+     * @param {Function} [onError] — A function to be called if an error occurs during parsing. The function receives error as an argument.
+     */
+    parse(buffer: ArrayBuffer | string | Object, path: string, onLoad: Function, onError?: Function): void;
+    /**
+     * Async promise-based parsing of a glTF-based ArrayBuffer, JSON string or object.
+     * @param {ArrayBuffer|String|Object} data - the glTF asset to parse, as an ArrayBuffer, JSON string or object.
+     * @param {String} path - the base path from which to find subsequent glTF resources such as textures and .bin data files.
+     * @returns {Promise<Object>} A promise that resolves an Object that contains loaded parts:
+     * .scene, .scenes, .cameras, .animations, and .asset, when parsing is done.
+     */
+    parseAsync(data: ArrayBuffer | string | Object, path: string): Promise<Object>;
+}
+import * as THREE from 'three';
+import { GLTFLoader } from '../ThreeExtended/loaders/GLTFLoader';

package/lib/Process/3dTilesProcessing.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Check if the node is visible in the camera.
+ *
+ * @param      {C3DTilesLayer} layer       node 3D tiles layer
+ * @param      {Camera}   camera           camera
+ * @param      {THREE.Object3D}   node             The 3d tile node to check.
+ * @param      {THREE.Matrix4}   tileMatrixWorld  The node matrix world
+ * @return     {boolean}  return true if the node is visible
+ */
+export function $3dTilesCulling(layer: C3DTilesLayer, camera: Camera, node: THREE.Object3D, tileMatrixWorld: THREE.Matrix4): boolean;
+export function pre3dTilesUpdate(context: any): any[];
+export class pre3dTilesUpdate {
+    constructor(context: any);
+    scale: any;
+}
+export function computeNodeSSE(camera: any, node: any): number;
+export function init3dTilesLayer(view: any, scheduler: any, layer: any, rootTile: any): any;
+/**
+ * This funcion builds the method to update 3d tiles node.
+ *
+ * The returned method checks the 3d tile visibility with `cullingTest` function.
+ * It subdivises visible node if `subdivisionTest` return `true`.
+ *
+ * @param      {Function}  [cullingTest=$3dTilesCulling]                 The culling test method.
+ * @param      {Function}  [subdivisionTest=$3dTilesSubdivisionControl]  The subdivision test method.
+ * @return     {Function}    { description_of_the_return_value }
+ */
+export function process3dTilesNode(cullingTest?: Function, subdivisionTest?: Function): Function;
+/**
+ *
+ *
+ * the method returns true if the `node` should be subivised.
+ *
+ * @param      {object}   context  The current context
+ * @param      {Camera}   context.camera  The current camera
+ * @param      {C3DTilesLayer}   layer  The 3d tile layer
+ * @param      {THREE.Object3D}  node  The 3d tile node
+ * @return     {boolean}
+ */
+export function $3dTilesSubdivisionControl(context: {
+    camera: Camera;
+}, layer: C3DTilesLayer, node: THREE.Object3D): boolean;
+import * as THREE from 'three';