@xeokit/xeokit-sdk 2.6.111 → 2.6.112

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xeokit/xeokit-sdk",
-  "version": "2.6.111",
+  "version": "2.6.112",
   "description": "3D BIM IFC Viewer SDK for AEC engineering applications. Open Source JavaScript Toolkit based on pure WebGL for top performance, real-world coordinates and full double precision",
   "module": "./dist/xeokit-sdk.es.js",
   "main": "./dist/xeokit-sdk.cjs.js",

package/src/plugins/GLTFLoaderPlugin/GLTFLoaderPlugin.js

@@ -323,6 +323,9 @@ class GLTFLoaderPlugin extends Plugin {
      * @param {Boolean} [params.globalizeObjectIds=false] Indicates whether to globalize each {@link Entity#id} and {@link MetaObject#id}, in case you need to prevent ID clashes with other models.
      * @param {*} [params.parseOptions={}] Options to pass to loaders.gl parse method, eg. ````{ gltf: { excludeExtensions: { "KHR_texture_transform": false } } }````.
      * @param {Boolean} [params.entityPerMesh=false] Create an entity for each mesh, instead of grouping leaf meshes under their common entity.
+     * @param {*} [params.loadersGl={core,gltf}] Alternative user-provided loaders.gl library.
+     * This feature has been tested with loaders.gl 4.3.4 version.
+     * Because loaders.gl is supplied externally, xeokit cannot guarantee compatibility with all loaders.gl versions.
      * @returns {Entity} Entity representing the model, which will have {@link Entity#isModel} set ````true```` and will be registered by {@link Entity#id} in {@link Scene#models}
      */
     load(params = {}) {

package/src/plugins/GLTFLoaderPlugin/GLTFSceneModelLoader.js

@@ -108,11 +108,12 @@ function getBasePath(src) {
 function parseGLTF(plugin, src, gltf, metaModelJSON, options, sceneModel, ok, error) {
     const spinner = plugin.viewer.scene.canvas.spinner;
     spinner.processes++;
-    parse(gltf, GLTFLoader, {
+    const loadersGl = options.loadersGl;
+    (loadersGl ? loadersGl.core.parse : parse)(gltf, loadersGl ? loadersGl.gltf.GLTFLoader : GLTFLoader, {
         ...(options.parseOptions || { }),
         baseUri: options.basePath
     }).then((gltfData) => {
-        const processedGLTF = postProcessGLTF(gltfData);
+        const processedGLTF = (loadersGl ? loadersGl.gltf.postProcessGLTF : postProcessGLTF)(gltfData);
         const ctx = {
             src: src,
             entityId: options.entityId,

package/src/plugins/ViewCullPlugin/ViewCullPlugin.js

@@ -134,6 +134,9 @@ class ViewCullPlugin extends Plugin {
         if (cullDirty) {
             const kdNode = this._kdRoot;
             if (kdNode) {
+                for (let objectIdx = 0, len = this._objectCullStates.numObjects; objectIdx < len; objectIdx++) {
+                    this._objectCullStates.setObjectViewCulled(objectIdx, false);
+                }
                 this._visitKDNode(kdNode);
             }
         }

package/src/plugins/XKTLoaderPlugin/XKTLoaderPlugin.js

@@ -610,7 +610,7 @@ class XKTLoaderPlugin extends Plugin {
      * @param {String[]} [cfg.includeTypes] When loading metadata, only loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list.
      * @param {String[]} [cfg.excludeTypes] When loading metadata, never loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list.
      * @param {Boolean} [cfg.excludeUnclassifiedObjects=false] When loading metadata and this is ````true````, will only load {@link Entity}s that have {@link MetaObject}s (that are not excluded). This is useful when we don't want Entitys in the Scene that are not represented within IFC navigation components, such as {@link TreeViewPlugin}.
-     * @param {Boolean} [cfg.reuseGeometries=true] Indicates whether to enable geometry reuse (````true```` by default) or whether to internally expand
+     * @param {Boolean|Function} [cfg.reuseGeometries=true] Indicates whether to enable geometry reuse (````true```` by default) or whether to internally expand, a function will be called with a `{ instanceCount: <number> }` argument.
      * all geometry instances into batches (````false````), and not use instancing to render them. Setting this ````false```` can significantly
      * improve Viewer performance for models that have a lot of geometry reuse, but may also increase the amount of
      * browser and GPU memory they require. See [#769](https://github.com/xeokit/xeokit-sdk/issues/769) for more info.
@@ -878,7 +878,7 @@ class XKTLoaderPlugin extends Plugin {
      * @type {Boolean}
      */
     set reuseGeometries(value) {
-        this._reuseGeometries = value !== false;
+        this._reuseGeometries = value;
     }
 
     /**
@@ -920,9 +920,9 @@ class XKTLoaderPlugin extends Plugin {
      * Viewer will hide backfaces on watertight meshes, show backfaces on open meshes, and always show backfaces on meshes when we slice them open with {@link SectionPlane}s.
      * @param {Boolean} [params.excludeUnclassifiedObjects=false] When loading metadata and this is ````true````, will only load {@link Entity}s that have {@link MetaObject}s (that are not excluded). This is useful when we don't want Entitys in the Scene that are not represented within IFC navigation components, such as {@link TreeViewPlugin}.
      * @param {Boolean} [params.globalizeObjectIds=false] Indicates whether to globalize each {@link Entity#id} and {@link MetaObject#id}, in case you need to prevent ID clashes with other models. See {@link XKTLoaderPlugin#globalizeObjectIds} for more info.
-     * @param {Boolean} [params.reuseGeometries=true] Indicates whether to enable geometry reuse (````true```` by default) or whether to expand
-     * all geometry instances into batches (````false````), and not use instancing to render them. Setting this ````false```` can significantly
-     * improve Viewer performance for models that have excessive geometry reuse, but may also increases the amount of
+     * @param {Boolean|Function} [params.reuseGeometries=true] Indicates whether to enable geometry reuse (````true```` by default) or whether to expand
+     * all geometry instances into batches (````false````), and not use instancing to render them. A function will be called with a `{ instanceCount: <number> }` argument. Setting this ````false```` can significantly
+     * improve Viewer performance for models that have excessive geometry reuse, but may also increase the amount of
      * browser and GPU memory used by the model. See [#769](https://github.com/xeokit/xeokit-sdk/issues/769) for more info.
      * @param {Boolean} [params.dtxEnabled=true] When ````true```` (default) use data textures (DTX), where appropriate, to
      * represent the returned model. Set false to always use vertex buffer objects (VBOs). Note that DTX is only applicable
@@ -949,7 +949,8 @@ class XKTLoaderPlugin extends Plugin {
         const includeIds = params.includeIds || this._includeIds;
         const objectDefaults = params.objectDefaults || this._objectDefaults;
 
-        options.reuseGeometries = (params.reuseGeometries !== null && params.reuseGeometries !== undefined) ? params.reuseGeometries : (this._reuseGeometries !== false);
+        const reuseGeometries = params.reuseGeometries ?? this._reuseGeometries;
+        options.reuseGeometries = (typeof reuseGeometries !== "function") ? (() => reuseGeometries) : reuseGeometries;
 
         if (includeTypes) {
             options.includeTypesMap = {};

package/src/plugins/XKTLoaderPlugin/parsers/ParserV10.js

@@ -391,7 +391,7 @@ function load(viewer, options, inflatedData, sceneModel, metaModel, manifestCtx)
 
                     if (!geometryArrays) {
                         geometryArrays = {
-                            batchThisMesh: (!options.reuseGeometries)
+                            batchThisMesh: (!options.reuseGeometries({ instanceCount: geometryReuseCount }))
                         };
                         const primitiveType = eachGeometryPrimitiveType[geometryIndex];
                         let geometryValid = false;

package/src/plugins/XKTLoaderPlugin/parsers/ParserV11.js

@@ -384,7 +384,7 @@ function load(viewer, options, inflatedData, sceneModel, metaModel, manifestCtx)
 
                     if (!geometryArrays) {
                         geometryArrays = {
-                            batchThisMesh: (!options.reuseGeometries)
+                            batchThisMesh: (!options.reuseGeometries({ instanceCount: geometryReuseCount }))
                         };
                         const primitiveType = eachGeometryPrimitiveType[geometryIndex];
                         let geometryValid = false;

package/src/plugins/XKTLoaderPlugin/parsers/ParserV12.js

@@ -469,7 +469,7 @@ function load(viewer, options, inflatedData, sceneModel, metaModel, manifestCtx)
 
                     if (!geometryArrays) {
                         geometryArrays = {
-                            batchThisMesh: (!options.reuseGeometries)
+                            batchThisMesh: (!options.reuseGeometries({ instanceCount: geometryReuseCount }))
                         };
                         const primitiveType = eachGeometryPrimitiveType[geometryIndex];
                         const axisLabel = eachGeometryAxisLabel[geometryIndex];

package/src/plugins/XKTLoaderPlugin/parsers/ParserV8.js

@@ -341,7 +341,7 @@ function load(viewer, options, inflatedData, sceneModel, metaModel, manifestCtx)
                     if (!geometryArrays) {
 
                         geometryArrays = {
-                            batchThisMesh: (!options.reuseGeometries)
+                            batchThisMesh: (!options.reuseGeometries({ instanceCount: geometryReuseCount }))
                         };
 
                         const primitiveType = eachGeometryPrimitiveType[geometryIndex];

package/src/plugins/XKTLoaderPlugin/parsers/ParserV9.js

@@ -297,7 +297,7 @@ function load(viewer, options, inflatedData, sceneModel, metaModel, manifestCtx)
 
                     if (!geometryArrays) {
                         geometryArrays = {
-                            batchThisMesh: (!options.reuseGeometries)
+                            batchThisMesh: (!options.reuseGeometries({ instanceCount: geometryReuseCount }))
                         };
                         const primitiveType = eachGeometryPrimitiveType[geometryIndex];
                         let geometryValid = false;