@xeokit/xeokit-sdk 2.6.111 → 2.6.113

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xeokit/xeokit-sdk",
-  "version": "2.6.111",
+  "version": "2.6.113",
   "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;

package/src/viewer/scene/model/layer/Layer.js

@@ -338,7 +338,7 @@ export const getRenderers = (function() {
             if (primitive === "points") {
                 cache[sceneId] = {
                     colorRenderers:     { "sao-": { "vertex": lazy((vars, geo, c) => c(makeColorProgram(vars, geo, null, null))) } },
-                    occlusionRenderer:  lazy((vars, geo, c) => c(OcclusionProgram(vars, scene.logarithmicDepthBufferEnabled))),
+                    occlusionRenderer:  lazy((vars, geo, c) => c(OcclusionProgram(vars))),
                     pickDepthRenderer:  lazy(makePickDepthProgram),
                     pickMeshRenderer:   lazy(makePickMeshProgram),
                     // VBOBatchingPointsShadowRenderer has been implemented by 14e973df6268369b00baef60e468939e062ac320,
@@ -400,7 +400,7 @@ export const getRenderers = (function() {
                         uniform: lazy((vars, geo, c) => c(EdgesProgram(vars, geo, scene.logarithmicDepthBufferEnabled, true)),  { vertices: false }),
                         vertex:  lazy((vars, geo, c) => c(EdgesProgram(vars, geo, scene.logarithmicDepthBufferEnabled, false)), { vertices: false })
                     },
-                    occlusionRenderer:       lazy((vars, geo, c) => c(OcclusionProgram(vars, scene.logarithmicDepthBufferEnabled))),
+                    occlusionRenderer:       lazy((vars, geo, c) => c(OcclusionProgram(vars))),
                     pickDepthRenderer:       eager(makePickDepthProgram),
                     pickMeshRenderer:        eager(makePickMeshProgram),
                     pickNormalsFlatRenderer: eager((vars, geo, c) => makePickNormalsProgram(vars, geo, c, true)),

package/src/viewer/scene/model/layer/programs/OcclusionProgram.js

@@ -1,11 +1,7 @@
-export const OcclusionProgram = function(programVariables, logarithmicDepthBufferEnabled) {
+export const OcclusionProgram = function(programVariables) {
     const outColor = programVariables.createOutput("vec4", "outColor");
     return {
         programName: "Occlusion",
-        // Logarithmic depth buffer involves an accuracy tradeoff, sacrificing
-        // accuracy at close range to improve accuracy at long range. This can
-        // mess up accuracy for occlusion tests, so we'll disable for now.
-        getLogDepth: false && logarithmicDepthBufferEnabled && (vFragDepth => vFragDepth),
         renderPassFlag: 0,  // COLOR_OPAQUE // Only opaque objects can be occluders
         appendFragmentOutputs: (src) => src.push(`${outColor} = vec4(0.0, 0.0, 1.0, 1.0);`) // Occluders are blue
     };

package/src/viewer/scene/scene/Scene.js

@@ -636,6 +636,8 @@ class Scene extends Component {
             alphaDepthMask: alphaDepthMask
         });
 
+        this.canvas._renderer = this._renderer;
+
         this._sectionPlanesState = new (function () {
 
             this.sectionPlanes = [];

package/src/viewer/scene/sectionPlane/SectionPlaneCache.js

@@ -1,6 +1,6 @@
 import {Component} from '../Component.js';
 import {math} from "../math/math.js";
-import {SectionPlane} from "./SectionPlane";
+import {SectionPlane} from "./SectionPlane.js";
 
 const tempVec3a = math.vec3();
 

package/src/viewer/scene/webgl/occlusion/OcclusionTester.js

@@ -132,13 +132,12 @@ export class OcclusionTester {
                 "OcclusionTester",
                 {
                     sectionPlanesState: sectionPlanesState,
-                    getLogDepth: scene.logarithmicDepthBufferEnabled && (vFragDepth => vFragDepth),
                     clippableTest: () => "true",
                     getVertexData: () => {
                         const src = [ ];
                         src.push(`vec4 worldPosition = vec4(${position}, 1.0);`);
                         src.push(`vec4 ${clipPos} = ${projMatrix} * ${viewMatrix} * worldPosition;`);
-                        if ((! scene.logarithmicDepthBufferEnabled) && (scene.markerZOffset < 0.000)) {
+                        if (scene.markerZOffset < 0.000) {
                             src.push(`${clipPos}.z += ${scene.markerZOffset};`);
                         }
                         return src;

package/types/plugins/GLTFLoaderPlugin/GLTFLoaderPlugin.d.ts

@@ -87,6 +87,20 @@ export declare type LoadGLTFModel = {
   parseOptions?: any;
   /** Create an entity for each mesh, instead of grouping leaf meshes under their common entity. */
   entityPerMesh?: boolean;
+  /**
+   * 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.
+   */
+  loadersGl?: {
+    core: {
+      parse: (...args: any[]) => any;
+    };
+    gltf: {
+      GLTFLoader: any;
+      postProcessGLTF: (...args: any[]) => any;
+    };
+  };
 };
 
 /**

package/types/plugins/XKTLoaderPlugin/XKTLoaderPlugin.d.ts

@@ -1,5 +1,9 @@
 import {IFCObjectDefaults, Plugin, VBOSceneModel, Viewer} from "../../viewer";
 
+type ReuseGeometries =
+    | boolean
+    | ((geometryConfig: { instanceCount: number }) => boolean);
+
 export declare type XKTLoaderPluginConfiguration = {
     /** Optional ID for this plugin, so that we can find it within {@link Viewer.plugins}. */
     id?: string;
@@ -16,7 +20,7 @@ export declare type XKTLoaderPluginConfiguration = {
     /** 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}. */
     excludeUnclassifiedObjects?: boolean;
     /** Indicates whether to enable geometry reuse */
-    reuseGeometries?: boolean;
+    reuseGeometries?: ReuseGeometries;
     /** Maximum geometry batch size, as number of vertices. */
     maxGeometryBatchSize?: number;
 };
@@ -74,7 +78,7 @@ export declare type LoadXKTModel = {
      * 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
      * browser and GPU memory used by the model. See [#769](https://github.com/xeokit/xeokit-sdk/issues/769) for more info. */
-    reuseGeometries?: boolean;
+    reuseGeometries?: ReuseGeometries;
     /** 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
      * to non-textured triangle meshes, and that VBOs are always used for meshes that have textures, line segments, or point
@@ -267,7 +271,7 @@ export declare class XKTLoaderPlugin extends Plugin {
      *
      * @type {Boolean}
      */
-    set reuseGeometries(arg: boolean);
+    set reuseGeometries(arg: ReuseGeometries);
 
     /**
      * Gets whether XKTLoaderPlugin enables geometry reuse when loading models.
@@ -276,7 +280,7 @@ export declare class XKTLoaderPlugin extends Plugin {
      *
      * @type {Boolean}
      */
-    get reuseGeometries(): boolean;
+    get reuseGeometries(): ReuseGeometries;
 
     /**
      * Gets the ````.xkt```` format versions supported by this XKTLoaderPlugin/

package/types/viewer/metadata/MetaModel.d.ts

@@ -61,14 +61,24 @@ export declare class MetaModel {
   /**
    * The {@link PropertySet}s in this MetaModel.
    */
-  propertySets: {
-    String: PropertySet;
-  };
+  propertySets: PropertySet[];
 
   /**
    * The root {@link MetaObject} in this MetaModel's composition structure hierarchy.
    */
-  rootMetaObject: MetaObject;
+  rootMetaObject: MetaObject | null;
+
+  /**
+   * The root {@link MetaObject}s in this MetaModel's composition structure hierarchy.
+   */
+  rootMetaObjects: MetaObject[];
+
+  /**
+   * The {@link MetaObject}s in this MetaModel, each mapped to its ID.
+   */
+  metaObjects: {
+      String: MetaObject;
+  };
 
   /**
    * Finalizes this MetaModel.