@xeokit/xeokit-sdk 2.6.19 → 2.6.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xeokit/xeokit-sdk",
-  "version": "2.6.19",
+  "version": "2.6.22",
   "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/viewer/metadata/MetaModel.js

@@ -138,6 +138,8 @@ class MetaModel {
 
         this.metaScene.metaModels[this.id] = this;
 
+        this._propertyLookup = [];
+
         /**
          * True when this MetaModel has been finalized.
          * @type {boolean}
@@ -152,7 +154,7 @@ class MetaModel {
      * @type {MetaObject|null}
      */
     get rootMetaObject() {
-        if (this.rootMetaObjects.length == 1) {
+        if (this.rootMetaObjects.length === 1) {
             return this.rootMetaObjects[0];
         }
         return null;
@@ -173,6 +175,12 @@ class MetaModel {
         const metaScene = this.metaScene;
         const propertyLookup = metaModelData.properties;
 
+        if (propertyLookup) {
+            for (let i = 0, len = propertyLookup.length; i < len; i++) {
+                this._propertyLookup.push(propertyLookup[i]);
+            }
+        }
+
         // Create global Property Sets
 
         if (metaModelData.propertySets) {
@@ -183,9 +191,6 @@ class MetaModel {
                 }
                 let propertySet = metaScene.propertySets[propertySetData.id];
                 if (!propertySet) {
-                    if (propertyLookup) {
-                        this._decompressProperties(propertyLookup, propertySetData.properties);
-                    }
                     propertySet = new PropertySet({
                         id: propertySetData.id,
                         originalSystemId: propertySetData.originalSystemId || propertySetData.id,
@@ -232,15 +237,21 @@ class MetaModel {
     }
 
     _decompressProperties(propertyLookup, properties) {
+        const propsNotFound = [];
         for (let i = 0, len = properties.length; i < len; i++) {
             const property = properties[i];
             if (Number.isInteger(property)) {
                 const lookupProperty = propertyLookup[property];
                 if (lookupProperty) {
                     properties[i] = lookupProperty;
+                } else {
+                    propsNotFound.push(property);
                 }
             }
         }
+        if (propsNotFound.length > 0) {
+            console.error(`[MetaModel._decompressProperties] Properties not found: ${propsNotFound}`);
+        }
     }
 
     finalize() {
@@ -308,6 +319,18 @@ class MetaModel {
             (metaScene.metaObjectsByType[type] || (metaScene.metaObjectsByType[type] = {}))[objectId] = metaObject;
         }
 
+        // Decompress properties
+
+        if (this.propertySets) {
+            for (let i = 0, len = this.propertySets.length; i < len; i++) {
+                const propertySet = this.propertySets[i];
+                this._decompressProperties(this._propertyLookup, propertySet.properties);
+            }
+        }
+
+
+        this._propertyLookup = [];
+
         this.finalized = true;
 
         this.metaScene.fire("metaModelCreated", this.id);

package/src/viewer/metadata/PropertySet.js

@@ -68,7 +68,11 @@ class PropertySet {
             const properties = params.properties;
             for (let i = 0, len = properties.length; i < len; i++) {
                 const property = properties[i];
-                this.properties.push(new Property(property.name,  property.value, property.type, property.valueType, property.description));
+                if (Number.isInteger(property)) { // Will decompress in MetaModel.finalize();
+                    this.properties.push(property);
+                } else {
+                    this.properties.push(new Property(property.name, property.value, property.type, property.valueType, property.description));
+                }
             }
         }
     }

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

@@ -2289,8 +2289,6 @@ class Scene extends Component {
      * @param {Number[]} [params.origin] World-space ray origin when ray-picking. Ignored when canvasPos given.
      * @param {Number[]} [params.direction] World-space ray direction when ray-picking. Also indicates the length of the ray. Ignored when canvasPos given.
      * @param {Number[]} [params.matrix] 4x4 transformation matrix to define the World-space ray origin and direction, as an alternative to ````origin```` and ````direction````.
-     * @param {String[]} [params.includeEntities] IDs of {@link Entity}s to restrict picking to. When given, ignores {@link Entity}s whose IDs are not in this list.
-     * @param {String[]} [params.excludeEntities] IDs of {@link Entity}s to ignore. When given, will pick *through* these {@link Entity}s, as if they were not there.
      * @param {Number} [params.snapRadius=30] The snap radius, in canvas pixels.
      * @param {boolean} [params.snapToVertex=true] Whether to snap to vertex. Only works when `canvasPos` given.
      * @param {boolean} [params.snapToEdge=true] Whether to snap to edge. Only works when `canvasPos` given.

package/src/viewer/scene/webgl/Renderer.js

@@ -32,9 +32,6 @@ const Renderer = function (scene, options) {
     let drawableTypeInfo = {};
     let drawables = {};
 
-    let postSortDrawableList = [];
-    let postCullDrawableList = [];
-
     let drawableListDirty = true;
     let stateSortDirty = true;
     let imageDirty = true;
@@ -272,38 +269,28 @@ const Renderer = function (scene, options) {
                 const drawableInfo = drawableTypeInfo[type];
                 if (drawableInfo.isStateSortable) {
                     drawableInfo.drawableListPreCull.sort(drawableInfo.stateSortCompare);
-
-                    drawableInfo.drawableList = drawableInfo.drawableListPreCull;
                 }
             }
         }
-        let lenDrawableList = 0;
+    }
+
+    function cullDrawableList() {
         for (let type in drawableTypeInfo) {
             if (drawableTypeInfo.hasOwnProperty(type)) {
                 const drawableInfo = drawableTypeInfo[type];
                 const drawableListPreCull = drawableInfo.drawableListPreCull;
+                const drawableList = drawableInfo.drawableList;
+                let lenDrawableList = 0;
                 for (let i = 0, len = drawableListPreCull.length; i < len; i++) {
                     const drawable = drawableListPreCull[i];
-                    postSortDrawableList[lenDrawableList++] = drawable;
+                    drawable.rebuildRenderFlags();
+                    if (!drawable.renderFlags.culled) {
+                        drawableList[lenDrawableList++] = drawable;
+                    }
                 }
+                drawableList.length = lenDrawableList;
             }
         }
-        postSortDrawableList.length = lenDrawableList;
-        postSortDrawableList.sort((a, b) => {
-            return a.renderOrder - b.renderOrder;
-        });
-    }
-
-    function cullDrawableList() {
-        let lenDrawableList = 0;
-        for (let i = 0, len = postSortDrawableList.length; i < len; i++) {
-            const drawable = postSortDrawableList[i];
-            drawable.rebuildRenderFlags();
-            if (!drawable.renderFlags.culled) {
-                postCullDrawableList[lenDrawableList++] = drawable;
-            }
-        }
-        postCullDrawableList.length = lenDrawableList;
     }
 
     function draw(params) {
@@ -580,85 +567,93 @@ const Renderer = function (scene, options) {
         // Render normal opaque solids, defer others to bins to render after
         //------------------------------------------------------------------------------------------------------
 
-        for (let i = 0, len = postCullDrawableList.length; i < len; i++) {
+        for (let type in drawableTypeInfo) {
+            if (drawableTypeInfo.hasOwnProperty(type)) {
 
-            drawable = postCullDrawableList[i];
+                const drawableInfo = drawableTypeInfo[type];
+                const drawableList = drawableInfo.drawableList;
 
-            if (drawable.culled === true || drawable.visible === false) {
-                continue;
-            }
+                for (i = 0, len = drawableList.length; i < len; i++) {
 
-            const renderFlags = drawable.renderFlags;
+                    drawable = drawableList[i];
 
-            if (renderFlags.colorOpaque) {
-                if (saoEnabled && saoPossible && drawable.saoEnabled) {
-                    normalDrawSAOBin[normalDrawSAOBinLen++] = drawable;
-                } else {
-                    drawable.drawColorOpaque(frameCtx);
-                }
-            }
+                    if (drawable.culled === true || drawable.visible === false) {
+                        continue;
+                    }
 
-            if (transparentEnabled) {
-                if (renderFlags.colorTransparent) {
-                    normalFillTransparentBin[normalFillTransparentBinLen++] = drawable;
-                }
-            }
+                    const renderFlags = drawable.renderFlags;
 
-            if (renderFlags.xrayedSilhouetteTransparent) {
-                xrayedFillTransparentBin[xrayedFillTransparentBinLen++] = drawable;
-            }
+                    if (renderFlags.colorOpaque) {
+                        if (saoEnabled && saoPossible && drawable.saoEnabled) {
+                            normalDrawSAOBin[normalDrawSAOBinLen++] = drawable;
+                        } else {
+                            drawable.drawColorOpaque(frameCtx);
+                        }
+                    }
 
-            if (renderFlags.xrayedSilhouetteOpaque) {
-                xrayedFillOpaqueBin[xrayedFillOpaqueBinLen++] = drawable;
-            }
+                    if (transparentEnabled) {
+                        if (renderFlags.colorTransparent) {
+                            normalFillTransparentBin[normalFillTransparentBinLen++] = drawable;
+                        }
+                    }
 
-            if (renderFlags.highlightedSilhouetteTransparent) {
-                highlightedFillTransparentBin[highlightedFillTransparentBinLen++] = drawable;
-            }
+                    if (renderFlags.xrayedSilhouetteTransparent) {
+                        xrayedFillTransparentBin[xrayedFillTransparentBinLen++] = drawable;
+                    }
 
-            if (renderFlags.highlightedSilhouetteOpaque) {
-                highlightedFillOpaqueBin[highlightedFillOpaqueBinLen++] = drawable;
-            }
+                    if (renderFlags.xrayedSilhouetteOpaque) {
+                        xrayedFillOpaqueBin[xrayedFillOpaqueBinLen++] = drawable;
+                    }
 
-            if (renderFlags.selectedSilhouetteTransparent) {
-                selectedFillTransparentBin[selectedFillTransparentBinLen++] = drawable;
-            }
+                    if (renderFlags.highlightedSilhouetteTransparent) {
+                        highlightedFillTransparentBin[highlightedFillTransparentBinLen++] = drawable;
+                    }
 
-            if (renderFlags.selectedSilhouetteOpaque) {
-                selectedFillOpaqueBin[selectedFillOpaqueBinLen++] = drawable;
-            }
+                    if (renderFlags.highlightedSilhouetteOpaque) {
+                        highlightedFillOpaqueBin[highlightedFillOpaqueBinLen++] = drawable;
+                    }
 
-            if (drawable.edges && edgesEnabled) {
-                if (renderFlags.edgesOpaque) {
-                    normalEdgesOpaqueBin[normalEdgesOpaqueBinLen++] = drawable;
-                }
+                    if (renderFlags.selectedSilhouetteTransparent) {
+                        selectedFillTransparentBin[selectedFillTransparentBinLen++] = drawable;
+                    }
 
-                if (renderFlags.edgesTransparent) {
-                    normalEdgesTransparentBin[normalEdgesTransparentBinLen++] = drawable;
-                }
+                    if (renderFlags.selectedSilhouetteOpaque) {
+                        selectedFillOpaqueBin[selectedFillOpaqueBinLen++] = drawable;
+                    }
 
-                if (renderFlags.selectedEdgesTransparent) {
-                    selectedEdgesTransparentBin[selectedEdgesTransparentBinLen++] = drawable;
-                }
+                    if (drawable.edges && edgesEnabled) {
+                        if (renderFlags.edgesOpaque) {
+                            normalEdgesOpaqueBin[normalEdgesOpaqueBinLen++] = drawable;
+                        }
 
-                if (renderFlags.selectedEdgesOpaque) {
-                    selectedEdgesOpaqueBin[selectedEdgesOpaqueBinLen++] = drawable;
-                }
+                        if (renderFlags.edgesTransparent) {
+                            normalEdgesTransparentBin[normalEdgesTransparentBinLen++] = drawable;
+                        }
 
-                if (renderFlags.xrayedEdgesTransparent) {
-                    xrayEdgesTransparentBin[xrayEdgesTransparentBinLen++] = drawable;
-                }
+                        if (renderFlags.selectedEdgesTransparent) {
+                            selectedEdgesTransparentBin[selectedEdgesTransparentBinLen++] = drawable;
+                        }
 
-                if (renderFlags.xrayedEdgesOpaque) {
-                    xrayEdgesOpaqueBin[xrayEdgesOpaqueBinLen++] = drawable;
-                }
+                        if (renderFlags.selectedEdgesOpaque) {
+                            selectedEdgesOpaqueBin[selectedEdgesOpaqueBinLen++] = drawable;
+                        }
 
-                if (renderFlags.highlightedEdgesTransparent) {
-                    highlightedEdgesTransparentBin[highlightedEdgesTransparentBinLen++] = drawable;
-                }
+                        if (renderFlags.xrayedEdgesTransparent) {
+                            xrayEdgesTransparentBin[xrayEdgesTransparentBinLen++] = drawable;
+                        }
+
+                        if (renderFlags.xrayedEdgesOpaque) {
+                            xrayEdgesOpaqueBin[xrayEdgesOpaqueBinLen++] = drawable;
+                        }
 
-                if (renderFlags.highlightedEdgesOpaque) {
-                    highlightedEdgesOpaqueBin[highlightedEdgesOpaqueBinLen++] = drawable;
+                        if (renderFlags.highlightedEdgesTransparent) {
+                            highlightedEdgesTransparentBin[highlightedEdgesTransparentBinLen++] = drawable;
+                        }
+
+                        if (renderFlags.highlightedEdgesOpaque) {
+                            highlightedEdgesOpaqueBin[highlightedEdgesOpaqueBinLen++] = drawable;
+                        }
+                    }
                 }
             }
         }