itowns 2.45.1 → 2.45.2-next.1

package/lib/Layer/OrientedImageLayer.d.ts

@@ -0,0 +1,53 @@
+export default OrientedImageLayer;
+/**
+ * OrientedImageLayer loads oriented images, and project these textures on the scene.
+ * It is design to create an immersive view. </br>
+ * It loads a set of panoramic position and orientation,
+ * a set of camera calibration file (it's the same set of camera for each panoramic),
+ * and a set of texture (each image for each camera for each panoramic), all organised in an {@link OrientedImageSource}. </br>
+ * It creates an {@link OrientedImageMaterial} used to do projective texture mapping on the scene.
+ * @extends GeometryLayer
+ */
+declare class OrientedImageLayer extends GeometryLayer {
+    /**
+     * @param { string } id - The id of the layer, a unique name.
+     * @param { Object } config - configuration of the layer
+     * @param { number } config.backgroundDistance - Radius in meter of the sphere used as a background
+     * @param { function } config.onPanoChanged - callback fired when current panoramic changes
+     * @param { string } config.crs - crs projection of the view
+     * @param { string } config.orientation - Json object, using GeoJSon format to represent points,
+     * it's a set of panoramic position and orientation.
+     * @param { string } config.calibrations - Json object, representing a set of camera.
+     * see {@link CameraCalibrationParser}
+     * @param { OrientedImageSource } config.source - Source used to build url of texture for each oriented image,
+     * a tecture is need for each camera, for each panoramic.
+     */
+    constructor(id: string, config?: {
+        backgroundDistance: number;
+        onPanoChanged: Function;
+        crs: string;
+        orientation: string;
+        calibrations: string;
+        source: OrientedImageSource;
+    });
+    isOrientedImageLayer: boolean;
+    background: any;
+    currentPano: any;
+    onPanoChanged: Function;
+    getCamerasNameFromFeature: any;
+    mergeFeatures: boolean;
+    accurate: boolean;
+    panos: any;
+    cameras: any;
+    material: OrientedImageMaterial;
+    update(): void;
+    set boostLight(value: any);
+    get boostLight(): any;
+    preUpdate(context: any): void;
+    getNextPano(): any;
+    getCurrentPano(): any;
+    getPreviousPano(): any;
+    mostNearPano(position: any): any;
+}
+import GeometryLayer from '../Layer/GeometryLayer';
+import OrientedImageMaterial from '../Renderer/OrientedImageMaterial';

package/lib/Layer/PointCloudLayer.d.ts

