itowns 2.45.1 → 2.45.2-next.0

package/lib/Layer/LabelLayer.d.ts

@@ -0,0 +1,93 @@
+export default LabelLayer;
+/**
+ * A layer to handle a bunch of `Label`. This layer can be created on its own,
+ * but it is better to use the option `addLabelLayer` on another `Layer` to let
+ * it work with it (see the `vector_tile_raster_2d` example). Supported for Points features, not yet
+ * for Lines and Polygons features.
+ *
+ * @property {boolean} isLabelLayer - Used to checkout whether this layer is a
+ * LabelLayer.  Default is true. You should not change this, as it is used
+ * internally for optimisation.
+ */
+declare class LabelLayer extends GeometryLayer {
+    /**
+     * @extends Layer
+     *
+     * @param {string} id - The id of the layer, that should be unique. It is
+     * not mandatory, but an error will be emitted if this layer is added a
+     * {@link View} that already has a layer going by that id.
+     * @param {Object} [config] - Optional configuration, all elements in it
+     * will be merged as is in the layer. For example, if the configuration
+     * contains three elements `name, protocol, extent`, these elements will be
+     * available using `layer.name` or something else depending on the property
+     * name.
+     * @param {boolean} [config.performance=true] - remove labels that have no chance of being visible.
+     * if the `config.performance` is set to true then the performance is improved
+     * proportional to the amount of unnecessary labels that are removed.
+     * Indeed, even in the best case, labels will never be displayed. By example, if there's many labels.
+     * We advise you to not use this option if your data is optimized.
+     * @param {domElement|function} config.domElement - An HTML domElement.
+     * If set, all `Label` displayed within the current instance `LabelLayer`
+     * will be this domElement.
+     *
+     * It can be set to a method. The single parameter of this method gives the
+     * properties of each feature on which a `Label` is created.
+     *
+     * If set, all the parameters set in the `LabelLayer` `Style.text` will be overridden,
+     * except for the `Style.text.anchor` parameter which can help place the label.
+     */
+    constructor(id: string, config?: {
+        performance?: boolean | undefined;
+        domElement: any;
+    });
+    isLabelLayer: boolean;
+    domElement: DomNode;
+    buildExtent: boolean;
+    performance: boolean;
+    forceClampToTerrain: any;
+    margin: any;
+    toHide: THREE.Group<THREE.Object3DEventMap>;
+    labelDomelement: any;
+    get submittedLabelNodes(): any;
+    /**
+     * Reads each {@link FeatureGeometry} that contains label configuration, and
+     * creates the corresponding {@link Label}. To create a `Label`, a geometry
+     * needs to have a `label` object with at least a few properties:
+     * - `content`, which refers to `Label#content`
+     * - `position`, which refers to `Label#position`
+     * - (optional) `config`, containing miscellaneous configuration for the
+     *   label
+     *
+     * The geometry (or its parent Feature) needs to have a Style set.
+     *
+     * @param {FeatureCollection} data - The FeatureCollection to read the
+     * labels from.
+     * @param {Extent|Tile} extentOrTile
+     *
+     * @return {Label[]} An array containing all the created labels.
+     */
+    convert(data: FeatureCollection, extentOrTile: Extent | Tile): Label[];
+    preUpdate(context: any, sources: any): void;
+    update(context: any, layer: any, node: any, parent: any): any;
+    removeLabelsFromNodeRecursive(node: any): void;
+    removeNodeDomElement(node: any): void;
+    #private;
+}
+import GeometryLayer from '../Layer/GeometryLayer';
+/**
+ * DomNode is a node in the tree data structure of labels divs.
+ *
+ * @class DomNode
+ */
+declare class DomNode {
+    dom: HTMLDivElement;
+    set visible(v: boolean);
+    get visible(): boolean;
+    hide(): void;
+    show(): void;
+    add(node: any): void;
+    #private;
+}
+import * as THREE from 'three';
+import { Extent } from '@itowns/geographic';
+import Label from '../Core/Label';

package/lib/Layer/LabelLayer.js

