itowns 2.43.2-next.2 → 2.43.2-next.20

package/lib/Loader/Potree2Loader.js

@@ -0,0 +1,207 @@
+/*
+============
+== POTREE ==
+============
+
+http://potree.org
+
+Copyright (c) 2011-2020, Markus Schütz
+All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies,
+    either expressed or implied, of the FreeBSD Project.
+ */
+
+import { PointAttribute, PointAttributeTypes } from "../Core/Potree2PointAttributes.js";
+const typedArrayMapping = {
+  int8: Int8Array,
+  int16: Int16Array,
+  int32: Int32Array,
+  int64: Float64Array,
+  uint8: Uint8Array,
+  uint16: Uint16Array,
+  uint32: Uint32Array,
+  uint64: Float64Array,
+  float: Float32Array,
+  double: Float64Array
+};
+export default function load(buffer, options) {
+  const {
+    pointAttributes,
+    scale,
+    min,
+    size,
+    offset,
+    numPoints
+  } = options;
+  const view = new DataView(buffer);
+  const attributeBuffers = {};
+  let attributeOffset = 0;
+  let bytesPerPoint = 0;
+  for (const pointAttribute of pointAttributes.attributes) {
+    bytesPerPoint += pointAttribute.byteSize;
+  }
+  const gridSize = 32;
+  const grid = new Uint32Array(gridSize ** 3);
+  const toIndex = (x, y, z) => {
+    // min is already subtracted
+    const dx = gridSize * x / size.x;
+    const dy = gridSize * y / size.y;
+    const dz = gridSize * z / size.z;
+    const ix = Math.min(parseInt(dx, 10), gridSize - 1);
+    const iy = Math.min(parseInt(dy, 10), gridSize - 1);
+    const iz = Math.min(parseInt(dz, 10), gridSize - 1);
+    return ix + iy * gridSize + iz * gridSize * gridSize;
+  };
+  let numOccupiedCells = 0;
+  for (const pointAttribute of pointAttributes.attributes) {
+    if (['POSITION_CARTESIAN', 'position'].includes(pointAttribute.name)) {
+      const buff = new ArrayBuffer(numPoints * 4 * 3);
+      const positions = new Float32Array(buff);
+      for (let j = 0; j < numPoints; j++) {
+        const pointOffset = j * bytesPerPoint;
+        const x = view.getInt32(pointOffset + attributeOffset + 0, true) * scale[0] + offset[0] - min.x;
+        const y = view.getInt32(pointOffset + attributeOffset + 4, true) * scale[1] + offset[1] - min.y;
+        const z = view.getInt32(pointOffset + attributeOffset + 8, true) * scale[2] + offset[2] - min.z;
+        const index = toIndex(x, y, z);
+        const count = grid[index]++;
+        if (count === 0) {
+          numOccupiedCells++;
+        }
+        positions[3 * j + 0] = x;
+        positions[3 * j + 1] = y;
+        positions[3 * j + 2] = z;
+      }
+      attributeBuffers[pointAttribute.name] = {
+        buffer: buff,
+        attribute: pointAttribute
+      };
+    } else if (['RGBA', 'rgba'].includes(pointAttribute.name)) {
+      const buff = new ArrayBuffer(numPoints * 4);
+      const colors = new Uint8Array(buff);
+      for (let j = 0; j < numPoints; j++) {
+        const pointOffset = j * bytesPerPoint;
+        const r = view.getUint16(pointOffset + attributeOffset + 0, true);
+        const g = view.getUint16(pointOffset + attributeOffset + 2, true);
+        const b = view.getUint16(pointOffset + attributeOffset + 4, true);
+        colors[4 * j + 0] = r > 255 ? r / 256 : r;
+        colors[4 * j + 1] = g > 255 ? g / 256 : g;
+        colors[4 * j + 2] = b > 255 ? b / 256 : b;
+      }
+      attributeBuffers[pointAttribute.name] = {
+        buffer: buff,
+        attribute: pointAttribute
+      };
+    } else {
+      const buff = new ArrayBuffer(numPoints * 4);
+      const f32 = new Float32Array(buff);
+      const TypedArray = typedArrayMapping[pointAttribute.type.name];
+      const preciseBuffer = new TypedArray(numPoints);
+      let [offset, scale] = [0, 1];
+      const getterMap = {
+        int8: view.getInt8,
+        int16: view.getInt16,
+        int32: view.getInt32,
+        uint8: view.getUint8,
+        uint16: view.getUint16,
+        uint32: view.getUint32,
+        float: view.getFloat32,
+        double: view.getFloat64
+      };
+      const getter = getterMap[pointAttribute.type.name].bind(view);
+
+      // compute offset and scale to pack larger types into 32 bit floats
+      if (pointAttribute.type.size > 4) {
+        const [amin, amax] = pointAttribute.range;
+        offset = amin;
+        scale = 1 / (amax - amin);
+      }
+      for (let j = 0; j < numPoints; j++) {
+        const pointOffset = j * bytesPerPoint;
+        const value = getter(pointOffset + attributeOffset, true);
+        f32[j] = (value - offset) * scale;
+        preciseBuffer[j] = value;
+      }
+      attributeBuffers[pointAttribute.name] = {
+        buffer: buff,
+        preciseBuffer,
+        attribute: pointAttribute,
+        offset,
+        scale
+      };
+    }
+    attributeOffset += pointAttribute.byteSize;
+  }
+  const occupancy = parseInt(numPoints / numOccupiedCells, 10);
+  {
+    // add indices
+    const buff = new ArrayBuffer(numPoints * 4);
+    const indices = new Uint32Array(buff);
+    for (let i = 0; i < numPoints; i++) {
+      indices[i] = i;
+    }
+    attributeBuffers.INDICES = {
+      buffer: buff,
+      attribute: PointAttribute.INDICES
+    };
+  }
+  {
+    // handle attribute vectors
+    const vectors = pointAttributes.vectors;
+    for (const vector of vectors) {
+      const {
+        name,
+        attributes
+      } = vector;
+      const numVectorElements = attributes.length;
+      const buffer = new ArrayBuffer(numVectorElements * numPoints * 4);
+      const f32 = new Float32Array(buffer);
+      let iElement = 0;
+      for (const sourceName of attributes) {
+        const sourceBuffer = attributeBuffers[sourceName];
+        const {
+          offset,
+          scale
+        } = sourceBuffer;
+        const view = new DataView(sourceBuffer.buffer);
+        const getter = view.getFloat32.bind(view);
+        for (let j = 0; j < numPoints; j++) {
+          const value = getter(j * 4, true);
+          f32[j * numVectorElements + iElement] = value / scale + offset;
+        }
+        iElement++;
+      }
+      const vecAttribute = new PointAttribute(name, PointAttributeTypes.DATA_TYPE_FLOAT, 3);
+      attributeBuffers[name] = {
+        buffer,
+        attribute: vecAttribute
+      };
+    }
+  }
+  return {
+    buffer,
+    attributeBuffers,
+    density: occupancy
+  };
+}