@@ -0,0 +1,103 @@
+export default PointCloudLayer;
+/**
+ * The basis for all point clouds related layers.
+ *
+ * @property {boolean} isPointCloudLayer - Used to checkout whether this layer
+ * is a PointCloudLayer. Default is `true`. You should not change this, as it is
+ * used internally for optimisation.
+ * @property {THREE.Group|THREE.Object3D} group - Contains the created
+ * `THREE.Points` meshes, usually with an instance of a `THREE.Points` per node.
+ * @property {THREE.Group|THREE.Object3D} bboxes - Contains the bounding boxes
+ * (`THREE.Box3`) of the tree, usually one per node.
+ * @property {number} octreeDepthLimit - The depth limit at which to stop
+ * browsing the octree. Can be used to limit the browsing, without having to
+ * edit manually the source of the point cloud. No limit by default (`-1`).
+ * @property {number} [pointBudget=2000000] - Maximum number of points to
+ * display at the same time. This influences the performance of rendering.
+ * Default to two millions points.
+ * @property {number} [sseThreshold=2] - Threshold of the **S**creen **S**pace
+ * **E**rror. Default to `2`.
+ * @property {number} [pointSize=4] - The size (in pixels) of the points.
+ * Default to `4`.
+ * @property {THREE.Material|PointsMaterial} [material=new PointsMaterial] - The
+ * material to use to display the points of the cloud. Be default it is a new
+ * `PointsMaterial`.
+ * @property {number} [mode=PNTS_MODE.COLOR] - The displaying mode of the points.
+ * Values are specified in `PointsMaterial`.
+ * @property {number} [minIntensityRange=0] - The minimal intensity of the
+ * layer. Changing this value will affect the material, if it has the
+ * corresponding uniform. The value is normalized between 0 and 1.
+ * @property {number} [maxIntensityRange=1] - The maximal intensity of the
+ * layer. Changing this value will affect the material, if it has the
+ * corresponding uniform. The value is normalized between 0 and 1.
+ *
+ * @extends GeometryLayer
+ */
+declare class PointCloudLayer extends GeometryLayer {
+    /**
+     * Constructs a new instance of point cloud layer.
+     * Constructs a new instance of a Point Cloud Layer. This should not be used
+     * directly, but rather implemented using `extends`.
+     *
+     * @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. See the list of properties to know which one can be specified.
+     * @param {Source} config.source - Description and options of the source See @Layer.
+     * @param {number}  [options.minElevationRange] - Min value for the elevation range (default value will be taken from the source.metadata).
+     * @param {number}  [options.maxElevationRange] - Max value for the elevation range (default value will be taken from the source.metadata).
+     */
+    constructor(id: string, config?: {
+        source: Source;
+    });
+    /**
+     * @type {boolean}
+     * @readonly
+     */
+    readonly isPointCloudLayer: boolean;
+    protocol: string;
+    group: any;
+    bboxes: any;
+    /**
+     * @type {number}
+     */
+    octreeDepthLimit: number;
+    /**
+     * @type {number}
+     */
+    pointBudget: number;
+    /**
+     * @type {number}
+     */
+    pointSize: number;
+    /**
+     * @type {number}
+     */
+    sseThreshold: number;
+    /**
+     * @type {THREE.Material}
+     */
+    material: THREE.Material;
+    mode: any;
+    /**
+     * @type {PointCloudNode | undefined}
+     */
+    root: PointCloudNode | undefined;
+    preUpdate(context: any, changeSources: any): any[];
+    update(context: any, layer: any, elt: any): any;
+    displayedCount: number | undefined;
+    pickObjectsAt(view: any, mouse: any, radius: any, target?: any[]): any[] | undefined;
+    getObjectToUpdateForAttachedLayers(meta: any): {
+        element: any;
+        parent: any;
+    } | {
+        element: any;
+        parent?: undefined;
+    } | undefined;
+}
+import GeometryLayer from '../Layer/GeometryLayer';
+import * as THREE from 'three';

package/lib/Layer/PointCloudLayer.js

@@ -26,11 +26,10 @@ function initBoundingBox(elt, layer) {
   elt.obj.boxHelper.updateMatrix();
   elt.obj.boxHelper.updateMatrixWorld();
 }
