@xeokit/xeokit-sdk 2.4.2-beta-29 → 2.4.2-beta-31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xeokit/xeokit-sdk",
-  "version": "2.4.2-beta-29",
+  "version": "2.4.2-beta-31",
   "description": "Web Programming Toolkit for 3D/2D BIM and AEC Graphics",
   "module": "./dist/xeokit-sdk.es.js",
   "main": "./dist/xeokit-sdk.cjs.js",

package/src/plugins/BCFViewpointsPlugin/BCFViewpointsPlugin.js

@@ -316,29 +316,11 @@ class BCFViewpointsPlugin extends Plugin {
      * @param {String} [cfg.id="BCFViewpoints"] Optional ID for this plugin, so that we can find it within {@link Viewer#plugins}.
      * @param {String} [cfg.originatingSystem] Identifies the originating system for BCF records.
      * @param {String} [cfg.authoringTool] Identifies the authoring tool for BCF records.
-     * @param {Boolean} [cfg.xrayAsZeroAlpha=false] Specifies how xeokit's X-ray emphasis effect is handled in BCF viewpoints. See {@link BCFViewpointsPlugin#xrayAsZeroAlpha} for details.
      */
     constructor(viewer, cfg = {}) {
 
         super("BCFViewpoints", viewer, cfg);
 
-        /**
-         * Specifies how xeokit's X-ray emphasis effect is handled in BCF viewpoints.
-         *
-         * When `xrayAsZeroAlpha` is `true`:
-         *
-         * * when saving a viewpoint, set the `A` channel of each `coloring` component to `0` for each X-rayed object, and
-         * * when loading a viewpoint saved from a xeokit application (i.e. when the viewpoint's `originating_system == "xeokit.io"`), set an object X-rayed if the `A` channel of its corresponding `coloring` component equals `0`
-         *
-         * When `xrayAsZeroAlpha` is `false`:
-         *
-         * * don't save any X-ray information in viewpoints, and
-         * * reset all objects as not X-rayed whenever loading a viewpoint.
-         *
-         * @type {boolean}
-         */
-        this.xrayAsZeroAlpha = !!cfg.xrayAsZeroAlpha;
-
         /**
          * Identifies the originating system to include in BCF viewpoints saved by this plugin.
          * @property originatingSystem
@@ -363,6 +345,9 @@ class BCFViewpointsPlugin extends Plugin {
      * @param {Boolean} [options.spacesVisible=false] Indicates whether ````IfcSpace```` types should be forced visible in the viewpoint.
      * @param {Boolean} [options.openingsVisible=false] Indicates whether ````IfcOpening```` types should be forced visible in the viewpoint.
      * @param {Boolean} [options.spaceBoundariesVisible=false] Indicates whether the boundaries of ````IfcSpace```` types should be visible in the viewpoint.
+     * @param {Boolean} [options.spacesTranslucent=false] Indicates whether ````IfcSpace```` types should be forced translucent in the viewpoint.
+     * @param {Boolean} [options.spaceBoundariesTranslucent=false] Indicates whether the boundaries of ````IfcSpace```` types should be forced translucent in the viewpoint.
+     * @param {Boolean} [options.openingsTranslucent=true] Indicates whether ````IfcOpening```` types should be forced translucent in the viewpoint.
      * @param {Boolean} [options.snapshot=true] Indicates whether the snapshot should be included in the viewpoint.
      * @param {Boolean} [options.defaultInvisible=false] When ````true````, will save the default visibility of all objects
      * as ````false````. This means that when we load the viewpoint again, and there are additional models loaded that
@@ -510,7 +495,10 @@ class BCFViewpointsPlugin extends Plugin {
                 view_setup_hints: {
                     spaces_visible: !!options.spacesVisible,
                     space_boundaries_visible: !!options.spaceBoundariesVisible,
-                    openings_visible: !!options.openingsVisible
+                    openings_visible: !!options.openingsVisible,
+                    spaces_translucent: !!options.spaces_translucent,
+                    space_boundaries_translucent: !!options.space_boundaries_translucent,
+                    openings_translucent: !!options.openings_translucent
                 }
             }
         };
@@ -527,15 +515,11 @@ class BCFViewpointsPlugin extends Plugin {
                 let alpha;
 
                 if (entity.xrayed) {
-                    if (this.xrayAsZeroAlpha) {
-                        alpha = 0;
+                    if (scene.xrayMaterial.fillAlpha === 0.0 && scene.xrayMaterial.edgeAlpha !== 0.0) {
+                        // BCF can't deal with edges. If xRay is implemented only with edges, set an arbitrary opacity
+                        alpha = 0.1;
                     } else {
-                        if (scene.xrayMaterial.fillAlpha === 0.0 && scene.xrayMaterial.edgeAlpha !== 0.0) {
-                            // BCF can't deal with edges. If xRay is implemented only with edges, set an arbitrary opacity
-                            alpha = 0.1;
-                        } else {
-                            alpha = scene.xrayMaterial.fillAlpha;
-                        }
+                        alpha = scene.xrayMaterial.fillAlpha;
                     }
                     alpha = Math.round(alpha * 255).toString(16).padStart(2, "0");
                     color = alpha + color;
@@ -586,6 +570,8 @@ class BCFViewpointsPlugin extends Plugin {
 
         bcfViewpoint.components.selection = this._createBCFComponents(selectedObjectIds);
 
+        bcfViewpoint.components.translucency = this._createBCFComponents(scene.xrayedObjectIds);
+
         if (options.snapshot !== false) {
             bcfViewpoint.snapshot = {
                 snapshot_type: "png",
@@ -771,13 +757,22 @@ class BCFViewpointsPlugin extends Plugin {
                 const view_setup_hints = bcfViewpoint.components.visibility.view_setup_hints;
                 if (view_setup_hints) {
                     if (view_setup_hints.spaces_visible === false) {
-                        scene.setObjectsVisible(viewer.metaScene.getObjectIDsByType("IfcSpace"), false);
+                        scene.setObjectsVisible(viewer.metaScene.getObjectIDsByType("IfcSpace"), true);
                     }
-                    if (view_setup_hints.openings_visible === false) {
-                        scene.setObjectsVisible(viewer.metaScene.getObjectIDsByType("IfcOpening"), false);
+                    if (view_setup_hints.spaces_translucent !== undefined) {
+                        scene.setObjectsXRayed(viewer.metaScene.getObjectIDsByType("IfcSpace"), true);
                     }
                     if (view_setup_hints.space_boundaries_visible !== undefined) {
-                        // TODO: Ability to show boundaries
+
+                    }
+                    if (view_setup_hints.openings_visible === false) {
+                        scene.setObjectsVisible(viewer.metaScene.getObjectIDsByType("IfcOpening"), true);
+                    }
+                    if (view_setup_hints.space_boundaries_translucent !== undefined) {
+
+                    }
+                    if (view_setup_hints.openings_translucent !== undefined) {
+                        scene.setObjectsXRayed(viewer.metaScene.getObjectIDsByType("IfcOpening"), true);
                     }
                 }
             }
@@ -788,6 +783,11 @@ class BCFViewpointsPlugin extends Plugin {
 
             }
 
+            if (bcfViewpoint.components.translucency) {
+                scene.setObjectsXRayed(scene.xrayedObjectIds, false);
+                bcfViewpoint.components.translucency.forEach(component => this._withBCFComponent(options, component, entity => entity.xrayed = true));
+            }
+
             if (bcfViewpoint.components.coloring) {
                 bcfViewpoint.components.coloring.forEach(coloring => {
 
@@ -814,16 +814,7 @@ class BCFViewpointsPlugin extends Plugin {
                         this._withBCFComponent(options, component, entity => {
                             entity.colorize = colorize;
                             if (alphaDefined) {
-                                if (alpha === 0 && this.xrayAsZeroAlpha) {
-                                    const savedFromXeokit = (component.originating_system === this.originatingSystem);
-                                    if (savedFromXeokit) {
-                                        entity.xrayed = true;
-                                    } else {
-                                        entity.opacity = alpha;
-                                    }
-                                } else {
-                                    entity.opacity = alpha;
-                                }
+                                entity.opacity = alpha;
                             }
                         }));
                 });

package/src/plugins/XKTLoaderPlugin/XKTLoaderPlugin.js

@@ -431,6 +431,15 @@ parsers[ParserV10.version] = ParserV10;
  * myViewer.scene.setObjectVisibilities("myModel1#0BTBFw6f90Nfh9rP1dlXrb", true);
  *````
  *
+ * We can also provide an HTTP URL to the XKT file:
+ *
+ * ````javascript
+ * const sceneModel = xktLoader.load({
+ *   manifestSrc: "https://xeokit.github.io/xeokit-sdk/assets/models/models/xkt/Schependomlaan.xkt",
+ *   id: "myModel",
+ * });
+ * ````
+ *
  * # Loading a model from a manifest of XKT files
  *
  * The `ifc2gltf` tool from Creoox, which converts IFC files into glTF geometry and JSON metadata files, has the option to
@@ -517,6 +526,65 @@ parsers[ParserV10.version] = ParserV10;
  * They work much reliably (and faster) when processing smaller files (eg. 20MB) than when processing large files (eg. 500MB), where
  * they have less trouble allocating the system memory they need for conversion and parsing.
  *
+ * We can also provide an HTTP URL to the manifest:
+ *
+ * ````javascript
+ * const sceneModel = xktLoader.load({
+ *   manifestSrc: "https://xeokit.github.io/xeokit-sdk/assets/models/xkt/v10/split/Karhumaki-Bridge/model.xkt.manifest.json",
+ *   id: "myModel",
+ * });
+ * ````
+ *
+ * We can also provide the manifest as parameter object:
+ *
+ * ````javascript
+ * const sceneModel = xktLoader.load({
+ *   id: "myModel",
+ *   manifest: {
+ *   inputFile: "assets/models/gltf/Karhumaki/model.glb.manifest.json",
+ *   converterApplication: "convert2xkt",
+ *   converterApplicationVersion: "v1.1.10",
+ *   conversionDate": "09-11-2023- 18-29-01",
+ *     xktFiles: [
+ *       "../../assets/models/xkt/v10/split/Karhumaki-Bridge/model.xkt",
+ *       "../../assets/models/xkt/v10/split/Karhumaki-Bridge/model_1.xkt",
+ *       "../../assets/models/xkt/v10/split/Karhumaki-Bridge/model_2.xkt",
+ *       "../../assets/models/xkt/v10/split/Karhumaki-Bridge/model_3.xkt",
+ *       "../../assets/models/xkt/v10/split/Karhumaki-Bridge/model_4.xkt",
+ *       "../../assets/models/xkt/v10/split/Karhumaki-Bridge/model_5.xkt",
+ *       "../../assets/models/xkt/v10/split/Karhumaki-Bridge/model_6.xkt",
+ *       "../../assets/models/xkt/v10/split/Karhumaki-Bridge/model_7.xkt",
+ *       "../../assets/models/xkt/v10/split/Karhumaki-Bridge/model_8.xkt"
+ *     ]
+ *   }
+ * });
+ * ````
+ *
+ * We can also provide the paths to the XKT files as HTTP URLs:
+ *
+ * ````javascript
+ * const sceneModel = xktLoader.load({
+ *   id: "myModel",
+ *   manifest: {
+ *   inputFile: "assets/models/gltf/Karhumaki/model.glb.manifest.json",
+ *   converterApplication: "convert2xkt",
+ *   converterApplicationVersion: "v1.1.10",
+ *   conversionDate": "09-11-2023- 18-29-01",
+ *     xktFiles: [
+ *       "https://xeokit.github.io/xeokit-sdk/assets/models/xkt/v10/split/Karhumaki-Bridge/model.xkt",
+ *       "https://xeokit.github.io/xeokit-sdk/assets/models/xkt/v10/split/Karhumaki-Bridge/model_1.xkt",
+ *       "https://xeokit.github.io/xeokit-sdk/assets/models/xkt/v10/split/Karhumaki-Bridge/model_2.xkt",
+ *       "https://xeokit.github.io/xeokit-sdk/assets/models/xkt/v10/split/Karhumaki-Bridge/model_3.xkt",
+ *       "https://xeokit.github.io/xeokit-sdk/assets/models/xkt/v10/split/Karhumaki-Bridge/model_4.xkt",
+ *       "https://xeokit.github.io/xeokit-sdk/assets/models/xkt/v10/split/Karhumaki-Bridge/model_5.xkt",
+ *       "https://xeokit.github.io/xeokit-sdk/assets/models/xkt/v10/split/Karhumaki-Bridge/model_6.xkt",
+ *       "https://xeokit.github.io/xeokit-sdk/assets/models/xkt/v10/split/Karhumaki-Bridge/model_7.xkt",
+ *       "https://xeokit.github.io/xeokit-sdk/assets/models/xkt/v10/split/Karhumaki-Bridge/model_8.xkt"
+ *     ]
+ *   }
+ * });
+ * ````
+ *
  * @class XKTLoaderPlugin
  */
 class XKTLoaderPlugin extends Plugin {
@@ -786,10 +854,14 @@ class XKTLoaderPlugin extends Plugin {
      *
      * @param {*} params Loading parameters.
      * @param {String} [params.id] ID to assign to the root {@link Entity#id}, unique among all components in the Viewer's {@link Scene}, generated automatically by default.
-     * @param {String} [params.src] Path to a *````.xkt````* file, as an alternative to the ````xkt```` parameter.
+     * @param {String} [params.src] Path or URL to an *````.xkt````* file, as an alternative to the ````xkt```` parameter.
      * @param {ArrayBuffer} [params.xkt] The *````.xkt````* file data, as an alternative to the ````src```` parameter.
-     * @param {String} [params.metaModelSrc] Path to an optional metadata file, as an alternative to the ````metaModelData```` parameter.
+     * @param {String} [params.metaModelSrc] Path or URL to an optional metadata file, as an alternative to the ````metaModelData```` parameter.
      * @param {*} [params.metaModelData] JSON model metadata, as an alternative to the ````metaModelSrc```` parameter.
+     * @param {String} [params.manifestSrc] Path or URL to a JSON manifest file that provides paths to ````.xkt```` files to load as parts of the model. Use this option to load models that have been split into
+     * multiple XKT files. See [tutorial](https://www.notion.so/xeokit/Automatically-Splitting-Large-Models-for-Better-Performance-165fc022e94742cf966ee50003572259) for more info.
+     * @param {Object} [params.manifest] A JSON manifest object (as an alternative to a path or URL) that provides paths to ````.xkt```` files to load as parts of the model. Use this option to load models that have been split into
+     * multiple XKT files. See [tutorial](https://www.notion.so/xeokit/Automatically-Splitting-Large-Models-for-Better-Performance-165fc022e94742cf966ee50003572259) for more info.
      * @param {{String:Object}} [params.objectDefaults] Map of initial default states for each loaded {@link Entity} that represents an object. Default value is {@link IFCObjectDefaults}.
      * @param {String[]} [params.includeTypes] When loading metadata, only loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list.
      * @param {String[]} [params.excludeTypes] When loading metadata, never loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list.
@@ -825,8 +897,8 @@ class XKTLoaderPlugin extends Plugin {
             delete params.id;
         }
 
-        if (!params.src && !params.xkt && !params.manifestSrc) {
-            this.error("load() param expected: src, xkt or manifestSrc");
+        if (!params.src && !params.xkt && !params.manifestSrc && !params.manifest) {
+            this.error("load() param expected: src, xkt, manifestSrc or manifestData");
             return sceneModel; // Return new empty model
         }
 
@@ -954,8 +1026,8 @@ class XKTLoaderPlugin extends Plugin {
             } else if (params.xkt) {
                 this._parseModel(params.xkt, params, options, sceneModel, metaModel, manifestCtx);
                 finish();
-            } else if (params.manifestSrc) {
-                const baseDir = getBaseDirectory(params.manifestSrc)
+            } else if (params.manifestSrc || params.manifest) {
+                const baseDir = params.manifestSrc ? getBaseDirectory(params.manifestSrc) : "";
                 const loadJSONs = (metaDataFiles, done, error) => {
                     let i = 0;
                     const loadNext = () => {
@@ -975,7 +1047,6 @@ class XKTLoaderPlugin extends Plugin {
                     }
                     loadNext();
                 }
-
                 const loadXKTs = (xktFiles, done, error) => {
                     let i = 0;
                     const loadNext = () => {
@@ -991,11 +1062,8 @@ class XKTLoaderPlugin extends Plugin {
                     }
                     loadNext();
                 };
-
-                this._dataSource.getManifest(params.manifestSrc, (manifestData) => {
-                    if (sceneModel.destroyed) {
-                        return;
-                    }
+                if (params.manifest) {
+                    const manifestData = params.manifest;
                     const xktFiles = manifestData.xktFiles;
                     if (!xktFiles || xktFiles.length === 0) {
                         error(`load(): Failed to load model manifest - manifest not valid`);
@@ -1009,7 +1077,26 @@ class XKTLoaderPlugin extends Plugin {
                     } else {
                         loadXKTs(xktFiles, finish, error);
                     }
-                }, error);
+                } else {
+                    this._dataSource.getManifest(params.manifestSrc, (manifestData) => {
+                        if (sceneModel.destroyed) {
+                            return;
+                        }
+                        const xktFiles = manifestData.xktFiles;
+                        if (!xktFiles || xktFiles.length === 0) {
+                            error(`load(): Failed to load model manifest - manifest not valid`);
+                            return;
+                        }
+                        const metaModelFiles = manifestData.metaModelFiles;
+                        if (metaModelFiles) {
+                            loadJSONs(metaModelFiles, () => {
+                                loadXKTs(xktFiles, finish, error);
+                            }, error);
+                        } else {
+                            loadXKTs(xktFiles, finish, error);
+                        }
+                    }, error);
+                }
             }
         }
 

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

@@ -2654,7 +2654,7 @@ class Scene extends Component {
      * - it runs maximum once per scene-tick
      *
      * @param {Function} cb The function to tickify
-     * @returns {Function)}
+     * @returns {Function}
      */
     tickify(cb) {
         const cbString = cb.toString();