package/lib/Main.js

@@ -51,6 +51,7 @@ export { default as GeometryLayer } from "./Layer/GeometryLayer.js";
 export { default as FeatureGeometryLayer } from "./Layer/FeatureGeometryLayer.js";
 export { default as PointCloudLayer } from "./Layer/PointCloudLayer.js";
 export { default as PotreeLayer } from "./Layer/PotreeLayer.js";
+export { default as Potree2Layer } from "./Layer/Potree2Layer.js";
 export { default as C3DTilesLayer, C3DTILES_LAYER_EVENTS } from "./Layer/C3DTilesLayer.js";
 export { default as TiledGeometryLayer } from "./Layer/TiledGeometryLayer.js";
 export { default as OrientedImageLayer } from "./Layer/OrientedImageLayer.js";
@@ -75,6 +76,7 @@ export { default as WMTSSource } from "./Source/WMTSSource.js";
 export { default as VectorTilesSource } from "./Source/VectorTilesSource.js";
 export { default as OrientedImageSource } from "./Source/OrientedImageSource.js";
 export { default as PotreeSource } from "./Source/PotreeSource.js";
+export { default as Potree2Source } from "./Source/Potree2Source.js";
 export { default as C3DTilesSource } from "./Source/C3DTilesSource.js";
 export { default as C3DTilesIonSource } from "./Source/C3DTilesIonSource.js";
 export { default as C3DTilesGoogleSource } from "./Source/C3DTilesGoogleSource.js";