@@ -425,8 +425,8 @@ class LabelLayer extends GeometryLayer {
 
         // Necessary event listener, to remove any Label attached to
         node.addEventListener('removed', () => this.removeNodeDomElement(node));
-        if (labelsNode.needsAltitude && node.material.getElevationLayer()) {
-          node.material.getElevationLayer().addEventListener('rasterElevationLevelChanged', () => {
+        if (labelsNode.needsAltitude && node.material.getElevationTile()) {
+          node.material.getElevationTile().addEventListener('rasterElevationLevelChanged', () => {
             labelsNode.needsUpdate = true;
           });
         }

package/lib/Layer/Layer.d.ts

@@ -0,0 +1,185 @@
+export default Layer;
+export namespace ImageryLayers {
+    function moveLayerToIndex(layer: any, newIndex: any, imageryLayers: any): void;
+    function moveLayerDown(layer: any, imageryLayers: any): void;
+    function moveLayerUp(layer: any, imageryLayers: any): void;
+    function getColorLayersIdOrderedBySequence(imageryLayers: any): any[];
+}
+/**
+ * @property {boolean} isLayer - Used to checkout whether this layer is a Layer.
+ * Default is true. You should not change this, as it is used internally for
+ * optimisation.
+ * @property {boolean} ready - This property is false when the layer isn't added.
+ * It's true when the layer is added and all initializations are done.
+ * @property {Source} source - This source determines the datas to be displayed with the layer.
+ * The layer determines how this data are displayed.
+ * By example:
+ * * For ColorLayer/ElevationLayer, the source datas are rasterised (if it's necessary).
+ * * For GeometryLayer, the source datas are converted to meshes (not possible for the raster data sources).
+ * @property {Promise} whenReady - this promise is resolved when the layer is added and all initializations are done.
+ * This promise is resolved with this layer.
+ * This promise is returned by [View#addLayer]{@link View}.
+ * @property {object} [zoom] - This property is used only the layer is attached
+ * to {@link TiledGeometryLayer}.
+ * By example,
+ * The layer checks the tile zoom level to determine if the layer is visible in this tile.
+ *
+ * ![tiled geometry](/docs/static/images/wfszoommaxmin.jpeg)
+ * _In `GlobeView`, **red lines** represents the **WGS84 grid** and **orange lines** the Pseudo-mercator grid_
+ * _In this example [WFS to 3D objects](http://www.itowns-project.org/itowns/examples/index.html#source_stream_wfs_3d), the building layer zoom min is 14._
+ * _In the lower part of the picture, the zoom tiles 14 have buildings, while in the upper part of the picture, the level 13 tiles have no buildings._
+ *
+ * @property {number} [zoom.max=Infinity] - this is the maximum zoom beyond which it'll be hidden.
+ * @property {number} [zoom.min=0] - this is the minimum zoom from which it'll be visible.
+ *
+ */
+declare class Layer extends THREE.EventDispatcher<any> {
+    /**
+     * Don't use directly constructor to instance a new Layer. Instead, use
+     * another available type of Layer, implement a new one inheriting from this
+     * one or use [View#addLayer]{@link View}.
+     *
+     * @protected
+     *
+     * @param {string} id - The id of the layer, that should be unique. It is
+     * not mandatory, but an error will be emitted if this layer is added a
+     * {@link View} that already has a layer going by that id.
+     * @param {Object} config - configuration, all elements in it
+     * will be merged as is in the layer. For example, if the configuration
+     * contains three elements `name, extent`, these elements will be
+     * available using `layer.name` or something else depending on the property
+     * name.
+     * @param {Source|boolean} config.source - instantiated Source specifies data source to display.
+     * if config.source is a boolean, it can only be false. if config.source is false,
+     * the layer doesn't need Source (like debug Layer or procedural layer).
+     * @param {StyleOptions} [config.style] - an object that contain any properties
+     * (order, zoom, fill, stroke, point, text or/and icon)
+     * and sub properties of a Style (@see {@link StyleOptions}). Or directly a {@link Style} .<br/>
+     * When entering a StyleOptions the missing style properties will be look for in the data (if any)
+     * what won't be done when you use a Style.
+     * @param {number} [config.cacheLifeTime=Infinity] - set life time value in cache.
+     * This value is used for cache expiration mechanism.
+     * @param {(boolean|Object)} [config.addLabelLayer] - Used to tell if this layer has
+     * labels to display from its data. For example, it needs to be set to `true`
+     * for a layer with vector tiles. If it's `true` a new `LabelLayer` is added and attached to this `Layer`.
+     * You can also configure it with {@link LabelLayer} options described below such as: `addLabelLayer: { performance: true }`.
+     * @param {boolean} [config.addLabelLayer.performance=false] - In case label layer adding, so remove labels that have no chance of being visible.
+     * Indeed, even in the best case, labels will never be displayed. By example, if there's many labels.
+     * @param {boolean} [config.addLabelLayer.forceClampToTerrain=false] - use elevation layer to clamp label on terrain.
+     * @param {number} [config.subdivisionThreshold=256] - set the texture size and, if applied to the globe, affects the tile subdivision.
+     *
+     * @example
+     * // Add and create a new Layer
+     * const newLayer = new Layer('id', options);
+     * view.addLayer(newLayer);
+     *
+     * // Change layer's visibility
+     * const layerToChange = view.getLayerById('idLayerToChange');
+     * layerToChange.visible = false;
+     * view.notifyChange(); // update viewer
+     *
+     * // Change layer's opacity
+     * const layerToChange = view.getLayerById('idLayerToChange');
+     * layerToChange.opacity = 0.5;
+     * view.notifyChange(); // update viewer
+     *
+     * // Listen properties
+     * const layerToListen = view.getLayerById('idLayerToListen');
+     * layerToListen.addEventListener('visible-property-changed', (event) => console.log(event));
+     * layerToListen.addEventListener('opacity-property-changed', (event) => console.log(event));
+     */
+    protected constructor();
+    /**
+     * @type {boolean}
+     * @readonly
+     */
+    readonly isLayer: boolean;
+    /**
+     * @type {string}
+     * @readonly
+     */
+    readonly id: string;
+    /**
+     * @type {string}
+     */
+    name: string;
+    /**
+     * @type {Source}
+     */
+    source: Source;
+    crs: any;
+    style: any;
+    /**
+     * @type {number}
+     */
+    subdivisionThreshold: number;
+    sizeDiagonalTexture: number;
+    addLabelLayer: boolean | Object;
+    options: any;
+    updateStrategy: any;
+    zoom: {
+        min: any;
+        max: any;
+    };
+    info: InfoLayer;
+    /**
+     * @type {boolean}
+     */
+    ready: boolean;
+    /**
+     * @type {Array<Promise<any>>}
+     * @protected
+     */
+    protected _promises: Array<Promise<any>>;
+    /**
+     * @type {Promise<this>}
+     */
+    whenReady: Promise<this>;
+    _resolve: (value: any) => void;
+    _reject: (reason?: any) => void;
+    /**
+     * @type {Cache}
+     */
+    cache: Cache;
+    mergeFeatures: any;
+    addInitializationStep(): undefined;
+    /**
+     * Defines a property for this layer, with a default value and a callback
+     * executed when the property changes.
+     * <br><br>
+     * When changing the property, it also emits an event, named following this
+     * convention: `${propertyName}-property-changed`, with `${propertyName}`
+     * being replaced by the name of the property.  For example, if the added
+     * property name is `frozen`, it will emit a `frozen-property-changed`.
+     * <br><br>
+     * @example <caption>The emitted event has some properties assigned to it</caption>
+     * event = {
+     *     new: {
+     *         ${propertyName}: * // the new value of the property
+     *     },
+     *     previous: {
+     *         ${propertyName}: * // the previous value of the property
+     *     },
+     *     target: Layer // the layer it has been dispatched from
+     *     type: string // the name of the emitted event
+     * }
+     *
+     * @param {string} propertyName - The name of the property, also used in
+     * the emitted event name.
+     * @param {*} defaultValue - The default set value.
+     * @param {function} [onChange] - The function executed when the property is
+     * changed. Parameters are the layer the property is defined on, and the
+     * name of the property.
+     */
+    defineLayerProperty(propertyName: string, defaultValue: any, onChange?: Function): void;
+    convert(data: any): any;
+    getData(from: any, to: any): any;
+    /**
+     * Remove and dispose all objects from layer.
+     * @param {boolean} [clearCache=false] Whether to clear the layer cache or not
+     */
+    delete(clearCache?: boolean): void;
+}
+import * as THREE from 'three';
+import Source from '../Source/Source';
+import InfoLayer from '../Layer/InfoLayer';

package/lib/Layer/LayerUpdateState.d.ts

@@ -0,0 +1,24 @@
+export default LayerUpdateState;
+/**
+ * LayerUpdateState is the update state of a layer, for a given object (e.g tile).
+ * It stores information to allow smart update decisions, and especially network
+ * error handling.
+ * @constructor
+ */
+declare class LayerUpdateState {
+    state: number;
+    lastErrorTimestamp: number;
+    errorCount: number;
+    failureParams: {
+        lowestLevelError: number;
+    };
+    hasFinished(): boolean;
+    canTryUpdate(timestamp?: number): boolean;
+    secondsUntilNextTry(): number;
+    newTry(): void;
+    success(): void;
+    noMoreUpdatePossible(): void;
+    noData(failureParams: any): void;
+    failure(timestamp: any, definitive: any, failureParams: any): void;
+    inError(): boolean;
+}

package/lib/Layer/LayerUpdateStrategy.d.ts

@@ -0,0 +1,11 @@
+export function chooseNextLevelToFetch(strategy: any, node: any, nodeLevel: any, currentLevel: any, layer: any, failureParams: any): any;
+/**
+ * This modules implements various layer update strategies.
+ *
+ * Default strategy is STRATEGY_MIN_NETWORK_TRAFFIC which aims
+ * to reduce the amount of network traffic.
+ */
+export const STRATEGY_MIN_NETWORK_TRAFFIC: 0;
+export const STRATEGY_GROUP: 1;
+export const STRATEGY_PROGRESSIVE: 2;
+export const STRATEGY_DICHOTOMY: 3;

package/lib/Layer/LayerUpdateStrategy.js

@@ -10,12 +10,7 @@ export const STRATEGY_MIN_NETWORK_TRAFFIC = 0;
 export const STRATEGY_GROUP = 1;
 export const STRATEGY_PROGRESSIVE = 2;
 export const STRATEGY_DICHOTOMY = 3;
-function _minimizeNetworkTraffic(node, nodeLevel, currentLevel, source) {
-  // TO DO source.isVectorTileSource is a temp fix for pendingSubdivision.
-  // see issue https://github.com/iTowns/itowns/issues/2214
-  if (node.pendingSubdivision && !source.isVectorTileSource) {
-    return currentLevel;
-  }
+function _minimizeNetworkTraffic(nodeLevel) {
   return nodeLevel;
 }
 
@@ -72,7 +67,7 @@ export function chooseNextLevelToFetch(strategy, node) {
       // default strategy
       case STRATEGY_MIN_NETWORK_TRAFFIC:
       default:
-        nextLevelToFetch = _minimizeNetworkTraffic(node, nodeLevel, currentLevel, layer.source);
+        nextLevelToFetch = _minimizeNetworkTraffic(nodeLevel);
     }
     nextLevelToFetch = Math.min(nextLevelToFetch, maxZoom);
   }

package/lib/Layer/OGC3DTilesLayer.d.ts

@@ -0,0 +1,277 @@
+/**
+ * Enable loading 3D Tiles with [Draco](https://google.github.io/draco/) geometry extension.
+ *
+ * @param {String} path path to draco library folder containing the JS and WASM decoder libraries. They can be found in
+ * [itowns examples](https://github.com/iTowns/itowns/tree/master/examples/libs/draco).
+ * @param {Object} [config] optional configuration for Draco decoder (see threejs'
+ * [setDecoderConfig](https://threejs.org/docs/index.html?q=draco#examples/en/loaders/DRACOLoader.setDecoderConfig) that
+ * is called under the hood with this configuration for details.
+ */
+export function enableDracoLoader(path: string, config?: Object): void;
+/**
+ * Enable loading 3D Tiles with [KTX2](https://www.khronos.org/ktx/) texture extension.
+ *
+ * @param {String} path path to ktx2 library folder containing the JS and WASM decoder libraries. They can be found in
+ * [itowns examples](https://github.com/iTowns/itowns/tree/master/examples/libs/basis).
+ * @param {THREE.WebGLRenderer} renderer the threejs renderer
+ */
+export function enableKtx2Loader(path: string, renderer: THREE.WebGLRenderer): void;
+/**
+ * Enable loading 3D Tiles and GLTF with
+ * [meshopt](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/EXT_meshopt_compression/README.md) compression extension.
+ *
+ * @param {MeshOptDecoder.constructor} MeshOptDecoder - The Meshopt decoder
+ * module.
+ *
+ * @example
+ * import * as itowns from 'itowns';
+ * import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js';
+ *
+ * // Enable support of EXT_meshopt_compression
+ * itowns.enableMeshoptDecoder(MeshoptDecoder);
+ */
+export function enableMeshoptDecoder(MeshOptDecoder: MeshOptDecoder.constructor): void;
+export const itownsGLTFLoader: iGLTFLoader;
+export namespace OGC3DTILES_LAYER_EVENTS {
+    let LOAD_TILE_SET: Object;
+    let LOAD_MODEL: Object;
+    let DISPOSE_MODEL: Object;
+    let TILE_VISIBILITY_CHANGE: Object;
+    let TILES_LOAD_START: string;
+    let TILES_LOAD_END: string;
+}
+export default OGC3DTilesLayer;
+import * as THREE from 'three';
+import iGLTFLoader from '../Parser/iGLTFLoader';
+declare class OGC3DTilesLayer extends GeometryLayer {
+    /**
+     * Layer for [3D Tiles](https://www.ogc.org/standard/3dtiles/) datasets.
+     *
+     * Advanced configuration note: 3D Tiles rendering is delegated to 3DTilesRendererJS that exposes several
+     * configuration options accessible through the tilesRenderer property of this class. see the
+     * [3DTilesRendererJS doc](https://github.com/NASA-AMMOS/3DTilesRendererJS/blob/master/README.md). Also note that
+     * the cache is shared amongst 3D tiles layers and can be configured through tilesRenderer.lruCache (see the
+     * [following documentation](https://github.com/NASA-AMMOS/3DTilesRendererJS/blob/master/README.md#lrucache-1).
+     *
+     * @extends Layer
+     *
+     * @param {String} id - unique layer id.
+     * @param {Object} config - layer specific configuration
+     * @param {OGC3DTilesSource} config.source - data source configuration
+     * @param {String} [config.pntsMode = PNTS_MODE.COLOR] Point cloud coloring mode (passed to {@link PointsMaterial}).
+     *      Only 'COLOR' or 'CLASSIFICATION' are possible. COLOR uses RGB colors of the points,
+     *      CLASSIFICATION uses a classification property of the batch table to color points.
+     * @param {ClassificationScheme}  [config.classificationScheme = ClassificationScheme.DEFAULT]  {@link PointsMaterial} classification scheme
+     * @param {String} [config.pntsShape = PNTS_SHAPE.CIRCLE] Point cloud point shape. Only 'CIRCLE' or 'SQUARE' are possible.
+     * (passed to {@link PointsMaterial}).
+     * @param {String} [config.pntsSizeMode = PNTS_SIZE_MODE.VALUE] {@link PointsMaterial} Point cloud size mode (passed to {@link PointsMaterial}).
+     * Only 'VALUE' or 'ATTENUATED' are possible. VALUE use constant size, ATTENUATED compute size depending on distance
+     * from point to camera.
+     * @param {Number} [config.pntsMinAttenuatedSize = 3] Minimum scale used by 'ATTENUATED' size mode.
+     * @param {Number} [config.pntsMaxAttenuatedSize = 10] Maximum scale used by 'ATTENUATED' size mode.
+     */
+    constructor(id: string, config: {
+        source: OGC3DTilesSource;
+        pntsMode?: string | undefined;
+        classificationScheme?: {
+            DEFAULT: {
+                0: {
+                    visible: boolean;
+                    name: string;
+                    color: THREE.Color;
+                    opacity: number;
+                };
+                1: {
+                    visible: boolean;
+                    name: string;
+                    color: THREE.Color;
+                    opacity: number;
+                };
+                2: {
+                    visible: boolean;
+                    name: string;
+                    color: THREE.Color;
+                    opacity: number;
+                };
+                3: {
+                    visible: boolean;
+                    name: string;
+                    color: THREE.Color;
+                    opacity: number;
+                };
+                4: {
+                    visible: boolean;
+                    name: string;
+                    color: THREE.Color;
+                    opacity: number;
+                };
+                5: {
+                    visible: boolean;
+                    name: string;
+                    color: THREE.Color;
+                    opacity: number;
+                };
+                6: {
+                    visible: boolean;
+                    name: string;
+                    color: THREE.Color;
+                    opacity: number;
+                };
+                7: {
+                    visible: boolean;
+                    name: string;
+                    color: THREE.Color;
+                    opacity: number;
+                };
+                8: {
+                    visible: boolean;
+                    name: string;
+                    color: THREE.Color;
+                    opacity: number;
+                };
+                9: {
+                    visible: boolean;
+                    name: string;
+                    color: THREE.Color;
+                    opacity: number;
+                };
+                10: {
+                    visible: boolean;
+                    name: string;
+                    color: THREE.Color;
+                    opacity: number;
+                };
+                11: {
+                    visible: boolean;
+                    name: string;
+                    color: THREE.Color;
+                    opacity: number;
+                };
+                12: {
+                    visible: boolean;
+                    name: string;
+                    color: THREE.Color;
+                    opacity: number;
+                };
+                DEFAULT: {
+                    visible: boolean;
+                    name: string;
+                    color: THREE.Color;
+                    opacity: number;
+                };
+            };
+        } | undefined;
+        pntsShape?: string | undefined;
+        pntsSizeMode?: string | undefined;
+        pntsMinAttenuatedSize?: number | undefined;
+        pntsMaxAttenuatedSize?: number | undefined;
+    });
+    isOGC3DTilesLayer: boolean;
+    pntsMode: string | number;
+    pntsShape: string | number;
+    classification: any;
+    pntsSizeMode: string | number;
+    pntsMinAttenuatedSize: number;
+    pntsMaxAttenuatedSize: number;
+    /** @type{any} */
+    tilesRenderer: any;
+    _res: any;
+    /**
+     * @type {number}
+     */
+    sseThreshold: number;
+    tasks: any[];
+    tilesSchedulingCB: (func: any) => void;
+    /**
+     * Sets the lruCache and download and parse queues so they are shared amongst
+     * all tilesets from a same {@link View} view.
+     * @param {View} view - view associated to this layer.
+     * @private
+     */
+    private _setupCacheAndQueues;
+    /**
+     * Binds 3d-tiles-renderer events to this layer.
+     * @private
+     */
+    private _setupEvents;
+    /**
+     * Setup 3D tiles renderer js TilesRenderer with the camera, binds events and start updating. Executed when the
+     * layer has been added to the view.
+     * @param {View} view - the view the layer has been added to.
+     * @private
+     */
+    private _setup;
+    /**
+     * Replace materials from GLTFLoader by our own custom materials. Note that
+     * the replaced materials are not compiled yet and will be disposed by the
+     * GC.
+     * @param {Object3D} model
+     * @private
+     */
+    private _assignFinalMaterial;
+    /**
+     * @param {Object3D} model
+     * @private
+     */
+    private _assignFinalAttributes;
+    handleTasks(): void;
+    preUpdate(context: any): null;
+    scale: any;
+    update(): void;
+    /**
+     * Deletes the layer and frees associated memory
+     */
+    delete(): void;
+    /**
+     * Get the [metadata](https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata)
+     * of the closest intersected object from a list of intersections.
+     *
+     * This method retrieves structured metadata stored in GLTF 2.0 assets using
+     * the [`EXT_structural_metadata`](https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata)
+     * extension.
+     *
+     * Internally, it uses the closest intersected point to index metadata
+     * stored in property attributes and textures.
+     *
+     * If present in GLTF 2.0 assets, this method leverages the
+     * [`EXT_mesh_features`](`https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_mesh_features)
+     * extension and the returned featured to index metadata stored in property tables.
+     *
+     * @param {Array<THREE.Intersection>} intersections
+     * @returns {Promise<Object | null>} - the intersected object's metadata
+     */
+    getMetadataFromIntersections(intersections: Array<THREE.Intersection>): Promise<Object | null>;
+    /**
+     * Get the attributes for the closest intersection from a list of
+     * intersects.
+     * @param {Array<THREE.Intersection>} intersects -  An array containing all
+     * objects picked under mouse coordinates computed with view.pickObjectsAt(..).
+     * @returns {Object | null} - An object containing
+     */
+    getC3DTileFeatureFromIntersectsArray(intersects: Array<THREE.Intersection>): Object | null;
+    /**
+     * Get all 3D objects (mesh and points primitives) as intersects at the
+     * given non-normalized screen coordinates.
+     * @param {View} view - The view instance.
+     * @param {THREE.Vector2} coords - The coordinates to pick in the view. It
+     * should have at least `x` and `y` properties.
+     * @param {number} radius - Radius of the picking circle.
+     * @param {Array} [target=[]] - Target array to push results too
+     * @returns {Array} Array containing all target objects picked under the
+     * specified coordinates.
+     */
+    pickObjectsAt(view: View, coords: THREE.Vector2, radius: number, target?: any[]): any[];
+    attach(layer: any): void;
+    detach(layer: any): boolean;
+    getObjectToUpdateForAttachedLayers(obj: any): null;
+    /**
+     * Executes a callback for each tile of this layer tileset.
+     *
+     * @param {Function} callback The callback to execute for each tile. Has the following two parameters:
+     *  1. tile (Object) - the JSON tile
+     *  2. scene (THREE.Object3D | null) - The tile content. Contains a `batchTable` property. Can be null if the tile
+     *  has not yet been loaded.
+    */
+    forEachTile(callback: Function): void;
+}
+import GeometryLayer from '../Layer/GeometryLayer';

package/lib/Layer/OGC3DTilesLayer.js

@@ -253,6 +253,8 @@ class OGC3DTilesLayer extends GeometryLayer {
     this.pntsSizeMode = pntsSizeMode;
     this.pntsMinAttenuatedSize = pntsMinAttenuatedSize;
     this.pntsMaxAttenuatedSize = pntsMaxAttenuatedSize;
+
+    /** @type{any} */
     this.tilesRenderer = new TilesRenderer(this.source.url);
     if (config.source.isOGC3DTilesIonSource) {
       this.tilesRenderer.registerPlugin(new CesiumIonAuthPlugin({
@@ -289,6 +291,16 @@ class OGC3DTilesLayer extends GeometryLayer {
     if (config.sseThreshold) {
       this.sseThreshold = config.sseThreshold;
     }
+    // Used for custom schedule callbacks (VR)
+    this.tasks = [];
+    this.tilesSchedulingCB = func => {
+      this.tasks.push(func);
+    };
+    // We set our scheduling callback for tiles downloading and parsing -> MANDATORY for VR
+    // (WebXR session has its own requestAnimationFrame method separate from that of the window
+    //  https://github.com/NASA-AMMOS/3DTilesRendererJS/issues/213#issuecomment-947943386)
+    this.tilesRenderer.downloadQueue.schedulingCallback = this.tilesSchedulingCB;
+    this.tilesRenderer.parseQueue.schedulingCallback = this.tilesSchedulingCB;
   }
 
   /**
@@ -382,8 +394,10 @@ class OGC3DTilesLayer extends GeometryLayer {
       });
       pointsMaterial.copy(material);
       material = pointsMaterial;
+      material.depthWrite = false;
     }
     if (material) {
+      material.transparent = true;
       ReferLayerProperties(material, this);
     }
     model.material = material;
@@ -405,8 +419,15 @@ class OGC3DTilesLayer extends GeometryLayer {
       }
     }
   }
+  handleTasks() {
+    for (let t = 0, l = this.tasks.length; t < l; t++) {
+      this.tasks[t]();
+    }
+    this.tasks.length = 0;
+  }
   preUpdate(context) {
     this.scale = context.camera._preSSE;
+    this.handleTasks();
     this.tilesRenderer.update();
     return null; // don't return any element because 3d-tiles-renderer already updates them
   }