itowns 2.43.2-next.9 → 2.44.1-next.0

package/lib/Main.js

@@ -1,5 +1,5 @@
 const conf = {
-  version: '2.43.1'
+  version: '2.44.0'
 };
 export const REVISION = conf.version;
 
@@ -51,7 +51,9 @@ 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 OGC3DTilesLayer, OGC3DTILES_LAYER_EVENTS, enableDracoLoader, enableKtx2Loader } from "./Layer/OGC3DTilesLayer.js";
 export { default as TiledGeometryLayer } from "./Layer/TiledGeometryLayer.js";
 export { default as OrientedImageLayer } from "./Layer/OrientedImageLayer.js";
 export { STRATEGY_MIN_NETWORK_TRAFFIC, STRATEGY_GROUP, STRATEGY_PROGRESSIVE, STRATEGY_DICHOTOMY } from "./Layer/LayerUpdateStrategy.js";
@@ -75,9 +77,13 @@ 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";
+export { default as OGC3DTilesSource } from "./Source/OGC3DTilesSource.js";
+export { default as OGC3DTilesIonSource } from "./Source/OGC3DTilesIonSource.js";
+export { default as OGC3DTilesGoogleSource } from "./Source/OGC3DTilesGoogleSource.js";
 export { default as EntwinePointTileSource } from "./Source/EntwinePointTileSource.js";
 export { default as CopcSource } from "./Source/CopcSource.js";
 
@@ -93,7 +99,8 @@ export { default as LASParser } from "./Parser/LASParser.js";
 export { default as ISGParser } from "./Parser/ISGParser.js";
 export { default as GDFParser } from "./Parser/GDFParser.js";
 export { default as GTXParser } from "./Parser/GTXParser.js";
-export { default as GLTFParser, enableDracoLoader, enableKtx2Loader, glTFLoader, legacyGLTFLoader } from "./Parser/GLTFParser.js";
+export { default as B3dmParser } from "./Parser/B3dmParser.js";
+export { default as iGLTFLoader } from "./Parser/iGLTFLoader.js";
 
 // 3D Tiles classes and extensions
 // Exported to allow one to implement its own 3D Tiles extension which needs to

package/lib/Parser/B3dmParser.js

@@ -5,8 +5,10 @@ import { MeshBasicMaterial } from 'three';
 import disposeThreeMaterial from "../Utils/ThreeUtils.js";
 import shaderUtils from "../Renderer/Shader/ShaderUtils.js";
 import ReferLayerProperties from "../Layer/ReferencingLayerProperties.js";
-import GLTFParser from "./GLTFParser.js";
-const matrixChangeUpVectorYtoZInv = new THREE.Matrix4().makeRotationX(-Math.PI / 2);
+// A bit weird but temporary until we remove this deprecated parser. Mainly to benefit from the enableDracoLoader and enableKtx2Loader
+// methods.
+import { itownsGLTFLoader } from "../Layer/OGC3DTilesLayer.js";
+const matrixChangeUpVectorYtoZ = new THREE.Matrix4().makeRotationX(Math.PI / 2);
 const matrixChangeUpVectorXtoZ = new THREE.Matrix4().makeRotationZ(-Math.PI / 2);
 const utf8Decoder = new TextDecoder();
 
@@ -34,18 +36,15 @@ function filterUnsupportedSemantics(obj) {
 }
 
 /**
- * 3D Tiles pre-1.0 had a gltfUpAxis parameter that defined the up vector of the gltf file that might be different from
- * the standard y-up for gltf. Manage the case when this gltfUpAxis is defined (i.e. apply the correct rotation to the
- * gltf file to have it z-up in the end).
+ * Transforms loaded gltf model to z-up (either from y-up or from the up axis defined in gltfUpAxis). Note that
+ * gltfUpAxis was an attribut of pre-1.0 3D Tiles and is now deprecated.
  * @param {THREE.Object3D} gltfScene - the parsed glTF scene
  * @param {String} gltfUpAxis - the gltfUpAxis parameter
  */