package/lib/Parser/GeoJsonParser.js

@@ -132,8 +132,7 @@ function toFeatureType(jsonType) {
 const keyProperties = ['type', 'geometry', 'properties'];
 const firstCoordinates = a => a === undefined || Array.isArray(a) && !isNaN(a[0]) ? a : firstCoordinates(a[0]);
 function jsonFeatureToFeature(crsIn, json, collection) {
-  var _json$geometry, _firstCoordinates;
-  if (!((_json$geometry = json.geometry) !== null && _json$geometry !== void 0 && _json$geometry.type)) {
+  if (!json.geometry?.type) {
     console.warn('No geometry provided');
     return null;
   }
@@ -142,7 +141,7 @@ function jsonFeatureToFeature(crsIn, json, collection) {
   const feature = collection.requestFeatureByType(featureType);
   const coordinates = jsonType != 'point' ? json.geometry.coordinates : [json.geometry.coordinates];
   const properties = json.properties || {};
-  feature.hasRawElevationData = ((_firstCoordinates = firstCoordinates(coordinates)) === null || _firstCoordinates === void 0 ? void 0 : _firstCoordinates.length) === 3;
+  feature.hasRawElevationData = firstCoordinates(coordinates)?.length === 3;
 
   // copy other properties
   for (const key of Object.keys(json)) {

package/lib/Parser/LASParser.js

@@ -1,6 +1,23 @@
 import * as THREE from 'three';
-import LASLoader from "./LASLoader.js";
-const lasLoader = new LASLoader();
+import { spawn, Thread, Transfer } from 'threads';
+let _lazPerf;
+let _thread;
+function workerInstance() {
+  return new Worker( /* webpackChunkName: "itowns_lasparser" */
+  new URL('../Worker/LASLoaderWorker.js', import.meta.url), {
+    type: 'module'
+  });
+}
+async function loader() {
+  if (_thread) {
+    return _thread;
+  }
+  _thread = await spawn(workerInstance());
+  if (_lazPerf) {
+    _thread.lazPerf(_lazPerf);
+  }
+  return _thread;
+}
 function buildBufferGeometry(attributes) {
   const geometry = new THREE.BufferGeometry();
   const positionBuffer = new THREE.BufferAttribute(attributes.position, 3);
@@ -42,7 +59,16 @@ export default {
     if (!path) {
       throw new Error('Path to laz-perf is mandatory');
     }
-    lasLoader.lazPerf = path;
+    _lazPerf = path;
+  },
+  /**
+   * Terminate all worker instances.
+   * @returns {Promise<void>}
+   */
+  terminate() {
+    const currentThread = _thread;
+    _thread = undefined;
+    return Thread.terminate(currentThread);
   },
   /**
    * Parses a chunk of a LAS or LAZ (LASZip) and returns the corresponding
@@ -66,13 +92,18 @@ export default {
    * @return {Promise<THREE.BufferGeometry>} A promise resolving with a
    * `THREE.BufferGeometry`.
    */
-  parseChunk(data) {
+  async parseChunk(data) {
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    return lasLoader.parseChunk(data, options.in).then(parsedData => {
-      const geometry = buildBufferGeometry(parsedData.attributes);
-      geometry.computeBoundingBox();
-      return geometry;
+    const lasLoader = await loader();
+    const parsedData = await lasLoader.parseChunk(Transfer(data), {
+      pointCount: options.in.pointCount,
+      header: options.in.header,
+      eb: options.eb,
+      colorDepth: options.in.colorDepth
     });
+    const geometry = buildBufferGeometry(parsedData.attributes);
+    geometry.computeBoundingBox();
+    return geometry;
   },
   /**
    * Parses a LAS file or a LAZ (LASZip) file and return the corresponding
@@ -88,19 +119,19 @@ export default {
    * @return {Promise} A promise resolving with a `THREE.BufferGeometry`. The
    * header of the file is contained in `userData`.
    */
-  parse(data) {
-    var _options$out, _options$in;
+  async parse(data) {
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    if ((_options$out = options.out) !== null && _options$out !== void 0 && _options$out.skip) {
+    if (options.out?.skip) {
       console.warn("Warning: options 'skip' not supported anymore");
     }
-    return lasLoader.parseFile(data, {
-      colorDepth: (_options$in = options.in) === null || _options$in === void 0 ? void 0 : _options$in.colorDepth
-    }).then(parsedData => {
-      const geometry = buildBufferGeometry(parsedData.attributes);
-      geometry.userData.header = parsedData.header;
-      geometry.computeBoundingBox();
-      return geometry;
+    const input = options.in;
+    const lasLoader = await loader();
+    const parsedData = await lasLoader.parseFile(Transfer(data), {
+      colorDepth: input?.colorDepth
     });
+    const geometry = buildBufferGeometry(parsedData.attributes);
+    geometry.userData.header = parsedData.header;
+    geometry.computeBoundingBox();
+    return geometry;
   }
 };

package/lib/Parser/Potree2BinParser.js

@@ -0,0 +1,92 @@
+import * as THREE from 'three';
+import { spawn, Thread, Transfer } from 'threads';
+let _thread;
+function workerInstance() {
+  return new Worker( /* webpackChunkName: "itowns_potree2worker" */
+  new URL('../Worker/Potree2Worker.js', import.meta.url), {
+    type: 'module'
+  });
+}
+async function loader() {
+  if (_thread) {
+    return _thread;
+  }
+  _thread = await spawn(workerInstance());
+  return _thread;
+}
+function decoder(w, metadata) {
+  return metadata.encoding === 'BROTLI' ? w.parseBrotli : w.parse;
+}
+export default {
+  /**
+   * @return {Promise<void>}
+   */
+  terminate() {
+    const currentThread = _thread;
+    _thread = undefined;
+    return Thread.terminate(currentThread);
+  },
+  /** @module Potree2BinParser */
+  /** Parse .bin PotreeConverter 2.0 format and convert to a THREE.BufferGeometry
+   * @function parse
+   * @param {ArrayBuffer} buffer - the bin buffer.
+   * @param {Object} options
+   * @param {string[]} options.in.pointAttributes - the point attributes information contained in metadata.js
+   * @return {Promise} - a promise that resolves with a THREE.BufferGeometry.
+   *
+   */
+  parse: async function (buffer, options) {
+    const metadata = options.in.source.metadata;
+    const layer = options.out;
+    const pointAttributes = layer.pointAttributes;
+    const scale = metadata.scale;
+    const box = options.in.bbox;
+    const min = box.min;
+    const size = box.max.clone().sub(box.min);
+    const max = box.max;
+    const offset = metadata.offset;
+    const numPoints = options.in.numPoints;
+    const potreeLoader = await loader();
+    const decode = decoder(potreeLoader, metadata);
+    const data = await decode(Transfer(buffer), {
+      pointAttributes,
+      scale,
+      min,
+      max,
+      size,
+      offset,
+      numPoints
+    });
+    const buffers = data.attributeBuffers;
+    const geometry = new THREE.BufferGeometry();
+    Object.keys(buffers).forEach(property => {
+      const buffer = buffers[property].buffer;
+      if (property === 'position') {
+        geometry.setAttribute('position', new THREE.BufferAttribute(new Float32Array(buffer), 3));
+      } else if (property === 'rgba') {
+        geometry.setAttribute('color', new THREE.BufferAttribute(new Uint8Array(buffer), 4, true));
+      } else if (property === 'NORMAL') {
+        geometry.setAttribute('normal', new THREE.BufferAttribute(new Float32Array(buffer), 3));
+      } else if (property === 'INDICES') {
+        const bufferAttribute = new THREE.BufferAttribute(new Uint8Array(buffer), 4);
+        bufferAttribute.normalized = true;
+        geometry.setAttribute('indices', bufferAttribute);
+      } else {
+        const bufferAttribute = new THREE.BufferAttribute(new Float32Array(buffer), 1);
+        const batchAttribute = buffers[property].attribute;
+        bufferAttribute.potree = {
+          offset: buffers[property].offset,
+          scale: buffers[property].scale,
+          preciseBuffer: buffers[property].preciseBuffer,
+          range: batchAttribute.range
+        };
+        geometry.setAttribute(property, bufferAttribute);
+      }
+    });
+    geometry.computeBoundingBox();
+    return {
+      geometry,
+      density: data.density
+    };
+  }
+};

package/lib/Parser/deprecated/LegacyGLTFLoader.js

@@ -321,7 +321,6 @@ threeExamples.LegacyGLTFLoader = function () {
     1029: THREE.FrontSide // Culling back
     //1032: THREE.NoSide   // Culling front and back, what to do?
   };
-
   var WEBGL_DEPTH_FUNCS = {
     512: THREE.NeverDepth,
     513: THREE.LessDepth,
@@ -355,7 +354,6 @@ threeExamples.LegacyGLTFLoader = function () {
     //32771: CONSTANT_ALPHA,
     //32772: ONE_MINUS_CONSTANT_COLOR
   };
-
   var WEBGL_TYPE_SIZES = {
     'SCALAR': 1,
     'VEC2': 2,
@@ -1116,6 +1114,7 @@ threeExamples.LegacyGLTFLoader = function () {
 
         // According to COLLADA spec...
         // aspectRatio = xfov / yfov
+
         var _camera = new THREE.PerspectiveCamera(THREE.MathUtils.radToDeg(yfov * aspectRatio), aspectRatio, camera.perspective.znear || 1, camera.perspective.zfar || 2e6);
         if (camera.name !== undefined) _camera.name = camera.name;
         if (camera.extras) _camera.userData = camera.extras;

package/lib/Process/3dTilesProcessing.js

@@ -160,10 +160,11 @@ function cleanup3dTileset(layer, n) {
 }
 
 // this is a layer
-export function pre3dTilesUpdate() {
+export function pre3dTilesUpdate(context) {
   if (!this.visible) {
     return [];
   }
+  this.scale = context.camera._preSSE;
 
   // Elements removed are added in the layer._cleanableTiles list.
   // Since we simply push in this array, the first item is always

package/lib/Process/FeatureProcessing.js

@@ -17,9 +17,8 @@ export default {
     if (node.layerUpdateState[layer.id] === undefined) {
       node.layerUpdateState[layer.id] = new LayerUpdateState();
     } else if (!node.layerUpdateState[layer.id].canTryUpdate()) {
-      var _node$link$layer$id;
       // toggle visibility features
-      (_node$link$layer$id = node.link[layer.id]) === null || _node$link$layer$id === void 0 ? void 0 : _node$link$layer$id.forEach(f => {
+      node.link[layer.id]?.forEach(f => {
         f.layer.object3d.add(f);
         f.meshes.position.z = geoidLayerIsVisible(layer.parent) ? node.geoidHeight : 0;
         f.meshes.updateMatrixWorld();

package/lib/Process/LayeredMaterialNodeProcessing.js

@@ -1,8 +1,6 @@
 import { chooseNextLevelToFetch } from "../Layer/LayerUpdateStrategy.js";
 import LayerUpdateState from "../Layer/LayerUpdateState.js";
 import handlingError from "./handlerNodeError.js";
-export const SIZE_TEXTURE_TILE = 256;
-export const SIZE_DIAGONAL_TEXTURE = (2 * (SIZE_TEXTURE_TILE * SIZE_TEXTURE_TILE)) ** 0.5;
 function materialCommandQueuePriorityFunction(material) {
   // We know that 'node' is visible because commands can only be
   // issued for visible nodes.
@@ -62,14 +60,12 @@ export function updateLayeredMaterialNodeImagery(context, layer, node, parent) {
         return;
       } // ok, we're going to inherit our parent's texture
     }
-
     if (!nodeLayer) {
-      var _parent$material;
       // Create new raster node
       nodeLayer = layer.setupRasterNode(node);
 
       // Init the node by parent
-      const parentLayer = (_parent$material = parent.material) === null || _parent$material === void 0 ? void 0 : _parent$material.getLayer(layer.id);
+      const parentLayer = parent.material?.getLayer(layer.id);
       nodeLayer.initFromParent(parentLayer, extentsDestination);
     }
 
@@ -158,9 +154,8 @@ export function updateLayeredMaterialNodeElevation(context, layer, node, parent)
     nodeLayer = layer.setupRasterNode(node);
   }
   if (node.layerUpdateState[layer.id] === undefined) {
-    var _parent$material2;
     node.layerUpdateState[layer.id] = new LayerUpdateState();
-    const parentLayer = (_parent$material2 = parent.material) === null || _parent$material2 === void 0 ? void 0 : _parent$material2.getLayer(layer.id);
+    const parentLayer = parent.material?.getLayer(layer.id);
     nodeLayer.initFromParent(parentLayer, extentsDestination);
     if (nodeLayer.level >= layer.source.zoom.min) {
       context.view.notifyChange(node, false);
@@ -210,8 +205,7 @@ export function removeLayeredMaterialNodeLayer(layerId) {
    * @param {TileMesh} node - The node to udpate.
    */
   return function (node) {
-    var _node$material;
-    if ((_node$material = node.material) !== null && _node$material !== void 0 && _node$material.removeLayer) {
+    if (node.material?.removeLayer) {
       if (node.material.elevationLayerIds.indexOf(layerId) > -1) {
         node.setBBoxZ({
           min: 0,

package/lib/Process/ObjectRemovalHelper.js

@@ -28,7 +28,6 @@ export default {
         // see https://github.com/iTowns/itowns/issues/869
         // obj.geometry = null;
       }
-
       if (obj.material) {
         if (Array.isArray(obj.material)) {
           for (const material of obj.material) {
@@ -82,7 +81,7 @@ export default {
     // of the objects which have their own removal logic
     let toRemove = obj.children.filter(c => c.layer && c.layer.id === layer.id);
     const linked = obj.link && obj.link[layer.id];
-    if (linked !== null && linked !== void 0 && linked.children.length) {
+    if (linked?.children.length) {
       toRemove = toRemove.concat(linked.children);
       delete obj.link[layer.id];
     }

package/lib/Provider/3dTilesProvider.js

@@ -35,10 +35,10 @@ function gltfToMesh(data, layer, url) {
 function pntsParse(data, layer) {
   return PntsParser.parse(data, layer.registeredExtensions).then(result => {
     const material = layer.material ? layer.material.clone() : new PointsMaterial({
-      size: 0.05,
+      size: 1,
       mode: layer.pntsMode,
       shape: layer.pntsShape,
-      classification: layer.classification,
+      classificationScheme: layer.classification,
       sizeMode: layer.pntsSizeMode,
       minAttenuatedSize: layer.pntsMinAttenuatedSize,
       maxAttenuatedSize: layer.pntsMaxAttenuatedSize
@@ -114,6 +114,7 @@ function executeCommand(command) {
         } else if (magic == 'b3dm') {
           func = supportedFormats.b3dm;
         } else if (magic == 'pnts') {
+          layer.hasPnts = true;
           func = supportedFormats.pnts;
         } else if (magic == 'glTF') {
           func = supportedFormats.gltf;

package/lib/Renderer/ColorLayersOrdering.js

@@ -2,8 +2,7 @@ import { ImageryLayers } from "../Layer/Layer.js";
 function updateLayersOrdering(geometryLayer, imageryLayers) {
   const sequence = ImageryLayers.getColorLayersIdOrderedBySequence(imageryLayers);
   const cO = function (object) {
-    var _object$material;
-    if ((_object$material = object.material) !== null && _object$material !== void 0 && _object$material.setSequence) {
+    if (object.material?.setSequence) {
       object.material.setSequence(sequence);
     }
   };

package/lib/Renderer/Label2DRenderer.js

@@ -157,10 +157,7 @@ class Label2DRenderer {
       }
     });
     labelLayers.forEach(labelLayer => {
-      labelLayer.toHide.children.forEach(labelsNode => {
-        var _labelsNode$domElemen;
-        return (_labelsNode$domElemen = labelsNode.domElements) === null || _labelsNode$domElemen === void 0 ? void 0 : _labelsNode$domElemen.labels.hide();
-      });
+      labelLayer.toHide.children.forEach(labelsNode => labelsNode.domElements?.labels.hide());
       labelLayer.toHide.clear();
     });
   }