@xeokit/xeokit-sdk 2.4.0-alpha-39 → 2.4.0-alpha-40

package/dist/xeokit-sdk.cjs.js

@@ -33266,6 +33266,12 @@ class DataTextureSceneModel extends Component {
 
         this._edgeThreshold = cfg.edgeThreshold || 10;
 
+        /**
+         * True when this model has been finalized after a successful call to finalize().
+         * @type {boolean}
+         */
+        this.finalized = false;
+
         this.visible = cfg.visible;
         this.culled = cfg.culled;
         this.pickable = cfg.pickable;
@@ -34572,6 +34578,8 @@ class DataTextureSceneModel extends Component {
             const layer = this._layerList[i];
             layer.attachToRenderingEvent();
         }
+
+        this.finalized = true;
     }
 
     _rebuildAABB() {
@@ -96344,6 +96352,12 @@ class VBOSceneModel extends Component {
         /** @private **/
         this.renderFlags = new RenderFlags();
 
+        /**
+         * True when this model has been finalized after a successful call to finalize().
+         * @type {boolean}
+         */
+        this.finalized = false;
+
         /**
          * @private
          */
@@ -98161,6 +98175,8 @@ ${cfg.uv && cfg.uv.length > 0 ? 1 : 0}-${cfg.uvCompressed && cfg.uvCompressed.le
         this.glRedraw();
 
         this.scene._aabbDirty = true;
+
+        this.finalized = true;
     }
 
     _rebuildAABB() {
@@ -99339,13 +99355,17 @@ const getCanvasPosFromEvent$4 = function (event, canvasPos) {
         let element = event.target;
         let totalOffsetLeft = 0;
         let totalOffsetTop = 0;
+        let totalScrollX = 0;
+        let totalScrollY = 0;
         while (element.offsetParent) {
-            totalOffsetLeft += element.offsetLeft;
-            totalOffsetTop += element.offsetTop;
-            element = element.offsetParent;
+          totalOffsetLeft += element.offsetLeft;
+          totalOffsetTop += element.offsetTop;
+          totalScrollX += element.scrollLeft;
+          totalScrollY += element.scrollTop;
+          element = element.offsetParent;
         }
-        canvasPos[0] = event.pageX - totalOffsetLeft;
-        canvasPos[1] = event.pageY - totalOffsetTop;
+        canvasPos[0] = event.pageX + totalScrollX - totalOffsetLeft;
+        canvasPos[1] = event.pageY + totalScrollY - totalOffsetTop;
     }
     return canvasPos;
 };
@@ -102826,7 +102846,7 @@ class MetaModel {
     /**
      * @private
      */
-    constructor(metaScene, id, projectId, revisionId, author, createdAt, creatingApplication, schema, propertySets) {
+    constructor(params) {
 
         /**
          * Globally-unique ID.
@@ -102838,14 +102858,14 @@ class MetaModel {
          * @property id
          * @type {String|Number}
          */
-        this.id = id;
+        this.id = params.id;
 
         /**
          * The project ID
          * @property projectId
          * @type {String|Number}
          */
-        this.projectId = projectId;
+        this.projectId = params.projectId;
 
         /**
          * The revision ID, if available.
@@ -102855,7 +102875,7 @@ class MetaModel {
          * @property revisionId
          * @type {String|Number}
          */
-        this.revisionId = revisionId;
+        this.revisionId = params.revisionId;
 
         /**
          * The model author, if available.
@@ -102865,7 +102885,7 @@ class MetaModel {
          * @property author
          * @type {String}
          */
-        this.author = author;
+        this.author = params.author;
 
         /**
          * The date the model was created, if available.
@@ -102875,7 +102895,7 @@ class MetaModel {
          * @property createdAt
          * @type {String}
          */
-        this.createdAt = createdAt;
+        this.createdAt = params.createdAt;
 
         /**
          * The application that created the model, if available.
@@ -102885,7 +102905,7 @@ class MetaModel {
          * @property creatingApplication
          * @type {String}
          */
-        this.creatingApplication = creatingApplication;
+        this.creatingApplication = params.creatingApplication;
 
         /**
          * The model schema version, if available.
@@ -102895,7 +102915,7 @@ class MetaModel {
          * @property schema
          * @type {String}
          */
-        this.schema = schema;
+        this.schema = params.schema;
 
         /**
          * Metadata on the {@link Scene}.
@@ -102903,15 +102923,15 @@ class MetaModel {
          * @property metaScene
          * @type {MetaScene}
          */
-        this.metaScene = metaScene;
+        this.metaScene = params.metaScene;
 
         /**
          * The {@link PropertySet}s in this MetaModel.
          *
          * @property propertySets
-         * @type {{String:PropertySet}}
+         * @type  {PropertySet[]}
          */
-        this.propertySets = propertySets;
+        this.propertySets = [];
 
         /**
          * The root {@link MetaObject} in this MetaModel's composition structure hierarchy.
@@ -102929,6 +102949,20 @@ class MetaModel {
          * @type {MetaObject[]}
          */
         this.rootMetaObjects = [];
+
+        /**
+         * The {@link MetaObject}s in this MetaModel, each mapped to its ID.
+         *
+         * @property metaObjects
+         * @type  {MetaObject[]}
+         */
+        this.metaObjects=[];
+
+        /**
+         * Connectivity graph.
+         * @type {{}}
+         */
+        this.graph = params.graph || {};
     }
 
     getJSON() {
@@ -102987,7 +103021,7 @@ class MetaObject {
     /**
      * @private
      */
-    constructor(metaModel, id, originalSystemId, name, type, propertySets, parent, children, external) {
+    constructor(params) {
 
         /**
          * Model metadata.
@@ -102996,13 +103030,13 @@ class MetaObject {
          * @type {MetaModel}
          * @deprecated
          */
-        this.metaModel = metaModel;
+        this.metaModel = null;
 
         /**
          * The MetaModels that share this MetaObject.
          * @type {MetaModel[]}
          */
-        this.metaModels = [metaModel];
+        this.metaModels = [];
 
         /**
          * Globally-unique ID.
@@ -103012,7 +103046,19 @@ class MetaObject {
          * @property id
          * @type {String|Number}
          */
-        this.id = id;
+        this.id = params.id;
+
+        /**
+         * ID of the parent MetaObject.
+         * @type {String|Number}
+         */
+        this.parentId = params.parentId;
+
+        /**
+         * The parent MetaObject.
+         * @type {MetaObject | null}
+         */
+        this.parent = null;
 
         /**
          * ID of the corresponding object within the originating system, if any.
@@ -103020,7 +103066,7 @@ class MetaObject {
          * @type {String}
          * @abstract
          */
-        this.originalSystemId = originalSystemId;
+        this.originalSystemId = params.originalSystemId;
 
         /**
          * Human-readable name.
@@ -103028,7 +103074,7 @@ class MetaObject {
          * @property name
          * @type {String}
          */
-        this.name = name;
+        this.name = params.name;
 
         /**
          * Type - often an IFC product type.
@@ -103036,7 +103082,7 @@ class MetaObject {
          * @property type
          * @type {String}
          */
-        this.type = type;
+        this.type = params.type;
 
         /**
          * Optional {@link PropertySet}s used by this MetaObject.
@@ -103044,46 +103090,20 @@ class MetaObject {
          * @property propertySets
          * @type {PropertySet[]}
          */
-        this.propertySets = propertySets;
-
-        if (parent !== undefined && parent !== null) {
-
-            /**
-             * The parent MetaObject within the structure hierarchy.
-             *
-             * Undefined when this is the root of its structure.
-             *
-             * @property parent
-             * @type {MetaObject}
-             */
-            this.parent = parent;
-        }
+        this.propertySets = [];
 
-        if (children !== undefined && children !== null) {
-
-            /**
-             * Child ObjectMeta instances within the structure hierarchy.
-             *
-             * Undefined when there are no children.
-             *
-             * @property children
-             * @type {Array}
-             */
-            this.children = children;
-        }
-
-        if (external !== undefined && external !== null) {
-
-            /**
-             * External application-specific metadata
-             *
-             * Undefined when there are is no external application-specific metadata.
-             *
-             * @property external
-             * @type {*}
-             */
-            this.external = external;
-        }
+        // if (external !== undefined && external !== null) {
+        //
+        //     /**
+        //      * External application-specific metadata
+        //      *
+        //      * Undefined when there are is no external application-specific metadata.
+        //      *
+        //      * @property external
+        //      * @type {*}
+        //      */
+        //     this.external = external;
+        // }
     }
 
     /**
@@ -103273,6 +103293,12 @@ class PropertySet {
          */
         this.originalSystemId = originalSystemId;
 
+        /**
+         * The MetaModels that share this PropertySet.
+         * @type {MetaModel[]}
+         */
+        this.metaModels = [];
+
         /**
          * Human-readable name of this PropertySet.
          *
@@ -103369,12 +103395,6 @@ class MetaScene {
          */
         this.rootMetaObjects = {};
 
-        /**
-         * Tracks number of MetaObjects of each type.
-         * @private
-         */
-        this._typeCounts = {};
-
         /**
          * Subscriptions to events sent with {@link fire}.
          * @private
@@ -103442,119 +103462,143 @@ class MetaScene {
      */
     createMetaModel(modelId, metaModelData, options = {}) {
 
-        const projectId = metaModelData.projectId || "none";
-        const revisionId = metaModelData.revisionId || "none";
-        const newPropertySets = metaModelData.propertySets || [];
-        const newObjects = metaModelData.metaObjects || [];
-        const author = metaModelData.author;
-        const createdAt = metaModelData.createdAt;
-        const creatingApplication = metaModelData.creatingApplication;
-        const schema = metaModelData.schema;
-        // if (options.excludeTypes) {
-        //     excludeTypes = {};
-        //     for (let i = 0, len = options.excludeTypes.length; i < len; i++) {
-        //         includeTypes[options.excludeTypes[i]] = true;
-        //     }
-        // }
+        this._globalizeIDs(modelId, metaModelData, options);
 
-        const metaModel = new MetaModel(this, modelId, projectId, revisionId, author, createdAt, creatingApplication, schema, [], null);
+        // Create MetaModel
+
+        const metaModel = new MetaModel({
+            metaScene: this,
+            id: modelId,
+            projectId: metaModelData.projectId || "none",
+            revisionId: metaModelData.revisionId || "none",
+            author: metaModelData.author || "none",
+            createdAt: metaModelData.createdAt || "none",
+            creatingApplication: metaModelData.creatingApplication || "none",
+            schema: metaModelData.schema || "none",
+            propertySets: []
+        });
 
         this.metaModels[modelId] = metaModel;
 
-        for (let i = 0, len = newPropertySets.length; i < len; i++) {
-            const propertySetCfg = newPropertySets[i];
-            const propertySetId = propertySetCfg.id;
-            const propertySet = new PropertySet(propertySetId, propertySetCfg.originalSystemId, propertySetCfg.name, propertySetCfg.type, propertySetCfg.properties);
-            metaModel.propertySets[propertySetId] = propertySet;
-            this.propertySets[propertySetId] = propertySet;
+        // Create global Property Sets
+
+        for (let i = 0, len = metaModelData.propertySets.length; i < len; i++) {
+            const propertySetData = metaModelData.propertySets[i];
+            let propertySet = this.propertySets[propertySetData.id];
+            if (!propertySet) {
+                propertySet = new PropertySet({
+                    id: propertySetData.id,
+                    originalSystemId: propertySetData.originalSystemId,
+                    type: propertySetData.type,
+                    name: propertySetData.name,
+                    properties: propertySetData.properties
+                });
+                this.propertySets[propertySet.id] = propertySet;
+            }
+            propertySet.metaModels.push(metaModel);
+            metaModel.propertySets.push(propertySet);
         }
 
-        const filteredObjectsParams = []; // Params for each new metaobject that passes our filters
-        const existingObjects = []; // List of our metaobjects that are already existing, to which we'll also append new metaobjects we'll create
-        const createObjectsParams = []; // List of params for metaobjects we'll create
-
-
-        // Filter out the parameters we'll create
+        // Create MetaObjects
+        // Don't re-create reused MetaObjects
+        // Save root MetaObjects on MetaModel
+        // Save root MetaObjects on MetaScene
 
-        for (let i = 0, len = newObjects.length; i < len; i++) {
-            const newObject = newObjects[i];
-            newObject.type;
-            filteredObjectsParams.push(newObject);
+        for (let i = 0, len = metaModelData.metaObjects.length; i < len; i++) {
+            const metaObjectData = metaModelData.metaObjects[i];
+            const type = metaObjectData.type;
+            const id = metaObjectData.id;
+            let metaObject = this.metaObjects[id];
+            if (!metaObject) {
+                metaObject = new MetaObject({
+                    id,
+                    parentId: metaObjectData.parent,
+                    type,
+                    name: metaObjectData.name,
+                    propertySetIds: metaObjectData.propertySetIds
+                });
+                this.metaObjects[id] = metaObject;
+            }
+            metaObject.metaModels.push(metaModel);
+            if (!metaObjectData.parent) {
+                metaModel.rootMetaObjects.push(metaObject);
+                this.rootMetaObjects[id] = metaObject;
+            }
+            metaModel.metaObjects.push(metaObject);
         }
 
-        // Build list of params for metaobjects we'll create
+        // Re-link entire MetaObject parent/child hierarchy
 
-        for (let i = 0, len = filteredObjectsParams.length; i < len; i++) {
-            let filteredObject = filteredObjectsParams[i];
-            const existingObject = this.metaObjects[filteredObject.id];
-            if (existingObject) {
-                existingObject.metaModels.push(metaModel);
-                existingObjects.push(existingObject);
-                continue;
+        for (let objectId in this.metaObjects) {
+            const metaObject = this.metaObjects[objectId];
+            if (metaObject.children) {
+                metaObject.children = [];
             }
-            createObjectsParams.push(filteredObject);
         }
 
-        // Create metaobjects in the creation list, add them to list of existing metaobjects
-
-        for (let i = 0, len = createObjectsParams.length; i < len; i++) {
-            const createObject = createObjectsParams[i];
-            const type = createObject.type;
-            const objectId = options.globalizeObjectIds ? math.globalizeObjectId(modelId, createObject.id) : createObject.id;
-            const originalSystemId = createObject.id;
-            const name = createObject.name;
-            const propertySets = [];
-            if (createObject.propertySetIds && createObject.propertySetIds.length > 0) {
-                for (let j = 0, lenj = createObject.propertySetIds.length; j < lenj; j++) {
-                    const propertySetId = createObject.propertySetIds[j];
-                    const propertySet = metaModel.propertySets[propertySetId];
-                    if (propertySet) {
-                        propertySets.push(propertySet);
-                    }
-                }
-            }
-            const parent = null;
-            const children = null;
-            const external = createObject.external;
-            const metaObject = new MetaObject(metaModel, objectId, originalSystemId, name, type, propertySets, parent, children, external);
-            metaObject._parentId = createObject.parent;
-            this.metaObjects[objectId] = metaObject;
-            (this.metaObjectsByType[type] || (this.metaObjectsByType[type] = {}))[objectId] = metaObject;
-            if (this._typeCounts[type] === undefined) {
-                this._typeCounts[type] = 1;
-            } else {
-                this._typeCounts[type]++;
-            }
-            existingObjects.push(metaObject);
-            if (createObject.parent === undefined || createObject.parent === null) ;
-        }
-
-        // Ensure that metaobjects in the existing metaobject list are all attached to their parents,
-        // or registered as root metaobjects
-
-        for (let i = 0, len = existingObjects.length; i < len; i++) {
-            const existingObject = existingObjects[i];
-            const objectId = options.globalizeObjectIds ? math.globalizeObjectId(modelId, existingObject.id) : existingObject.id;
-            if ((existingObject._parentId === undefined || existingObject._parentId === null) && !existingObject.parent) {
-                metaModel.rootMetaObject = existingObject; // Deprecated, and won't work for federated models
-                metaModel.rootMetaObjects[objectId] = existingObject;
-                this.rootMetaObjects[objectId] = existingObject;
-            } else if (existingObject._parentId) {
-                const parentId = options.globalizeObjectIds ? math.globalizeObjectId(modelId, existingObject._parentId) : existingObject._parentId;
-                existingObject._parentId = null;
-                let parentMetaObject = this.metaObjects[parentId];
+        for (let objectId in this.metaObjects) {
+            const metaObject = this.metaObjects[objectId];
+            if (metaObject.parentId) {
+                const parentMetaObject = this.metaObjects[metaObject.parentId];
                 if (parentMetaObject) {
-                    existingObject.parent = parentMetaObject;
-                    parentMetaObject.children = parentMetaObject.children || [];
-                    parentMetaObject.children.push(existingObject);
+                    metaObject.parent = parentMetaObject;
+                    (parentMetaObject.children || (parentMetaObject.children = [])).push(metaObject);
                 }
             }
         }
 
+        // Create MetaObjects-by-type lookup
+
+        this.metaObjectsByType = {};
+        for (let objectId in this.metaObjects) {
+            const metaObject = this.metaObjects[objectId];
+            const type = metaObject.type;
+            (this.metaObjectsByType[type] || (this.metaObjectsByType[type] = {}))[objectId] = metaObject;
+        }
+
         this.fire("metaModelCreated", modelId);
+
         return metaModel;
     }
 
+    _globalizeIDs(modelId, metaModelData, options) {
+        const globalize = !!options.globalizeObjectIds;
+        for (let i = 0, len = metaModelData.metaObjects.length; i < len; i++) {
+            const metaObjectData = metaModelData.metaObjects[i];
+
+            // Globalize MetaObject IDs and parent IDs
+
+            metaObjectData.originalSystemId = metaObjectData.id;
+            metaObjectData.originalParentSystemId = metaObjectData.parent;
+            if (globalize) {
+                metaObjectData.id = math.globalizeObjectId(modelId, metaObject.id);
+                metaObjectData.parent = math.globalizeObjectId(modelId, metaObject.parent);
+            }
+
+            // Globalize MetaObject property set IDs
+
+            const propertySetIds = metaObjectData.propertySetIds;
+            if (propertySetIds) {
+                const propertySetGlobalIds = [];
+                for (let j = 0, lenj = propertySetIds.length; j < lenj; j++) {
+                    propertySetGlobalIds.push(math.globalizeObjectId(modelId, propertySetIds[j]));
+                }
+                metaObjectData.propertySetIds = propertySetGlobalIds;
+                metaObjectData.originalSystemPropertySetIds = propertySetIds;
+            }
+        }
+
+        // Globalize global PropertySet IDs
+
+        for (let i = 0, len = metaModelData.propertySets.length; i < len; i++) {
+            const propertySet = metaModelData.propertySets[i];
+            propertySet.originalSystemId = propertySet.id;
+            if (globalize) {
+                propertySet.id = math.globalizeObjectId(modelId, propertySet.id);
+            }
+        }
+    }
+
     /**
      * Removes a {@link MetaModel} from this MetaScene.
      *
@@ -103563,43 +103607,86 @@ class MetaScene {
      * @param {String} id ID of the target {@link MetaModel}.
      */
     destroyMetaModel(id) {
+
         const metaModel = this.metaModels[id];
         if (!metaModel) {
             return;
         }
-        this._removeMetaModel(metaModel);
-        this.fire("metaModelDestroyed", id);
-    }
 
-    _removeMetaModel(metaModel) {
-        const metaObjects = this.metaObjects;
-        const metaObjectsByType = this.metaObjectsByType;
-        let visit = (metaObject) => {
-            delete metaObjects[metaObject.id];
-            const types = metaObjectsByType[metaObject.type];
-            if (types && types[metaObject.id]) {
-                delete types[metaObject.id];
-                if (--this._typeCounts[metaObject.type] === 0) {
-                    delete this._typeCounts[metaObject.type];
-                    delete metaObjectsByType[metaObject.type];
+        // Remove global PropertySets
+
+        for (let i = 0, len = metaModel.propertySets.length; i < len; i++) {
+            const propertySet = metaModel.propertySets[i];
+            if (propertySet.metaModels.length === 1) { // Property set owned by one model, delete
+                delete this.propertySets[propertySet.id];
+            } else {
+                const newMetaModels = [];
+                for (let j = 0, lenj = propertySet.metaModels.length; j < lenj; j++) {
+                    if (propertySet.metaModels[i].id !== id) {
+                        newMetaModels.push(propertySet.metaModels[i]);
+                    }
                 }
+                propertySet.metaModels = newMetaModels;
             }
-            const children = metaObject.children;
-            if (children) {
-                for (let i = 0, len = children.length; i < len; i++) {
-                    const childMetaObject = children[i];
-                    visit(childMetaObject);
+        }
+
+        // Remove MetaObjects
+
+        for (let i = 0, len = metaModel.metaObjects.length; i < len; i++) {
+            const metaObject = metaModel.metaObjects[i];
+            metaObject.type;
+            const id = metaObject.id;
+            if (metaObject.metaModels.length === 1) { // MetaObject owned by one model, delete
+                delete this.metaObjects[id];
+                if (!metaObject.parent) {
+                    delete this.rootMetaObjects[id];
+                }
+            } else {
+                const newMetaModels = [];
+                const metaModelId = metaModel.id;
+                for (let i = 0, len = metaObject.metaModels.length; i < len; i++) {
+                    if (metaObject.metaModels[i].id !== metaModelId) {
+                        newMetaModels.push(metaObject.metaModels[i]);
+                    }
                 }
+                metaObject.metaModels = newMetaModels;
             }
-        };
-        visit(metaModel.rootMetaObject);
-        for (let propertySetId in metaModel.propertySets) {
-            if (metaModel.propertySets.hasOwnProperty(propertySetId)) {
-                delete this.propertySets[propertySetId];
+        }
+
+        // Re-link entire MetaObject parent/child hierarchy
+
+        for (let objectId in this.metaObjects) {
+            const metaObject = this.metaObjects[objectId];
+            if (metaObject.children) {
+                metaObject.children = [];
             }
         }
-        delete this.rootMetaObjects[metaModel.rootMetaObject.id];
-        delete this.metaModels[metaModel.id];
+
+        this.metaObjectsByType = {};
+
+        for (let objectId in this.metaObjects) {
+            const metaObject = this.metaObjects[objectId];
+            const type = metaObject.type;
+            if (metaObject.children) {
+                metaObject.children = null;
+            }
+            (this.metaObjectsByType[type] || (this.metaObjectsByType[type] = {}))[objectId] = metaObject;
+        }
+
+        for (let objectId in this.metaObjects) {
+            const metaObject = this.metaObjects[objectId];
+            if (metaObject.parentId) {
+                const parentMetaObject = this.metaObjects[metaObject.parentId];
+                if (parentMetaObject) {
+                    metaObject.parent = parentMetaObject;
+                    (parentMetaObject.children || (parentMetaObject.children = [])).push(metaObject);
+                }
+            }
+        }
+
+        delete this.metaModels[id];
+
+        this.fire("metaModelDestroyed", id);
     }
 
     /**
@@ -103622,12 +103709,13 @@ class MetaScene {
      * @returns {String[]} Array of {@link MetaObject#id}s.
      */
     getObjectIDsInSubtree(id, includeTypes, excludeTypes) {
+
         const list = [];
         const metaObject = this.metaObjects[id];
         const includeMask = (includeTypes && includeTypes.length > 0) ? arrayToMap(includeTypes) : null;
         const excludeMask = (excludeTypes && excludeTypes.length > 0) ? arrayToMap(excludeTypes) : null;
 
-        function visit(metaObject) {
+        const visit = (metaObject) => {
             if (!metaObject) {
                 return;
             }
@@ -103646,7 +103734,7 @@ class MetaScene {
                     visit(children[i]);
                 }
             }
-        }
+        };
 
         visit(metaObject);
         return list;