-function applyDeprecatedGltfUpAxis(gltfScene, gltfUpAxis) {
-  if (gltfUpAxis === 'Z') {
-    // If gltf up was already z-up, apply the inverse transform matrix that was applied in the glTFParser
-    gltfScene.applyMatrix4(matrixChangeUpVectorYtoZInv);
+function transformToZUp(gltfScene, gltfUpAxis) {
+  if (!gltfUpAxis || gltfUpAxis === 'Y') {
+    gltfScene.applyMatrix4(matrixChangeUpVectorYtoZ);
   } else if (gltfUpAxis === 'X') {
-    gltfScene.applyMatrix4(matrixChangeUpVectorYtoZInv);
     gltfScene.applyMatrix4(matrixChangeUpVectorXtoZ);
   }
 }
@@ -127,7 +126,6 @@ export default {
       }
       const posGltf = headerByteLength + b3dmHeader.FTJSONLength + b3dmHeader.FTBinaryLength + b3dmHeader.BTJSONLength + b3dmHeader.BTBinaryLength;
       const gltfBuffer = buffer.slice(posGltf);
-      const headerView = new DataView(gltfBuffer, 0, 20);
       const init_mesh = function (mesh) {
         mesh.frustumCulled = frustumCulled;
         if (mesh.material) {
@@ -147,11 +145,11 @@ export default {
           ReferLayerProperties(mesh.material, options.layer);
         }
       };
-      promises.push(GLTFParser.parse(gltfBuffer, options).then(gltf => {
+      promises.push(itownsGLTFLoader.parseAsync(gltfBuffer, options).then(gltf => {
         for (const scene of gltf.scenes) {
           scene.traverse(filterUnsupportedSemantics);
         }
-        applyDeprecatedGltfUpAxis(gltf.scene, options.gltfUpAxis);
+        transformToZUp(gltf.scene, options.gltfUpAxis);
         const shouldBePatchedForLogDepthSupport = Capabilities.isLogDepthBufferSupported() && !options.doNotPatchMaterial;
         if (options.frustumCulling === false || options.overrideMaterials || shouldBePatchedForLogDepthSupport || options.layer) {
           gltf.scene.traverse(init_mesh);
@@ -159,15 +157,6 @@ export default {
 
         // Apply relative center from Feature table.
         gltf.scene.position.copy(FT_RTC);
-
-        // Apply relative center from gltf json.
-        const contentArray = new Uint8Array(gltfBuffer, 20, headerView.getUint32(12, true));
-        const content = utf8Decoder.decode(new Uint8Array(contentArray));
-        const json = JSON.parse(content);
-        if (json.extensions && json.extensions.CESIUM_RTC) {
-          gltf.scene.position.fromArray(json.extensions.CESIUM_RTC.center);
-          gltf.scene.updateMatrixWorld(true);
-        }
         return gltf;
       }).catch(e => {
         throw new Error(e);

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,18 +119,19 @@ export default {
    * @return {Promise} A promise resolving with a `THREE.BufferGeometry`. The
    * header of the file is contained in `userData`.
    */
-  parse(data) {
+  async parse(data) {
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     if (options.out?.skip) {
       console.warn("Warning: options 'skip' not supported anymore");
     }
-    return lasLoader.parseFile(data, {
-      colorDepth: 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/ShapefileParser.js

@@ -68,9 +68,9 @@ export default {
 
     // If a zip is present, don't read anything else
     if (data.zip) {
-      result = shp.parseZip(data.zip);
+      result = shp(data.zip);
     } else if (data.shp && data.shx && data.dbf) {
-      result = Promise.all([shp.parseShp(data.shp, data.prj), shp.parseDbf(data.dbf)]).then(shp.combine);
+      result = shp(data);
     }
     options.in = options.in || {};
     options.in.crs = data.prj ? proj4(data.prj).oProj.datumName : options.in.crs;

package/lib/Parser/deprecated/LegacyGLTFLoader.js

@@ -1,5 +1,6 @@
 /* eslint-disable */
-// Copy LegacyGLTFLoader file from THREE v110 because it was removed in THREE v111
+// LegacyGLTFLoader for loading gltf 1.0 files taken from THREE v110 because it was removed in THREE v111 and maintained
+// since
 import * as THREE from 'three';
 const threeExamples = {};
 /**
@@ -45,6 +46,9 @@ threeExamples.LegacyGLTFLoader = function () {
       if (json.extensionsUsed && json.extensionsUsed.indexOf(EXTENSIONS.KHR_MATERIALS_COMMON) >= 0) {
         extensions[EXTENSIONS.KHR_MATERIALS_COMMON] = new GLTFMaterialsCommonExtension(json);
       }
+      if (json.extensionsUsed && json.extensionsUsed.indexOf(EXTENSIONS.CESIUM_RTC) >= 0) {
+        extensions[EXTENSIONS.CESIUM_RTC] = new CesiumRTCExtension(json);
+      }
       var parser = new GLTFParser(json, extensions, {
         crossOrigin: this.crossOrigin,
         manager: this.manager,
@@ -175,7 +179,8 @@ threeExamples.LegacyGLTFLoader = function () {
 
   var EXTENSIONS = {
     KHR_BINARY_GLTF: 'KHR_binary_glTF',
-    KHR_MATERIALS_COMMON: 'KHR_materials_common'
+    KHR_MATERIALS_COMMON: 'KHR_materials_common',
+    CESIUM_RTC: 'CESIUM_RTC'
   };
 
   /* MATERIALS COMMON EXTENSION */
@@ -247,6 +252,17 @@ threeExamples.LegacyGLTFLoader = function () {
     return THREE.LoaderUtils.decodeText(array);
   };
 
+  // Ref spec https://github.com/KhronosGroup/glTF/blob/main/extensions/1.0/Vendor/CESIUM_RTC/README.md
+  // Only the json storage method is implemented since it is the only one we've seen out there and since this extension
+  // is specific to deprecated 3D tiles with GLTF 1.0
+  function CesiumRTCExtension(json) {
+    this.name = EXTENSIONS.CESIUM_RTC;
+    this.center = [0, 0, 0];
+    if (json.extensions && json.extensions[EXTENSIONS.CESIUM_RTC] && json.extensions[EXTENSIONS.CESIUM_RTC].center && json.extensions[EXTENSIONS.CESIUM_RTC].center.length === 3) {
+      this.center = json.extensions[EXTENSIONS.CESIUM_RTC].center;
+    }
+  }
+
   /*********************************/
   /********** INTERNALS ************/
   /*********************************/
@@ -526,9 +542,9 @@ threeExamples.LegacyGLTFLoader = function () {
   }
 
   /**
-   * Verifies if the shaders are Cesium specific: if they contain attributes, uniforms or functions starting with 
-   * `czm_`. The cesium gltf-pipeline (the ancestor of cesium ion) used to create 3D Tiles tilesets they are only 
-   * defined in Cesium. 
+   * Verifies if the shaders are Cesium specific: if they contain attributes, uniforms or functions starting with
+   * `czm_`. The cesium gltf-pipeline (the ancestor of cesium ion) used to create 3D Tiles tilesets they are only
+   * defined in Cesium.
    * @param {Object} shaders
    */
   function areShadersCesiumSpecific(shaders) {
@@ -1323,6 +1339,7 @@ threeExamples.LegacyGLTFLoader = function () {
   };
   GLTFParser.prototype.loadScenes = function () {
     var json = this.json;
+    var extensions = this.extensions;
 
     // scene node hierachy builder
 
@@ -1357,6 +1374,9 @@ threeExamples.LegacyGLTFLoader = function () {
             };
           }
         });
+        if (extensions[EXTENSIONS.CESIUM_RTC]) {
+          _scene.position.fromArray(extensions[EXTENSIONS.CESIUM_RTC].center);
+        }
         return _scene;
       });
     });

package/lib/Parser/iGLTFLoader.js

@@ -0,0 +1,169 @@
+import * as THREE from 'three';
+import LegacyGLTFLoader from "./deprecated/LegacyGLTFLoader.js";
+import { GLTFLoader } from "../ThreeExtended/loaders/GLTFLoader.js";
+class iGLTFLoader extends THREE.Loader {
+  /**
+   * 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.
+   *
+   * @constructor
+   * @param {THREE.LoadingManager} [manager] - The loadingManager for the loader to use. Default is THREE.DefaultLoadingManager.
+   */
+  constructor(manager) {
+    super(manager);
+    this.legacyGLTFLoader = new LegacyGLTFLoader();
+    this.glTFLoader = new 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, onLoad, onProgress, onError) {
+    const scope = this;
+    let resourcePath;
+    if (this.resourcePath !== '') {
+      resourcePath = this.resourcePath;
+    } else if (this.path !== '') {
+      // If a base path is set, resources will be relative paths from that plus the relative path of the gltf file
+      // Example  path = 'https://my-cnd-server.com/', url = 'assets/models/model.gltf'
+      // resourcePath = 'https://my-cnd-server.com/assets/models/'
+      // referenced resource 'model.bin' will be loaded from 'https://my-cnd-server.com/assets/models/model.bin'
+      // referenced resource '../textures/texture.png' will be loaded from 'https://my-cnd-server.com/assets/textures/texture.png'
+      const relativeUrl = THREE.LoaderUtils.extractUrlBase(url);
+      resourcePath = THREE.LoaderUtils.resolveURL(relativeUrl, this.path);
+    } else {
+      resourcePath = THREE.LoaderUtils.extractUrlBase(url);
+    }
+
+    // Tells the LoadingManager to track an extra item, which resolves after
+    // the model is fully loaded. This means the count of items loaded will
+    // be incorrect, but ensures manager.onLoad() does not fire early.
+    this.manager.itemStart(url);
+    const _onError = e => {
+      if (onError) {
+        onError(e);
+      } else {
+        console.error(e);
+      }
+      scope.manager.itemError(url);
+      scope.manager.itemEnd(url);
+    };
+    const loader = new THREE.FileLoader(this.manager);
+    loader.setPath(this.path);
+    loader.setResponseType('arraybuffer');
+    loader.setRequestHeader(this.requestHeader);
+    loader.setWithCredentials(this.withCredentials);
+    loader.load(url, data => {
+      try {
+        scope.parse(data, resourcePath, gltf => {
+          onLoad(gltf);
+          scope.manager.itemEnd(url);
+        }, _onError);
+      } catch (e) {
+        _onError(e);
+      }
+    }, onProgress, _onError);
+  }
+
+  /**
+   * 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) {
+    this.glTFLoader.setDRACOLoader(dracoLoader);
+  }
+
+  /**
+   * 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) {
+    this.glTFLoader.setKTX2Loader(ktx2Loader);
+  }
+
+  /**
+   * 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) {
+    this.glTFLoader.setMeshoptDecoder(meshoptDecoder);
+  }
+
+  /**
+   * 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) {
+    this.glTFLoader.register(callback);
+  }
+
+  /**
+   * 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) {
+    this.glTFLoader.unregister(callback);
+  }
+
+  /** 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, path, onLoad, onError) {
+    if (!buffer || !path) {
+      onError('[iGLTFLoader]: Buffer and path are mandatory to parse a glTF.');
+      return;
+    }
+    const headerView = new DataView(buffer, 0, 20);
+    const version = headerView.getUint32(4, true);
+    if (version === 1) {
+      this.legacyGLTFLoader.parse(buffer, path, onLoad, onError);
+    } else {
+      this.glTFLoader.parse(buffer, path, onLoad, onError);
+    }
+  }
+
+  /**
+   * 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, path) {
+    const scope = this;
+    return new Promise((resolve, reject) => {
+      scope.parse(data, path, resolve, reject);
+    });
+  }
+}
+export default iGLTFLoader;

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/Provider/3dTilesProvider.js

@@ -1,10 +1,12 @@
 import * as THREE from 'three';
 import B3dmParser from "../Parser/B3dmParser.js";
 import PntsParser from "../Parser/PntsParser.js";
-import GLTFParser from "../Parser/GLTFParser.js";
 import Fetcher from "./Fetcher.js";
 import ReferLayerProperties from "../Layer/ReferencingLayerProperties.js";
 import PointsMaterial from "../Renderer/PointsMaterial.js";
+// A bit weird but temporary until we remove this deprecated provider. Mainly to benefit from the enableDracoLoader and enableKtx2Loader
+// methods.
+import { itownsGLTFLoader } from "../Layer/OGC3DTilesLayer.js";
 const utf8Decoder = new TextDecoder();
 function b3dmToMesh(data, layer, url) {
   const urlBase = THREE.LoaderUtils.extractUrlBase(url);
@@ -28,17 +30,17 @@ function b3dmToMesh(data, layer, url) {
 }
 function gltfToMesh(data, layer, url) {
   const urlBase = THREE.LoaderUtils.extractUrlBase(url);
-  return GLTFParser.parse(data, urlBase).then(result => ({
+  return itownsGLTFLoader.parseAsync(data, urlBase).then(result => ({
     object3d: result.scene
   }));
 }
 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