itowns 2.45.1 → 2.45.2-next.0

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';

package/lib/Process/FeatureProcessing.d.ts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function update(context: any, layer: any, node: any): any;
+}
+export default _default;

package/lib/Process/LayeredMaterialNodeProcessing.d.ts

@@ -0,0 +1,3 @@
+export function updateLayeredMaterialNodeImagery(context: any, layer: any, node: any, parent: any): any;
+export function updateLayeredMaterialNodeElevation(context: any, layer: any, node: any, parent: any): any;
+export function removeLayeredMaterialNodeTile(tileId: any): (node: TileMesh) => void;

package/lib/Process/LayeredMaterialNodeProcessing.js

@@ -15,7 +15,7 @@ function refinementCommandCancellationFn(cmd) {
   // Cancel the command if the tile already has a better texture.
   // This is only needed for elevation layers, because we may have several
   // concurrent layers but we can only use one texture.
-  if (cmd.layer.isElevationLayer && cmd.requester.material.getElevationLayer() && cmd.targetLevel <= cmd.requester.material.getElevationLayer().level) {
+  if (cmd.layer.isElevationLayer && cmd.requester.material.getElevationTile() && cmd.targetLevel <= cmd.requester.material.getElevationTile().level) {
     return true;
   }
 
@@ -50,7 +50,7 @@ export function updateLayeredMaterialNodeImagery(context, layer, node, parent) {
   if (zoom > layer.zoom.max || zoom < layer.zoom.min) {
     return;
   }
-  let nodeLayer = material.getLayer(layer.id);
+  let nodeLayer = material.getTile(layer.id);
 
   // Initialisation
   if (node.layerUpdateState[layer.id] === undefined) {
@@ -59,7 +59,7 @@ export function updateLayeredMaterialNodeImagery(context, layer, node, parent) {
       // we also need to check that tile's parent doesn't have a texture for this layer,
       // because even if this tile is outside of the layer, it could inherit it's
       // parent texture
-      if (!(!layer.noTextureParentOutsideLimit && parent.material && parent.material.getLayer && parent.material.getLayer(layer.id))) {
+      if (!(!layer.noTextureParentOutsideLimit && parent.material && parent.material.getTile && parent.material.getTile(layer.id))) {
         node.layerUpdateState[layer.id].noMoreUpdatePossible();
         return;
       } // ok, we're going to inherit our parent's texture
@@ -69,7 +69,7 @@ export function updateLayeredMaterialNodeImagery(context, layer, node, parent) {
       nodeLayer = layer.setupRasterNode(node);
 
       // Init the node by parent
-      const parentLayer = parent.material?.getLayer(layer.id);
+      const parentLayer = parent.material?.getTile(layer.id);
       nodeLayer.initFromParent(parentLayer, extentsDestination);
     }
 
@@ -157,13 +157,13 @@ export function updateLayeredMaterialNodeElevation(context, layer, node, parent)
     return;
   }
   // Init elevation layer, and inherit from parent if possible
-  let nodeLayer = material.getElevationLayer();
+  let nodeLayer = material.getElevationTile();
   if (!nodeLayer) {
     nodeLayer = layer.setupRasterNode(node);
   }
   if (node.layerUpdateState[layer.id] === undefined) {
     node.layerUpdateState[layer.id] = new LayerUpdateState();
-    const parentLayer = parent.material?.getLayer(layer.id);
+    const parentLayer = parent.material?.getTile(layer.id);
     nodeLayer.initFromParent(parentLayer, extentsDestination);
     if (nodeLayer.level >= layer.source.zoom.min) {
       context.view.notifyChange(node, false);
@@ -208,22 +208,22 @@ export function updateLayeredMaterialNodeElevation(context, layer, node, parent)
     node.layerUpdateState[layer.id].success();
   }, err => handlingError(err, node, layer, targetLevel, context.view));
 }
-export function removeLayeredMaterialNodeLayer(layerId) {
+export function removeLayeredMaterialNodeTile(tileId) {
   /**
    * @param {TileMesh} node - The node to udpate.
    */
   return function (node) {
-    if (node.material?.removeLayer) {
-      if (node.material.elevationLayerIds.indexOf(layerId) > -1) {
+    if (node.material?.removeTile) {
+      if (node.material.elevationTile !== undefined) {
         node.setBBoxZ({
           min: 0,
           max: 0
         });
       }
-      node.material.removeLayer(layerId);
+      node.material.removeTile(tileId);
     }
-    if (node.layerUpdateState && node.layerUpdateState[layerId]) {
-      delete node.layerUpdateState[layerId];
+    if (node.layerUpdateState && node.layerUpdateState[tileId]) {
+      delete node.layerUpdateState[tileId];
     }
   };
 }