-function computeSSEPerspective(context, pointSize, spacing, elt, distance) {
+function computeSSEPerspective(context, pointSize, pointSpacing, distance) {
   if (distance <= 0) {
     return Infinity;
   }
-  const pointSpacing = spacing / 2 ** elt.depth;
   // Estimate the onscreen distance between 2 points
   const onScreenSpacing = context.camera.preSSE * pointSpacing / distance;
   // [  P1  ]--------------[   P2   ]
@@ -39,9 +38,7 @@ function computeSSEPerspective(context, pointSize, spacing, elt, distance) {
   // <------>                         = pointSize (in pixels)
   return Math.max(0.0, onScreenSpacing - pointSize);
 }
-function computeSSEOrthographic(context, pointSize, spacing, elt) {
-  const pointSpacing = spacing / 2 ** elt.depth;
-
+function computeSSEOrthographic(context, pointSize, pointSpacing) {
   // Given an identity view matrix, project pointSpacing from world space to
   // clip space. v' = vVP = vP
   const v = new THREE.Vector4(pointSpacing);
@@ -53,11 +50,11 @@ function computeSSEOrthographic(context, pointSize, spacing, elt) {
   const distance = Math.sqrt(dx * dx + dy * dy);
   return Math.max(0.0, distance - pointSize);
 }
-function computeScreenSpaceError(context, pointSize, spacing, elt, distance) {
+function computeScreenSpaceError(context, pointSize, pointSpacing, distance) {
   if (context.camera.camera3D.isOrthographicCamera) {
-    return computeSSEOrthographic(context, pointSize, spacing, elt);
+    return computeSSEOrthographic(context, pointSize, pointSpacing);
   }
-  return computeSSEPerspective(context, pointSize, spacing, elt, distance);
+  return computeSSEPerspective(context, pointSize, pointSpacing, distance);
 }
 function markForDeletion(elt) {
   if (elt.obj) {
@@ -220,7 +217,7 @@ class PointCloudLayer extends GeometryLayer {
     if (this.material) {
       this.material.visible = this.visible;
       this.material.opacity = this.opacity;
-      this.material.transparent = this.opacity < 1 || this.material.userData.needTransparency[this.material.mode];
+      this.material.depthWrite = false;
       this.material.size = this.pointSize;
       this.material.scale = context.camera.preSSE;
       if (this.material.updateUniforms) {
@@ -284,7 +281,7 @@ class PointCloudLayer extends GeometryLayer {
       } else if (!elt.promise) {
         const distance = Math.max(0.001, bbox.distanceToPoint(point));
         // Increase priority of nearest node
-        const priority = computeScreenSpaceError(context, layer.pointSize, layer.spacing, elt, distance) / distance;
+        const priority = computeScreenSpaceError(context, layer.pointSize, elt.pointSpacing, distance) / distance;
         elt.promise = context.scheduler.execute({
           layer,
           requester: elt,
@@ -312,7 +309,7 @@ class PointCloudLayer extends GeometryLayer {
     }
     if (elt.children && elt.children.length) {
       const distance = bbox.distanceToPoint(point);
-      elt.sse = computeScreenSpaceError(context, layer.pointSize, layer.spacing, elt, distance) / this.sseThreshold;
+      elt.sse = computeScreenSpaceError(context, layer.pointSize, elt.pointSpacing, distance) / this.sseThreshold;
       if (elt.sse >= 1) {
         return elt.children;
       } else {

package/lib/Layer/Potree2Layer.d.ts

@@ -0,0 +1,56 @@
+export default Potree2Layer;
+/**
+ * @property {boolean} isPotreeLayer - Used to checkout whether this layer
+ * is a Potree2Layer. Default is `true`. You should not change this, as it is
+ * used internally for optimisation.
+ *
+ * @extends PointCloudLayer
+ */
+declare class Potree2Layer extends PointCloudLayer {
+    /**
+     * Constructs a new instance of Potree2 layer.
+     *
+     * @example
+     * // Create a new point cloud layer
+     * const points = new Potree2Layer('points',
+     *  {
+     *      source: new Potree2Source({
+     *          url: 'https://pointsClouds/',
+     *          file: 'metadata.json',
+     *      }
+     *  });
+     *
+     * View.prototype.addLayer.call(view, points);
+     *
+     * @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, protocol, extent`, these elements will be
+     * available using `layer.name` or something else depending on the property
+     * name. See the list of properties to know which one can be specified.
+     * @param {string} [config.crs=ESPG:4326] - The CRS of the {@link View} this
+     * layer will be attached to. This is used to determine the extent of this
+     * layer.  Default to `EPSG:4326`.
+     */
+    constructor(id: string, config: {
+        crs?: string | undefined;
+    });
+    /**
+     * @type {boolean}
+     * @readonly
+     */
+    readonly isPotreeLayer: boolean;
+    scale: THREE.Vector3;
+    metadata: any;
+    pointAttributes: Potree2PointAttributes;
+    spacing: any;
+    minElevationRange: any;
+    maxElevationRange: any;
+    extent: Extent;
+}
+import PointCloudLayer from '../Layer/PointCloudLayer';
+import * as THREE from 'three';
+import { Potree2PointAttributes } from '../Core/Potree2PointAttributes';
+import { Extent } from '@itowns/geographic';

package/lib/Layer/Potree2Layer.js

@@ -156,8 +156,6 @@ class Potree2Layer extends PointCloudLayer {
       root.boundingSphere = boundingBox.getBoundingSphere(new THREE.Sphere());
       this.minElevationRange = this.minElevationRange ?? metadata.boundingBox.min[2];
       this.maxElevationRange = this.maxElevationRange ?? metadata.boundingBox.max[2];
-      root.id = 'r';
-      root.depth = 0;
       root.nodeType = 2;
       root.hierarchyByteOffset = 0n;
       root.hierarchyByteSize = BigInt(metadata.hierarchy.firstChunkSize);

package/lib/Layer/PotreeLayer.d.ts

@@ -0,0 +1,55 @@
+export default PotreeLayer;
+/**
+ * @property {boolean} isPotreeLayer - Used to checkout whether this layer
+ * is a PotreeLayer. Default is `true`. You should not change this, as it is
+ * used internally for optimisation.
+ *
+ * @extends PointCloudLayer
+ */
+declare class PotreeLayer extends PointCloudLayer {
+    /**
+     * Constructs a new instance of Potree layer.
+     *
+     * @example
+     * // Create a new point cloud layer
+     * const points = new PotreeLayer('points',
+     *  {
+     *      source: new PotreeLayer({
+     *          url: 'https://pointsClouds/',
+     *          file: 'points.js',
+     *      }
+     *  });
+     *
+     * View.prototype.addLayer.call(view, points);
+     *
+     * @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, protocol, extent`, these elements will be
+     * available using `layer.name` or something else depending on the property
+     * name. See the list of properties to know which one can be specified.
+     * @param {string} [config.crs='ESPG:4326'] - The CRS of the {@link View} this
+     * layer will be attached to. This is used to determine the extent of this
+     * layer.  Default to `EPSG:4326`.
+     */
+    constructor(id: string, config: {
+        crs?: string | undefined;
+    });
+    /**
+     * @type {boolean}
+     * @readonly
+     */
+    readonly isPotreeLayer: boolean;
+    scale: THREE.Vector3;
+    spacing: any;
+    hierarchyStepSize: any;
+    supportsProgressiveDisplay: boolean;
+    minElevationRange: any;
+    maxElevationRange: any;
+    extent: Extent;
+}
+import PointCloudLayer from '../Layer/PointCloudLayer';
+import * as THREE from 'three';
+import { Extent } from '@itowns/geographic';

package/lib/Layer/RasterLayer.d.ts

@@ -0,0 +1,8 @@
+export default RasterLayer;
+declare class RasterLayer extends Layer {
+    constructor(id: any, config: any);
+    minFilter: any;
+    magFilter: any;
+    convert(data: any, extentDestination: any): any;
+}
+import Layer from '../Layer/Layer';

package/lib/Layer/RasterLayer.js

@@ -1,5 +1,5 @@
 import Layer from "./Layer.js";
-import { removeLayeredMaterialNodeLayer } from "../Process/LayeredMaterialNodeProcessing.js";
+import { removeLayeredMaterialNodeTile } from "../Process/LayeredMaterialNodeProcessing.js";
 import textureConverter from "../Converter/textureConverter.js";
 import { CACHE_POLICIES } from "../Core/Scheduler/Cache.js";
 class RasterLayer extends Layer {
@@ -30,7 +30,7 @@ class RasterLayer extends Layer {
       this.cache.clear();
     }
     for (const root of this.parent.level0Nodes) {
-      root.traverse(removeLayeredMaterialNodeLayer(this.id));
+      root.traverse(removeLayeredMaterialNodeTile(this.id));
     }
   }
 }

package/lib/Layer/ReferencingLayerProperties.d.ts

@@ -0,0 +1,2 @@
+export default ReferLayerProperties;
+declare function ReferLayerProperties(material: any, layer: any): any;

package/lib/Layer/ReferencingLayerProperties.js

@@ -1,8 +1,6 @@
 // next step is move these properties to Style class
-// and hide transparent mechanism
 function ReferLayerProperties(material, layer) {
   if (layer && layer.isGeometryLayer) {
-    let transparent = material.transparent;
     material.layer = layer;
     if (material.uniforms && material.uniforms.opacity != undefined) {
       Object.defineProperty(material.uniforms.opacity, 'value', {
@@ -46,16 +44,6 @@ function ReferLayerProperties(material, layer) {
     Object.defineProperty(material, 'wireframe', {
       get: () => material.layer.wireframe
     });
-    Object.defineProperty(material, 'transparent', {
-      get: () => {
-        const needTransparency = material.userData.needTransparency?.[material.mode] || material.layer.opacity < 1.0;
-        if (transparent != needTransparency) {
-          material.needsUpdate = true;
-          transparent = needTransparency;
-        }
-        return transparent;
-      }
-    });
   }
   return material;
 }

package/lib/Layer/TiledGeometryLayer.d.ts

@@ -0,0 +1,192 @@
+export default TiledGeometryLayer;
+/**
+ * @property {InfoTiledGeometryLayer} info - Status information of layer
+ * @property {boolean} isTiledGeometryLayer - Used to checkout whether this
+ * layer is a TiledGeometryLayer. Default is true. You should not change this,
+ * as it is used internally for optimisation.
+ * @property {boolean} hideSkirt (default false) - Used to hide the skirt (tile borders).
+ * Useful when the layer opacity < 1
+ *
+ * @extends GeometryLayer
+ */
+declare class TiledGeometryLayer extends GeometryLayer {
+    /**
+     * Tell if a node has enough elevation or color textures to subdivide.
+     * Subdivision is prevented if:
+     * <ul>
+     *  <li>the node is covered by at least one elevation layer and if the node
+     *  doesn't have an elevation texture yet</li>
+     *  <li>a color texture is missing</li>
+     * </ul>
+     *
+     * @param {Object} context - The context of the update; see the {@link
+     * MainLoop} for more informations.
+     * @param {TileMesh} node - The node to subdivide.
+     *
+     * @returns {boolean} False if the node can not be subdivided, true
+     * otherwise.
+     */
+    static hasEnoughTexturesToSubdivide(context: Object, node: TileMesh): boolean;
+    /**
+     * A layer extending the {@link GeometryLayer}, but with a tiling notion.
+     *
+     * `TiledGeometryLayer` is the ground where `ColorLayer` and `ElevationLayer` are attached.
+     * `TiledGeometryLayer` is a quadtree data structure. At zoom 0,
+     * there is a single tile for the whole earth. At zoom level 1,
+     * the single tile splits into 4 tiles (2x2 tile square).
+     * Each zoom level quadtree divides the geometry tiles of the one before it.
+     * The camera distance determines how the tiles are subdivided for optimal data display.
+     *
+     * Some `GeometryLayer` can also be attached to the `TiledGeometryLayer` if they want to take advantage of the quadtree.
+     *
+     * ![tiled geometry](/docs/static/images/tiledGeometry.jpeg)
+     * _In `GlobeView`, **red lines** represents the **WGS84 grid** and **orange lines** the **Pseudo-mercator grid**._
+     * _In this picture, there are tiles with 3 different zoom/levels._
+     *
+     * The zoom/level is based on [tiled web map](https://en.wikipedia.org/wiki/Tiled_web_map).
+     * It corresponds at meters by pixel. If the projection tile exceeds a certain pixel size (on screen)
+     * then it is subdivided into 4 tiles with a zoom greater than 1.
+     *
+     * @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 {THREE.Object3D} object3d - The object3d used to contain the
+     * geometry of the TiledGeometryLayer. It is usually a `THREE.Group`, but it
+     * can be anything inheriting from a `THREE.Object3d`.
+     * @param {Array} schemeTile - extents Array of root tiles
+     * @param {Object} builder - builder geometry object
+     * @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 {Source} [config.source] - Description and options of the source.
+     *
+     * @throws {Error} `object3d` must be a valid `THREE.Object3d`.
+     */
+    constructor(id: string, object3d: THREE.Object3D, schemeTile: any[], builder: Object, config?: {
+        source?: any;
+    });
+    /**
+     * @type {boolean}
+     * @readonly
+     */
+    readonly isTiledGeometryLayer: boolean;
+    protocol: string;
+    /**
+     * @type {boolean}
+     */
+    disableSkirt: boolean;
+    _hideSkirt: boolean;
+    /**
+     * @type {number}
+     */
+    sseSubdivisionThreshold: number;
+    /**
+     * @type {number}
+     */
+    minSubdivisionLevel: number;
+    /**
+     * @type {number}
+     */
+    maxSubdivisionLevel: number;
+    /**
+     * @type {number}
+     * @deprecated
+     */
+    maxDeltaElevationLevel: number;
+    segments: any;
+    schemeTile: any[];
+    builder: Object;
+    info: InfoTiledGeometryLayer;
+    maxScreenSizeNode: number;
+    tileMatrixSets: any;
+    materialOptions: any;
+    showOutline: any;
+    /**
+     * @type {THREE.Vector3 | undefined}
+     */
+    diffuse: THREE.Vector3 | undefined;
+    level0Nodes: any[];
+    set hideSkirt(value: boolean);
+    get hideSkirt(): boolean;
+    /**
+     * Does pre-update work on the context:
+     * <ul>
+     *  <li>update the `colorLayers` and `elevationLayers`</li>
+     *  <li>update the `maxElevationLevel`</li>
+     * </ul>
+     *
+     * Once this work is done, it returns a list of nodes to update. Depending
+     * on the origin of `sources`, it can return a few things:
+     * <ul>
+     *  <li>if `sources` is empty, it returns the first node of the layer
+     *  (stored as `level0Nodes`), which will trigger the update of the whole
+     *  tree</li>
+     *  <li>if the update is triggered by a camera move, the whole tree is
+     *  returned too</li>
+     *  <li>if `source.layer` is this layer, it means that `source` is a node; a
+     *  common ancestor will be found if there are multiple sources, with the
+     *  default common ancestor being the first source itself</li>
+     *  <li>else it returns the whole tree</li>
+     * </ul>
+     *
+     * @param {Object} context - The context of the update; see the {@link
+     * MainLoop} for more informations.
+     * @param {Set<GeometryLayer|TileMesh>} sources - A list of sources to
+     * generate a list of nodes to update.
+     *
+     * @return {TileMesh[]} The array of nodes to update.
+     */
+    preUpdate(context: Object, sources: Set<GeometryLayer | TileMesh>): TileMesh[];
+    _latestUpdateStartingLevel: any;
+    colorLayersOrder: any[] | undefined;
+    /**
+     * Update a node of this layer. The node will not be updated if:
+     * <ul>
+     *  <li>it does not have a parent, then it is removed</li>
+     *  <li>its parent is being subdivided</li>
+     *  <li>is not visible in the camera</li>
+     * </ul>
+     *
+     * @param {Object} context - The context of the update; see the {@link
+     * MainLoop} for more informations.
+     * @param {Layer} layer - Parameter to be removed once all update methods
+     * have been aligned.
+     * @param {TileMesh} node - The node to update.
+     *
+     * @returns {Object}
+     */
+    update(context: Object, layer: Layer, node: TileMesh): Object;
+    convert(requester: any, extent: any): Promise<import("../Core/TileMesh").default>;
+    countColorLayersTextures(...layers: any[]): number;
+    culling(node: any, camera: any): boolean;
+    /**
+     * Subdivides a node of this layer. If the node is currently in the process
+     * of subdivision, it will not do anything here. The subdivision of a node
+     * will occur in four part, to create a quadtree. The extent of the node
+     * will be divided in four parts: north-west, north-east, south-west and
+     * south-east. Once all four nodes are created, they will be added to the
+     * current node and the view of the context will be notified of this change.
+     *
+     * @param {Object} context - The context of the update; see the {@link
+     * MainLoop} for more informations.
+     * @param {TileMesh} node - The node to subdivide.
+     * @return {Promise}  { description_of_the_return_value }
+     */
+    subdivideNode(context: Object, node: TileMesh): Promise<any>;
+    /**
+     * Test the subdvision of a node, compared to this layer.
+     *
+     * @param {Object} context - The context of the update; see the {@link
+     * MainLoop} for more informations.
+     * @param {PlanarLayer} layer - This layer, parameter to be removed.
+     * @param {TileMesh} node - The node to test.
+     *
+     * @return {boolean} - True if the node is subdivisable, otherwise false.
+     */
+    subdivision(context: Object, layer: PlanarLayer, node: TileMesh): boolean;
+}
+import GeometryLayer from '../Layer/GeometryLayer';
+import { InfoTiledGeometryLayer } from '../Layer/InfoLayer';
+import * as THREE from 'three';

package/lib/Layer/TiledGeometryLayer.js

@@ -68,7 +68,7 @@ class TiledGeometryLayer extends GeometryLayer {
       showOutline = false,
       segments,
       disableSkirt = false,
-      materialOptions,
+      materialOptions = {},
       ...configGeometryLayer
     } = config;
     super(id, object3d, {
@@ -126,6 +126,7 @@ class TiledGeometryLayer extends GeometryLayer {
     }
     this.maxScreenSizeNode = this.sseSubdivisionThreshold * (this.sizeDiagonalTexture * 2);
     this.tileMatrixSets = tileMatrixSets;
+    materialOptions.transparent = materialOptions.transparent ?? true;
     this.materialOptions = materialOptions;
 
     /*
@@ -340,7 +341,7 @@ class TiledGeometryLayer extends GeometryLayer {
    */
   static hasEnoughTexturesToSubdivide(context, node) {
     const layerUpdateState = node.layerUpdateState || {};
-    let nodeLayer = node.material.getElevationLayer();
+    let nodeLayer = node.material.getElevationTile();
     for (const e of context.elevationLayers) {
       const extents = node.getExtentsByProjection(e.crs);
       const zoom = extents[0].zoom;
@@ -368,7 +369,7 @@ class TiledGeometryLayer extends GeometryLayer {
       if (layerUpdateState[c.id] && layerUpdateState[c.id].inError()) {
         continue;
       }
-      nodeLayer = node.material.getLayer(c.id);
+      nodeLayer = node.material.getColorTile(c.id);
       if (c.source.extentInsideLimit(node.extent, zoom) && (!nodeLayer || nodeLayer.level < 0)) {
         return false;
       }