@xeokit/xeokit-sdk 2.0.14 → 2.0.15

package/dist/xeokit-sdk.es.js

@@ -8261,6 +8261,20 @@ class PerformanceNode {
         return this._numTriangles;
     }
 
+    /**
+     * Gets if this PerformanceNode is visible.
+     *
+     * Only rendered when {@link PerformanceNode#visible} is ````true```` and {@link PerformanceNode#culled} is ````false````.
+     *
+     * When both {@link PerformanceNode#isObject} and {@link PerformanceNode#visible} are ````true```` the PerformanceNode will be
+     * registered by {@link PerformanceNode#id} in {@link Scene#visibleObjects}.
+     *
+     * @type {Boolean}
+     */
+    get visible() {
+        return this._getFlag(ENTITY_FLAGS.VISIBLE);
+    }
+
     /**
      * Sets if this PerformanceNode is visible.
      *
@@ -8290,21 +8304,15 @@ class PerformanceNode {
     }
 
     /**
-     * Gets if this PerformanceNode is visible.
-     *
-     * Only rendered when {@link PerformanceNode#visible} is ````true```` and {@link PerformanceNode#culled} is ````false````.
+     * Gets if this PerformanceNode is highlighted.
      *
-     * When both {@link PerformanceNode#isObject} and {@link PerformanceNode#visible} are ````true```` the PerformanceNode will be
-     * registered by {@link PerformanceNode#id} in {@link Scene#visibleObjects}.
+     * When both {@link PerformanceNode#isObject} and {@link PerformanceNode#highlighted} are ````true```` the PerformanceNode will be
+     * registered by {@link PerformanceNode#id} in {@link Scene#highlightedObjects}.
      *
      * @type {Boolean}
      */
-    get visible() {
-        return this._getFlag(ENTITY_FLAGS.VISIBLE);
-    }
-
-    _getFlag(flag) {
-        return !!(this._flags & flag);
+    get highlighted() {
+        return this._getFlag(ENTITY_FLAGS.HIGHLIGHTED);
     }
 
     /**
@@ -8334,15 +8342,15 @@ class PerformanceNode {
     }
 
     /**
-     * Gets if this PerformanceNode is highlighted.
+     * Gets if this PerformanceNode is xrayed.
      *
-     * When both {@link PerformanceNode#isObject} and {@link PerformanceNode#highlighted} are ````true```` the PerformanceNode will be
-     * registered by {@link PerformanceNode#id} in {@link Scene#highlightedObjects}.
+     * When both {@link PerformanceNode#isObject} and {@link PerformanceNode#xrayed} are ````true```` the PerformanceNode will be
+     * registered by {@link PerformanceNode#id} in {@link Scene#xrayedObjects}.
      *
      * @type {Boolean}
      */
-    get highlighted() {
-        return this._getFlag(ENTITY_FLAGS.HIGHLIGHTED);
+    get xrayed() {
+        return this._getFlag(ENTITY_FLAGS.XRAYED);
     }
 
     /**
@@ -8372,15 +8380,15 @@ class PerformanceNode {
     }
 
     /**
-     * Gets if this PerformanceNode is xrayed.
+     * Sets if this PerformanceNode is selected.
      *
-     * When both {@link PerformanceNode#isObject} and {@link PerformanceNode#xrayed} are ````true```` the PerformanceNode will be
-     * registered by {@link PerformanceNode#id} in {@link Scene#xrayedObjects}.
+     * When both {@link PerformanceNode#isObject} and {@link PerformanceNode#selected} are ````true```` the PerformanceNode will be
+     * registered by {@link PerformanceNode#id} in {@link Scene#selectedObjects}.
      *
      * @type {Boolean}
      */
-    get xrayed() {
-        return this._getFlag(ENTITY_FLAGS.XRAYED);
+    get selected() {
+        return this._getFlag(ENTITY_FLAGS.SELECTED);
     }
 
     /**
@@ -8410,15 +8418,12 @@ class PerformanceNode {
     }
 
     /**
-     * Sets if this PerformanceNode is selected.
-     *
-     * When both {@link PerformanceNode#isObject} and {@link PerformanceNode#selected} are ````true```` the PerformanceNode will be
-     * registered by {@link PerformanceNode#id} in {@link Scene#selectedObjects}.
+     * Gets if this PerformanceNode's edges are enhanced.
      *
      * @type {Boolean}
      */
-    get selected() {
-        return this._getFlag(ENTITY_FLAGS.SELECTED);
+    get edges() {
+        return this._getFlag(ENTITY_FLAGS.EDGES);
     }
 
     /**
@@ -8442,12 +8447,14 @@ class PerformanceNode {
     }
 
     /**
-     * Gets if this PerformanceNode's edges are enhanced.
+     * Gets if this PerformanceNode is culled.
+     *
+     * Only rendered when {@link PerformanceNode#visible} is ````true```` and {@link PerformanceNode#culled} is ````false````.
      *
      * @type {Boolean}
      */
-    get edges() {
-        return this._getFlag(ENTITY_FLAGS.EDGES);
+    get culled() {
+        return this._getFlag(ENTITY_FLAGS.CULLED);
     }
 
     /**
@@ -8473,14 +8480,14 @@ class PerformanceNode {
     }
 
     /**
-     * Gets if this PerformanceNode is culled.
+     * Gets if this PerformanceNode is clippable.
      *
-     * Only rendered when {@link PerformanceNode#visible} is ````true```` and {@link PerformanceNode#culled} is ````false````.
+     * Clipping is done by the {@link SectionPlane}s in {@link Scene#sectionPlanes}.
      *
      * @type {Boolean}
      */
-    get culled() {
-        return this._getFlag(ENTITY_FLAGS.CULLED);
+    get clippable() {
+        return this._getFlag(ENTITY_FLAGS.CLIPPABLE);
     }
 
     /**
@@ -8506,14 +8513,12 @@ class PerformanceNode {
     }
 
     /**
-     * Gets if this PerformanceNode is clippable.
-     *
-     * Clipping is done by the {@link SectionPlane}s in {@link Scene#sectionPlanes}.
+     * Gets if this PerformanceNode is included in boundary calculations.
      *
      * @type {Boolean}
      */
-    get clippable() {
-        return this._getFlag(ENTITY_FLAGS.CLIPPABLE);
+    get collidable() {
+        return this._getFlag(ENTITY_FLAGS.COLLIDABLE);
     }
 
     /**
@@ -8536,12 +8541,14 @@ class PerformanceNode {
     }
 
     /**
-     * Gets if this PerformanceNode is included in boundary calculations.
+     * Gets if this PerformanceNode is pickable.
+     *
+     * Picking is done via calls to {@link Scene#pick}.
      *
      * @type {Boolean}
      */
-    get collidable() {
-        return this._getFlag(ENTITY_FLAGS.COLLIDABLE);
+    get pickable() {
+        return this._getFlag(ENTITY_FLAGS.PICKABLE);
     }
 
     /**
@@ -8566,14 +8573,21 @@ class PerformanceNode {
     }
 
     /**
-     * Gets if this PerformanceNode is pickable.
+     * Gets the PerformanceNode's RGB colorize color.
      *
-     * Picking is done via calls to {@link Scene#pick}.
+     * Each element of the color is in range ````[0..1]````.
      *
-     * @type {Boolean}
+     * @type {Number[]}
      */
-    get pickable() {
-        return this._getFlag(ENTITY_FLAGS.PICKABLE);
+    get colorize() { // [0..1, 0..1, 0..1]
+        if (this.meshes.length === 0) {
+            return null;
+        }
+        const colorize = this.meshes[0]._colorize;
+        tempFloatRGB[0] = colorize[0] / 255.0; // Unquantize
+        tempFloatRGB[1] = colorize[1] / 255.0;
+        tempFloatRGB[2] = colorize[2] / 255.0;
+        return tempFloatRGB;
     }
 
     /**
@@ -8604,21 +8618,18 @@ class PerformanceNode {
     }
 
     /**
-     * Gets the PerformanceNode's RGB colorize color.
+     * Gets the PerformanceNode's opacity factor.
      *
-     * Each element of the color is in range ````[0..1]````.
+     * This is a factor in range ````[0..1]```` which multiplies by the rendered fragment alphas.
      *
-     * @type {Number[]}
+     * @type {Number}
      */
-    get colorize() { // [0..1, 0..1, 0..1]
-        if (this.meshes.length === 0) {
-            return null;
+    get opacity() {
+        if (this.meshes.length > 0) {
+            return (this.meshes[0]._colorize[3] / 255.0);
+        } else {
+            return 1.0;
         }
-        const colorize = this.meshes[0]._colorize;
-        tempFloatRGB[0] = colorize[0] / 255.0; // Unquantize
-        tempFloatRGB[1] = colorize[1] / 255.0;
-        tempFloatRGB[2] = colorize[2] / 255.0;
-        return tempFloatRGB;
     }
 
     /**
@@ -8661,18 +8672,14 @@ class PerformanceNode {
     }
 
     /**
-     * Gets the PerformanceNode's opacity factor.
+     * Gets the PerformanceNode's 3D World-space offset.
      *
-     * This is a factor in range ````[0..1]```` which multiplies by the rendered fragment alphas.
+     * Default value is ````[0,0,0]````.
      *
-     * @type {Number}
+     * @type {Number[]}
      */
-    get opacity() {
-        if (this.meshes.length > 0) {
-            return (this.meshes[0]._colorize[3] / 255.0);
-        } else {
-            return 1.0;
-        }
+    get offset() {
+        return this._offset;
     }
 
     /**
@@ -8712,14 +8719,12 @@ class PerformanceNode {
     }
 
     /**
-     * Gets the PerformanceNode's 3D World-space offset.
-     *
-     * Default value is ````[0,0,0]````.
+     * Gets if this PerformanceNode casts shadows.
      *
-     * @type {Number[]}
+     * @type {Boolean}
      */
-    get offset() {
-        return this._offset;
+    get castsShadow() { // TODO
+        return false;
     }
 
     /**
@@ -8732,11 +8737,11 @@ class PerformanceNode {
     }
 
     /**
-     * Gets if this PerformanceNode casts shadows.
+     * Whether or not this PerformanceNode can have shadows cast upon it
      *
      * @type {Boolean}
      */
-    get castsShadow() { // TODO
+    get receivesShadow() { // TODO
         return false;
     }
 
@@ -8749,15 +8754,6 @@ class PerformanceNode {
 
     }
 
-    /**
-     * Whether or not this PerformanceNode can have shadows cast upon it
-     *
-     * @type {Boolean}
-     */
-    get receivesShadow() { // TODO
-        return false;
-    }
-
     /**
      * Gets if Scalable Ambient Obscurance (SAO) will apply to this PerformanceNode.
      *
@@ -8770,6 +8766,10 @@ class PerformanceNode {
         return this.model.saoEnabled;
     }
 
+    _getFlag(flag) {
+        return !!(this._flags & flag);
+    }
+
     _finalize() {
         const scene = this.model.scene;
         if (this._isObject) {
@@ -8791,6 +8791,12 @@ class PerformanceNode {
         }
     }
 
+    _finalize2() {
+        for (let i = 0, len = this.meshes.length; i < len; i++) {
+            this.meshes[i]._finalize2();
+        }
+    }
+
     _destroy() { // Called by PerformanceModel
         const scene = this.model.scene;
         if (this._isObject) {
@@ -8939,8 +8945,8 @@ function getPlaneRTCPos(dist, dir, rtcCenter, rtcPlanePos) {
     return rtcPlanePos;
 }
 
-const tempVec4a$8 = math.vec4();
-const tempVec4b$8 = math.vec4();
+const tempVec4a$a = math.vec4();
+const tempVec4b$a = math.vec4();
 
 
 /**
@@ -9101,12 +9107,12 @@ class Marker extends Component {
             this.fire("viewPos", this._viewPos);
         }
         if (this._canvasPosDirty) {
-            tempVec4a$8.set(this._viewPos);
-            tempVec4a$8[3] = 1.0;
-            math.transformPoint4(this.scene.camera.projMatrix, tempVec4a$8, tempVec4b$8);
+            tempVec4a$a.set(this._viewPos);
+            tempVec4a$a[3] = 1.0;
+            math.transformPoint4(this.scene.camera.projMatrix, tempVec4a$a, tempVec4b$a);
             const aabb = this.scene.canvas.boundary;
-            this._canvasPos[0] = Math.floor((1 + tempVec4b$8[0] / tempVec4b$8[3]) * aabb[2] / 2);
-            this._canvasPos[1] = Math.floor((1 - tempVec4b$8[1] / tempVec4b$8[3]) * aabb[3] / 2);
+            this._canvasPos[0] = Math.floor((1 + tempVec4b$a[0] / tempVec4b$a[3]) * aabb[2] / 2);
+            this._canvasPos[1] = Math.floor((1 - tempVec4b$a[1] / tempVec4b$a[3]) * aabb[3] / 2);
             this._canvasPosDirty = false;
             this.fire("canvasPos", this._canvasPos);
         }
@@ -9622,26 +9628,21 @@ class AngleMeasurement extends Component {
 
         this._originDot = new Dot(this._container, {
             fillColor: this._color,
-            zIndex: plugin.zIndex !== undefined ? plugin.zIndex + 1: undefined
+            zIndex: plugin.zIndex + 1
         });
         this._cornerDot = new Dot(this._container, {
             fillColor: this._color,
-            zIndex: plugin.zIndex !== undefined ? plugin.zIndex + 1: undefined
+            zIndex: plugin.zIndex + 1
         });
         this._targetDot = new Dot(this._container, {
             fillColor: this._color,
-            zIndex: plugin.zIndex !== undefined ? plugin.zIndex + 1: undefined
+            zIndex: plugin.zIndex + 1
         });
 
         this._originWire = new Wire(this._container, {color: this._color || "blue", thickness: 1, zIndex: plugin.zIndex});
         this._targetWire = new Wire(this._container, {color: this._color || "red", thickness: 1, zIndex: plugin.zIndex});
 
-        this._angleLabel = new Label(this._container, {
-            fillColor: this._color || "#00BBFF",
-            prefix: "",
-            text: "",
-            zIndex: plugin.zIndex !== undefined ? plugin.zIndex + 2: undefined
-        });
+        this._angleLabel = new Label(this._container, {fillColor: this._color || "#00BBFF", prefix: "", text: "", zIndex: plugin.zIndex + 2});
 
         this._wpDirty = false;
         this._vpDirty = false;
@@ -20776,6 +20777,17 @@ var compressPositions = (function () { // http://cg.postech.ac.kr/research/mesh_
     };
 })();
 
+function compressPosition(p, aabb, q) {
+    const multiplier = new Float32Array([
+        aabb[3] !== aabb[0] ? 65535 / (aabb[3] - aabb[0]) : 0,
+        aabb[4] !== aabb[1] ? 65535 / (aabb[4] - aabb[1]) : 0,
+        aabb[5] !== aabb[2] ? 65535 / (aabb[5] - aabb[2]) : 0
+    ]);
+    q[0] = Math.floor((p[0] - aabb[0]) * multiplier[0]);
+    q[1] = Math.floor((p[1] - aabb[1]) * multiplier[1]);
+    q[2] = Math.floor((p[2] - aabb[2]) * multiplier[2]);
+}
+
 function decompressPosition(position, decodeMatrix, dest) {
     dest[0] = position[0] * decodeMatrix[0] + decodeMatrix[12];
     dest[1] = position[1] * decodeMatrix[5] + decodeMatrix[13];
@@ -20783,7 +20795,7 @@ function decompressPosition(position, decodeMatrix, dest) {
     return dest;
 }
 
-function decompressAABB(aabb, decodeMatrix, dest=aabb) {
+function decompressAABB(aabb, decodeMatrix, dest = aabb) {
     dest[0] = aabb[0] * decodeMatrix[0] + decodeMatrix[12];
     dest[1] = aabb[1] * decodeMatrix[5] + decodeMatrix[13];
     dest[2] = aabb[2] * decodeMatrix[10] + decodeMatrix[14];
@@ -21027,6 +21039,7 @@ const geometryCompressionUtils = {
     getPositionsBounds: getPositionsBounds,
     createPositionsDecodeMatrix: createPositionsDecodeMatrix,
     compressPositions: compressPositions,
+    compressPosition:compressPosition,
     decompressPositions: decompressPositions,
     decompressPosition: decompressPosition,
     decompressAABB: decompressAABB,
@@ -39820,6 +39833,15 @@ class PerformanceMesh {
         this._layer.initFlags(this._portionId, entityFlags, this._transparent);
     }
 
+    /**
+     * @private
+     */
+    _finalize2() {
+        if (this._layer.flushInitFlags) {
+            this._layer.flushInitFlags();
+        }
+    }
+
     /**
      * @private
      */
@@ -45674,8 +45696,8 @@ function dot(p, vec3) { // Dot product of a normal in an array against a candida
 
 const tempMat4$2 = math.mat4();
 const tempMat4b = math.mat4();
-const tempVec4a$7 = math.vec4([0, 0, 0, 1]);
-const tempVec4b$7 = math.vec4([0, 0, 0, 1]);
+const tempVec4a$9 = math.vec4([0, 0, 0, 1]);
+const tempVec4b$9 = math.vec4([0, 0, 0, 1]);
 const tempVec4c$7 = math.vec4([0, 0, 0, 1]);
 const tempOBB3$2 = math.OBB3();
 
@@ -45750,6 +45772,8 @@ class TrianglesBatchingLayer {
         this._modelAABB = math.collapseAABB3(); // Model-space AABB
         this._portions = [];
 
+        this._numVerts = 0;
+
         this._finalized = false;
 
         if (cfg.positionsDecodeMatrix) {
@@ -45873,23 +45897,23 @@ class TrianglesBatchingLayer {
 
                 for (let i = positionsBase, len = positionsBase + lenPositions; i < len; i += 3) {
 
-                    tempVec4a$7[0] = buffer.positions[i + 0];
-                    tempVec4a$7[1] = buffer.positions[i + 1];
-                    tempVec4a$7[2] = buffer.positions[i + 2];
+                    tempVec4a$9[0] = buffer.positions[i + 0];
+                    tempVec4a$9[1] = buffer.positions[i + 1];
+                    tempVec4a$9[2] = buffer.positions[i + 2];
 
-                    math.transformPoint4(meshMatrix, tempVec4a$7, tempVec4b$7);
+                    math.transformPoint4(meshMatrix, tempVec4a$9, tempVec4b$9);
 
-                    buffer.positions[i + 0] = tempVec4b$7[0];
-                    buffer.positions[i + 1] = tempVec4b$7[1];
-                    buffer.positions[i + 2] = tempVec4b$7[2];
+                    buffer.positions[i + 0] = tempVec4b$9[0];
+                    buffer.positions[i + 1] = tempVec4b$9[1];
+                    buffer.positions[i + 2] = tempVec4b$9[2];
 
-                    math.expandAABB3Point3(this._modelAABB, tempVec4b$7);
+                    math.expandAABB3Point3(this._modelAABB, tempVec4b$9);
 
                     if (worldMatrix) {
-                        math.transformPoint4(worldMatrix, tempVec4b$7, tempVec4c$7);
+                        math.transformPoint4(worldMatrix, tempVec4b$9, tempVec4c$7);
                         math.expandAABB3Point3(worldAABB, tempVec4c$7);
                     } else {
-                        math.expandAABB3Point3(worldAABB, tempVec4b$7);
+                        math.expandAABB3Point3(worldAABB, tempVec4b$9);
                     }
                 }
 
@@ -45897,17 +45921,17 @@ class TrianglesBatchingLayer {
 
                 for (let i = positionsBase, len = positionsBase + lenPositions; i < len; i += 3) {
 
-                    tempVec4a$7[0] = buffer.positions[i + 0];
-                    tempVec4a$7[1] = buffer.positions[i + 1];
-                    tempVec4a$7[2] = buffer.positions[i + 2];
+                    tempVec4a$9[0] = buffer.positions[i + 0];
+                    tempVec4a$9[1] = buffer.positions[i + 1];
+                    tempVec4a$9[2] = buffer.positions[i + 2];
 
-                    math.expandAABB3Point3(this._modelAABB, tempVec4a$7);
+                    math.expandAABB3Point3(this._modelAABB, tempVec4a$9);
 
                     if (worldMatrix) {
-                        math.transformPoint4(worldMatrix, tempVec4a$7, tempVec4b$7);
-                        math.expandAABB3Point3(worldAABB, tempVec4b$7);
+                        math.transformPoint4(worldMatrix, tempVec4a$9, tempVec4b$9);
+                        math.expandAABB3Point3(worldAABB, tempVec4b$9);
                     } else {
-                        math.expandAABB3Point3(worldAABB, tempVec4a$7);
+                        math.expandAABB3Point3(worldAABB, tempVec4a$9);
                     }
                 }
             }
@@ -46032,6 +46056,8 @@ class TrianglesBatchingLayer {
         this._numPortions++;
         this.model.numPortions++;
 
+        this._numVerts += portion.numVerts;
+
         return portionId;
     }
 
@@ -46164,8 +46190,14 @@ class TrianglesBatchingLayer {
             this._numTransparentLayerPortions++;
             this.model.numTransparentLayerPortions++;
         }
-        this._setFlags(portionId, flags, meshTransparent);
-        this._setFlags2(portionId, flags);
+        const deferred = true;
+        this._setFlags(portionId, flags, meshTransparent, deferred);
+        this._setFlags2(portionId, flags, deferred);
+    }
+
+    flushInitFlags() {
+        this._setDeferredFlags();
+        this._setDeferredFlags2();
     }
 
     setVisible(portionId, flags, transparent) {
@@ -46323,7 +46355,7 @@ class TrianglesBatchingLayer {
         this._setFlags(portionId, flags, transparent);
     }
 
-    _setFlags(portionId, flags, transparent) {
+    _setFlags(portionId, flags, transparent, deferred = false) {
 
         if (!this._finalized) {
             throw "Not finalized";
@@ -46335,7 +46367,6 @@ class TrianglesBatchingLayer {
         const numVerts = portion.numVerts;
         const firstFlag = vertexBase * 4;
         const lenFlags = numVerts * 4;
-        const tempArray = this._scratchMemory.getUInt8Array(lenFlags);
 
         const visible = !!(flags & ENTITY_FLAGS.VISIBLE);
         const xrayed = !!(flags & ENTITY_FLAGS.XRAYED);
@@ -46398,19 +46429,37 @@ class TrianglesBatchingLayer {
 
         let f3 = (visible && !culled && pickable) ? RENDER_PASSES.PICK : RENDER_PASSES.NOT_RENDERED;
 
-        for (let i = 0; i < lenFlags; i += 4) {
-            tempArray[i + 0] = f0; // x - normal fill
-            tempArray[i + 1] = f1; // y - emphasis fill
-            tempArray[i + 2] = f2; // z - edges
-            tempArray[i + 3] = f3; // w - pick
+        if (deferred) {
+            // Avoid zillions of individual WebGL bufferSubData calls - buffer them to apply in one shot
+            if (!this._deferredFlagValues) {
+                this._deferredFlagValues = new Uint8Array(this._numVerts * 4);
+            }
+            for (let i = firstFlag, len = (firstFlag + lenFlags); i < len; i += 4) {
+                this._deferredFlagValues[i + 0] = f0;
+                this._deferredFlagValues[i + 1] = f1;
+                this._deferredFlagValues[i + 2] = f2;
+                this._deferredFlagValues[i + 3] = f3;
+            }
+        } else if (this._state.flagsBuf) {
+            const tempArray = this._scratchMemory.getUInt8Array(lenFlags);
+            for (let i = 0; i < lenFlags; i += 4) {
+                tempArray[i + 0] = f0; // x - normal fill
+                tempArray[i + 1] = f1; // y - emphasis fill
+                tempArray[i + 2] = f2; // z - edges
+                tempArray[i + 3] = f3; // w - pick
+            }
+            this._state.flagsBuf.setData(tempArray, firstFlag, lenFlags);
         }
+    }
 
-        if (this._state.flagsBuf) {
-            this._state.flagsBuf.setData(tempArray, firstFlag, lenFlags);
+    _setDeferredFlags() {
+        if (this._deferredFlagValues) {
+            this._state.flagsBuf.setData(this._deferredFlagValues);
+            this._deferredFlagValues = null;
         }
     }
 
-    _setFlags2(portionId, flags) {
+    _setFlags2(portionId, flags, deferred = false) {
 
         if (!this._finalized) {
             throw "Not finalized";
@@ -46422,16 +46471,28 @@ class TrianglesBatchingLayer {
         const numVerts = portion.numVerts;
         const firstFlag = vertexBase * 4;
         const lenFlags = numVerts * 4;
-        const tempArray = this._scratchMemory.getUInt8Array(lenFlags);
-
         const clippable = !!(flags & ENTITY_FLAGS.CLIPPABLE) ? 255 : 0;
 
-        for (let i = 0; i < lenFlags; i += 4) {
-            tempArray[i + 0] = clippable;
+        if (deferred) {
+            if (!this._setDeferredFlag2Values) {
+                this._setDeferredFlag2Values = new Uint8Array(this._numVerts * 4);
+            }
+            for (let i = firstFlag, len = (firstFlag + lenFlags); i < len; i += 4) {
+                this._setDeferredFlag2Values[i] = clippable;
+            }
+        } else if (this._state.flags2Buf) {
+            const tempArray = this._scratchMemory.getUInt8Array(lenFlags);
+            for (let i = 0; i < lenFlags; i += 4) {
+                tempArray[i + 0] = clippable;
+            }
+            this._state.flags2Buf.setData(tempArray, firstFlag, lenFlags);
         }
+    }
 
-        if (this._state.flags2Buf) {
-            this._state.flags2Buf.setData(tempArray, firstFlag, lenFlags);
+    _setDeferredFlags2() {
+        if (this._setDeferredFlag2Values) {
+            this._state.flags2Buf.setData(this._setDeferredFlag2Values);
+            this._setDeferredFlag2Values = null;
         }
     }
 
@@ -52814,8 +52875,8 @@ function getInstancingRenderers$1(scene) {
 const bigIndicesSupported$4 = WEBGL_INFO$1.SUPPORTED_EXTENSIONS["OES_element_index_uint"];
 
 const tempUint8Vec4$2 = new Uint8Array(4);
-const tempVec4a$6 = math.vec4([0, 0, 0, 1]);
-const tempVec4b$6 = math.vec4([0, 0, 0, 1]);
+const tempVec4a$8 = math.vec4([0, 0, 0, 1]);
+const tempVec4b$8 = math.vec4([0, 0, 0, 1]);
 const tempVec4c$6 = math.vec4([0, 0, 0, 1]);
 const tempVec3fa$2 = new Float32Array(3);
 
@@ -53094,15 +53155,15 @@ class TrianglesInstancingLayer {
         const obb = this._state.obb;
         const lenPositions = obb.length;
         for (let i = 0; i < lenPositions; i += 4) {
-            tempVec4a$6[0] = obb[i + 0];
-            tempVec4a$6[1] = obb[i + 1];
-            tempVec4a$6[2] = obb[i + 2];
-            math.transformPoint4(meshMatrix, tempVec4a$6, tempVec4b$6);
+            tempVec4a$8[0] = obb[i + 0];
+            tempVec4a$8[1] = obb[i + 1];
+            tempVec4a$8[2] = obb[i + 2];
+            math.transformPoint4(meshMatrix, tempVec4a$8, tempVec4b$8);
             if (worldMatrix) {
-                math.transformPoint4(worldMatrix, tempVec4b$6, tempVec4c$6);
+                math.transformPoint4(worldMatrix, tempVec4b$8, tempVec4c$6);
                 math.expandAABB3Point3(worldAABB, tempVec4c$6);
             } else {
-                math.expandAABB3Point3(worldAABB, tempVec4b$6);
+                math.expandAABB3Point3(worldAABB, tempVec4b$8);
             }
         }
 
@@ -54641,8 +54702,8 @@ class LinesBatchingBuffer {
     }
 }
 
-const tempVec4a$5 = math.vec4([0, 0, 0, 1]);
-const tempVec4b$5 = math.vec4([0, 0, 0, 1]);
+const tempVec4a$7 = math.vec4([0, 0, 0, 1]);
+const tempVec4b$7 = math.vec4([0, 0, 0, 1]);
 const tempVec4c$5 = math.vec4([0, 0, 0, 1]);
 const tempOBB3$1 = math.OBB3();
 
@@ -54699,6 +54760,8 @@ class LinesBatchingLayer {
         this._modelAABB = math.collapseAABB3(); // Model-space AABB
         this._portions = [];
 
+        this._numVerts = 0;
+
         this._finalized = false;
         this._positionsDecodeMatrix = cfg.positionsDecodeMatrix;
         this._preCompressed = (!!this._positionsDecodeMatrix);
@@ -54800,23 +54863,23 @@ class LinesBatchingLayer {
 
                 for (let i = positionsBase, len = positionsBase + lenPositions; i < len; i += 3) {
 
-                    tempVec4a$5[0] = buffer.positions[i + 0];
-                    tempVec4a$5[1] = buffer.positions[i + 1];
-                    tempVec4a$5[2] = buffer.positions[i + 2];
+                    tempVec4a$7[0] = buffer.positions[i + 0];
+                    tempVec4a$7[1] = buffer.positions[i + 1];
+                    tempVec4a$7[2] = buffer.positions[i + 2];
 
-                    math.transformPoint4(meshMatrix, tempVec4a$5, tempVec4b$5);
+                    math.transformPoint4(meshMatrix, tempVec4a$7, tempVec4b$7);
 
-                    buffer.positions[i + 0] = tempVec4b$5[0];
-                    buffer.positions[i + 1] = tempVec4b$5[1];
-                    buffer.positions[i + 2] = tempVec4b$5[2];
+                    buffer.positions[i + 0] = tempVec4b$7[0];
+                    buffer.positions[i + 1] = tempVec4b$7[1];
+                    buffer.positions[i + 2] = tempVec4b$7[2];
 
-                    math.expandAABB3Point3(this._modelAABB, tempVec4b$5);
+                    math.expandAABB3Point3(this._modelAABB, tempVec4b$7);
 
                     if (worldMatrix) {
-                        math.transformPoint4(worldMatrix, tempVec4b$5, tempVec4c$5);
+                        math.transformPoint4(worldMatrix, tempVec4b$7, tempVec4c$5);
                         math.expandAABB3Point3(worldAABB, tempVec4c$5);
                     } else {
-                        math.expandAABB3Point3(worldAABB, tempVec4b$5);
+                        math.expandAABB3Point3(worldAABB, tempVec4b$7);
                     }
                 }
 
@@ -54824,17 +54887,17 @@ class LinesBatchingLayer {
 
                 for (let i = positionsBase, len = positionsBase + lenPositions; i < len; i += 3) {
 
-                    tempVec4a$5[0] = buffer.positions[i + 0];
-                    tempVec4a$5[1] = buffer.positions[i + 1];
-                    tempVec4a$5[2] = buffer.positions[i + 2];
+                    tempVec4a$7[0] = buffer.positions[i + 0];
+                    tempVec4a$7[1] = buffer.positions[i + 1];
+                    tempVec4a$7[2] = buffer.positions[i + 2];
 
-                    math.expandAABB3Point3(this._modelAABB, tempVec4a$5);
+                    math.expandAABB3Point3(this._modelAABB, tempVec4a$7);
 
                     if (worldMatrix) {
-                        math.transformPoint4(worldMatrix, tempVec4a$5, tempVec4b$5);
-                        math.expandAABB3Point3(worldAABB, tempVec4b$5);
+                        math.transformPoint4(worldMatrix, tempVec4a$7, tempVec4b$7);
+                        math.expandAABB3Point3(worldAABB, tempVec4b$7);
                     } else {
-                        math.expandAABB3Point3(worldAABB, tempVec4a$5);
+                        math.expandAABB3Point3(worldAABB, tempVec4a$7);
                     }
                 }
             }
@@ -54889,6 +54952,8 @@ class LinesBatchingLayer {
         this._numPortions++;
         this.model.numPortions++;
 
+        this._numVerts += numVerts;
+
         return portionId;
     }
 
@@ -54914,7 +54979,7 @@ class LinesBatchingLayer {
                 state.positionsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, positions, buffer.positions.length, 3, gl.STATIC_DRAW);
             } else {
                 const positions = new Float32Array(buffer.positions);
-                const quantizedPositions = quantizePositions(positions, this._modelAABB,  state.positionsDecodeMatrix);
+                const quantizedPositions = quantizePositions(positions, this._modelAABB, state.positionsDecodeMatrix);
                 state.positionsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, quantizedPositions, buffer.positions.length, 3, gl.STATIC_DRAW);
             }
         }
@@ -54990,8 +55055,14 @@ class LinesBatchingLayer {
             this._numTransparentLayerPortions++;
             this.model.numTransparentLayerPortions++;
         }
-        this._setFlags(portionId, flags, meshTransparent);
-        this._setFlags2(portionId, flags);
+        const deferred = true;
+        this._setFlags(portionId, flags, meshTransparent, deferred);
+        this._setFlags2(portionId, flags, deferred);
+    }
+
+    flushInitFlags() {
+        this._setDeferredFlags();
+        this._setDeferredFlags2();
     }
 
     setVisible(portionId, flags, transparent) {
@@ -55146,7 +55217,7 @@ class LinesBatchingLayer {
         this._setFlags(portionId, flags, transparent);
     }
 
-    _setFlags(portionId, flags, transparent) {
+    _setFlags(portionId, flags, transparent, deferred = false) {
 
         if (!this._finalized) {
             throw "Not finalized";
@@ -55157,7 +55228,7 @@ class LinesBatchingLayer {
         const numVerts = this._portions[portionsIdx + 1];
         const firstFlag = vertexBase * 4;
         const lenFlags = numVerts * 4;
-        const tempArray = this._scratchMemory.getUInt8Array(lenFlags);
+        this._scratchMemory.getUInt8Array(lenFlags);
 
         const visible = !!(flags & ENTITY_FLAGS.VISIBLE);
         const xrayed = !!(flags & ENTITY_FLAGS.XRAYED);
@@ -55197,18 +55268,36 @@ class LinesBatchingLayer {
         // Pick
 
         let f3 = (visible && !culled && pickable) ? RENDER_PASSES.PICK : RENDER_PASSES.NOT_RENDERED;
-
-        for (let i = 0; i < lenFlags; i += 4) {
-            tempArray[i + 0] = f0; // x - color
-            tempArray[i + 1] = f1; // y - silhouette - select/highlight/xray
-            tempArray[i + 2] = 0; // z - edges
-            tempArray[i + 3] = f3; // w - pickable
+        if (deferred) {
+            if (!this._deferredFlagValues) {
+                this._deferredFlagValues = new Uint8Array(this._numVerts * 4);
+            }
+            for (let i = firstFlag, len = (firstFlag + lenFlags); i < len; i += 4) {
+                this._deferredFlagValues[i + 0] = f0;
+                this._deferredFlagValues[i + 1] = f1;
+                this._deferredFlagValues[i + 2] = 0;
+                this._deferredFlagValues[i + 3] = f3;
+            }
+        } else if (this._state.flagsBuf) {
+            const tempArray = this._scratchMemory.getUInt8Array(lenFlags);
+            for (let i = 0; i < lenFlags; i += 4) {
+                tempArray[i + 0] = f0; // x - color
+                tempArray[i + 1] = f1; // y - silhouette - select/highlight/xray
+                tempArray[i + 2] = 0; // z - edges
+                tempArray[i + 3] = f3; // w - pickable
+            }
+            this._state.flagsBuf.setData(tempArray, firstFlag, lenFlags);
         }
+    }
 
-        this._state.flagsBuf.setData(tempArray, firstFlag, lenFlags);
+    _setDeferredFlags() {
+        if (this._deferredFlagValues) {
+            this._state.flagsBuf.setData(this._deferredFlagValues);
+            this._deferredFlagValues = null;
+        }
     }
 
-    _setFlags2(portionId, flags) {
+    _setFlags2(portionId, flags, deferred = false) {
         if (!this._finalized) {
             throw "Not finalized";
         }
@@ -55217,12 +55306,28 @@ class LinesBatchingLayer {
         const numVerts = this._portions[portionsIdx + 1];
         const firstFlag = vertexBase * 4;
         const lenFlags = numVerts * 4;
-        const tempArray = this._scratchMemory.getUInt8Array(lenFlags);
         const clippable = !!(flags & ENTITY_FLAGS.CLIPPABLE) ? 255 : 0;
-        for (let i = 0; i < lenFlags; i += 4) {
-            tempArray[i + 0] = clippable;
+        if (deferred) {
+            if (!this._setDeferredFlag2Values) {
+                this._setDeferredFlag2Values = new Uint8Array(this._numVerts * 4);
+            }
+            for (let i = firstFlag, len = (firstFlag + lenFlags); i < len; i += 4) {
+                this._setDeferredFlag2Values[i] = clippable;
+            }
+        } else {
+            const tempArray = this._scratchMemory.getUInt8Array(lenFlags);
+            for (let i = 0; i < lenFlags; i += 4) {
+                tempArray[i + 0] = clippable;
+            }
+            this._state.flags2Buf.setData(tempArray, firstFlag, lenFlags);
+        }
+    }
+
+    _setDeferredFlags2() {
+        if (this._setDeferredFlag2Values) {
+            this._state.flags2Buf.setData(this._setDeferredFlag2Values);
+            this._setDeferredFlag2Values = null;
         }
-        this._state.flags2Buf.setData(tempArray, firstFlag, lenFlags);
     }
 
     setOffset(portionId, offset) {
@@ -56141,8 +56246,8 @@ const bigIndicesSupported$2 = WEBGL_INFO$1.SUPPORTED_EXTENSIONS["OES_element_ind
 
 const tempUint8Vec4$1 = new Uint8Array(4);
 
-const tempVec4a$4 = math.vec4([0, 0, 0, 1]);
-const tempVec4b$4 = math.vec4([0, 0, 0, 1]);
+const tempVec4a$6 = math.vec4([0, 0, 0, 1]);
+const tempVec4b$6 = math.vec4([0, 0, 0, 1]);
 const tempVec4c$4 = math.vec4([0, 0, 0, 1]);
 
 const tempVec3fa$1 = new Float32Array(3);
@@ -56325,15 +56430,15 @@ class LinesInstancingLayer {
         const obb = this._state.obb;
         const lenPositions = obb.length;
         for (let i = 0; i < lenPositions; i += 4) {
-            tempVec4a$4[0] = obb[i + 0];
-            tempVec4a$4[1] = obb[i + 1];
-            tempVec4a$4[2] = obb[i + 2];
-            math.transformPoint4(meshMatrix, tempVec4a$4, tempVec4b$4);
+            tempVec4a$6[0] = obb[i + 0];
+            tempVec4a$6[1] = obb[i + 1];
+            tempVec4a$6[2] = obb[i + 2];
+            math.transformPoint4(meshMatrix, tempVec4a$6, tempVec4b$6);
             if (worldMatrix) {
-                math.transformPoint4(worldMatrix, tempVec4b$4, tempVec4c$4);
+                math.transformPoint4(worldMatrix, tempVec4b$6, tempVec4c$4);
                 math.expandAABB3Point3(worldAABB, tempVec4c$4);
             } else {
-                math.expandAABB3Point3(worldAABB, tempVec4b$4);
+                math.expandAABB3Point3(worldAABB, tempVec4b$6);
             }
         }
 
@@ -58631,8 +58736,8 @@ class PointsBatchingBuffer {
 
 const tempVec3a$g = math.vec4();
 const tempVec3b$5 = math.vec4();
-const tempVec4a$3 = math.vec4([0, 0, 0, 1]);
-const tempVec4b$3 = math.vec4([0, 0, 0, 1]);
+const tempVec4a$5 = math.vec4([0, 0, 0, 1]);
+const tempVec4b$5 = math.vec4([0, 0, 0, 1]);
 const tempVec4c$3 = math.vec4([0, 0, 0, 1]);
 const tempOBB3 = math.OBB3();
 
@@ -58794,23 +58899,23 @@ class PointsBatchingLayer {
 
                 for (let i = positionsBase, len = positionsBase + lenPositions; i < len; i += 3) {
 
-                    tempVec4a$3[0] = buffer.positions[i + 0];
-                    tempVec4a$3[1] = buffer.positions[i + 1];
-                    tempVec4a$3[2] = buffer.positions[i + 2];
+                    tempVec4a$5[0] = buffer.positions[i + 0];
+                    tempVec4a$5[1] = buffer.positions[i + 1];
+                    tempVec4a$5[2] = buffer.positions[i + 2];
 
-                    math.transformPoint4(meshMatrix, tempVec4a$3, tempVec4b$3);
+                    math.transformPoint4(meshMatrix, tempVec4a$5, tempVec4b$5);
 
-                    buffer.positions[i + 0] = tempVec4b$3[0];
-                    buffer.positions[i + 1] = tempVec4b$3[1];
-                    buffer.positions[i + 2] = tempVec4b$3[2];
+                    buffer.positions[i + 0] = tempVec4b$5[0];
+                    buffer.positions[i + 1] = tempVec4b$5[1];
+                    buffer.positions[i + 2] = tempVec4b$5[2];
 
-                    math.expandAABB3Point3(this._modelAABB, tempVec4b$3);
+                    math.expandAABB3Point3(this._modelAABB, tempVec4b$5);
 
                     if (worldMatrix) {
-                        math.transformPoint4(worldMatrix, tempVec4b$3, tempVec4c$3);
+                        math.transformPoint4(worldMatrix, tempVec4b$5, tempVec4c$3);
                         math.expandAABB3Point3(worldAABB, tempVec4c$3);
                     } else {
-                        math.expandAABB3Point3(worldAABB, tempVec4b$3);
+                        math.expandAABB3Point3(worldAABB, tempVec4b$5);
                     }
                 }
 
@@ -58818,17 +58923,17 @@ class PointsBatchingLayer {
 
                 for (let i = positionsBase, len = positionsBase + lenPositions; i < len; i += 3) {
 
-                    tempVec4a$3[0] = buffer.positions[i + 0];
-                    tempVec4a$3[1] = buffer.positions[i + 1];
-                    tempVec4a$3[2] = buffer.positions[i + 2];
+                    tempVec4a$5[0] = buffer.positions[i + 0];
+                    tempVec4a$5[1] = buffer.positions[i + 1];
+                    tempVec4a$5[2] = buffer.positions[i + 2];
 
-                    math.expandAABB3Point3(this._modelAABB, tempVec4a$3);
+                    math.expandAABB3Point3(this._modelAABB, tempVec4a$5);
 
                     if (worldMatrix) {
-                        math.transformPoint4(worldMatrix, tempVec4a$3, tempVec4b$3);
-                        math.expandAABB3Point3(worldAABB, tempVec4b$3);
+                        math.transformPoint4(worldMatrix, tempVec4a$5, tempVec4b$5);
+                        math.expandAABB3Point3(worldAABB, tempVec4b$5);
                     } else {
-                        math.expandAABB3Point3(worldAABB, tempVec4a$3);
+                        math.expandAABB3Point3(worldAABB, tempVec4a$5);
                     }
                 }
             }
@@ -62058,8 +62163,8 @@ function getPointsInstancingRenderers(scene) {
 }
 
 const tempUint8Vec4 = new Uint8Array(4);
-const tempVec4a$2 = math.vec4([0, 0, 0, 1]);
-const tempVec4b$2 = math.vec4([0, 0, 0, 1]);
+const tempVec4a$4 = math.vec4([0, 0, 0, 1]);
+const tempVec4b$4 = math.vec4([0, 0, 0, 1]);
 const tempVec4c$2 = math.vec4([0, 0, 0, 1]);
 const tempVec3fa = new Float32Array(3);
 
@@ -62252,15 +62357,15 @@ class PointsInstancingLayer {
         const obb = this._state.obb;
         const lenPositions = obb.length;
         for (let i = 0; i < lenPositions; i += 4) {
-            tempVec4a$2[0] = obb[i + 0];
-            tempVec4a$2[1] = obb[i + 1];
-            tempVec4a$2[2] = obb[i + 2];
-            math.transformPoint4(meshMatrix, tempVec4a$2, tempVec4b$2);
+            tempVec4a$4[0] = obb[i + 0];
+            tempVec4a$4[1] = obb[i + 1];
+            tempVec4a$4[2] = obb[i + 2];
+            math.transformPoint4(meshMatrix, tempVec4a$4, tempVec4b$4);
             if (worldMatrix) {
-                math.transformPoint4(worldMatrix, tempVec4b$2, tempVec4c$2);
+                math.transformPoint4(worldMatrix, tempVec4b$4, tempVec4c$2);
                 math.expandAABB3Point3(worldAABB, tempVec4c$2);
             } else {
-                math.expandAABB3Point3(worldAABB, tempVec4b$2);
+                math.expandAABB3Point3(worldAABB, tempVec4b$4);
             }
         }
 
@@ -63786,6 +63891,14 @@ class PerformanceModel extends Component {
         return true;
     }
 
+    /**
+     * Returns the {@link Entity}s in this PerformanceModel.
+     * @returns {*|{}}
+     */
+    get objects() {
+        return this._nodes;
+    }
+
     /**
      * Gets the 3D World-space origin for this PerformanceModel.
      *
@@ -65045,6 +65158,12 @@ class PerformanceModel extends Component {
             node._finalize();
         }
 
+        for (let i = 0, len = this._nodeList.length; i < len; i++) {
+            const node = this._nodeList[i];
+            node._finalize2();
+        }
+
+
         // Sort layers to reduce WebGL shader switching when rendering them
 
         this._layerList.sort((a, b) => {
@@ -88556,6 +88675,9 @@ if (!pako$1.inflate) {  // See https://github.com/nodeca/pako/issues/97
     pako$1 = pako$1.default;
 }
 
+const tempVec4a$3 = math.vec4();
+const tempVec4b$3 = math.vec4();
+
 function extract$1(elements) {
 
     return {
@@ -88658,10 +88780,10 @@ const decompressColor$1 = (function () {
 
 function convertColorsRGBToRGBA(colorsRGB) {
     const colorsRGBA = [];
-    for (let i = 0, len = colorsRGB.length; i < len; i+=3) {
+    for (let i = 0, len = colorsRGB.length; i < len; i += 3) {
         colorsRGBA.push(colorsRGB[i]);
-        colorsRGBA.push(colorsRGB[i+1]);
-        colorsRGBA.push(colorsRGB[i+2]);
+        colorsRGBA.push(colorsRGB[i + 1]);
+        colorsRGBA.push(colorsRGB[i + 2]);
         colorsRGBA.push(1.0);
     }
     return colorsRGBA;
@@ -88765,6 +88887,8 @@ function load$1(viewer, options, inflatedData, performanceModel) {
     const tileCenter = math.vec3();
     const rtcAABB = math.AABB3();
 
+    const geometryArraysCache = {};
+
     for (let tileIndex = 0; tileIndex < numTiles; tileIndex++) {
 
         const lastTileIndex = (numTiles - 1);
@@ -88788,7 +88912,7 @@ function load$1(viewer, options, inflatedData, performanceModel) {
 
         const tileDecodeMatrix = geometryCompressionUtils.createPositionsDecodeMatrix(rtcAABB);
 
-        const geometryCreated = {};
+        const geometryCreatedInTile = {};
 
         // Iterate over each tile's entities
 
@@ -88880,82 +89004,139 @@ function load$1(viewer, options, inflatedData, performanceModel) {
 
                     const geometryId = "geometry." + tileIndex + "." + geometryIndex; // These IDs are local to the PerformanceModel
 
-                    if (!geometryCreated[geometryId]) {
+                    let geometryArrays = geometryArraysCache[geometryId];
+
+                    if (!geometryArrays) {
+
+                        geometryArrays = {
+                            batchThisMesh: (!options.reuseGeometries)
+                        };
 
                         const primitiveType = eachGeometryPrimitiveType[geometryIndex];
 
-                        let primitiveName;
-                        let geometryPositions;
-                        let geometryNormals;
-                        let geometryColors;
-                        let geometryIndices;
-                        let geometryEdgeIndices;
                         let geometryValid = false;
 
                         switch (primitiveType) {
                             case 0:
-                                primitiveName = "solid";
-                                geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
-                                geometryNormals = normals.subarray(eachGeometryNormalsPortion [geometryIndex], atLastGeometry ? normals.length : eachGeometryNormalsPortion [geometryIndex + 1]);
-                                geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
-                                geometryEdgeIndices = edgeIndices.subarray(eachGeometryEdgeIndicesPortion [geometryIndex], atLastGeometry ? edgeIndices.length : eachGeometryEdgeIndicesPortion [geometryIndex + 1]);
-                                geometryValid = (geometryPositions.length > 0 && geometryIndices.length > 0);
+                                geometryArrays.primitiveName = "solid";
+                                geometryArrays.geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
+                                geometryArrays.geometryNormals = normals.subarray(eachGeometryNormalsPortion [geometryIndex], atLastGeometry ? normals.length : eachGeometryNormalsPortion [geometryIndex + 1]);
+                                geometryArrays.geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
+                                geometryArrays.geometryEdgeIndices = edgeIndices.subarray(eachGeometryEdgeIndicesPortion [geometryIndex], atLastGeometry ? edgeIndices.length : eachGeometryEdgeIndicesPortion [geometryIndex + 1]);
+                                geometryValid = (geometryArrays.geometryPositions.length > 0 && geometryArrays.geometryIndices.length > 0);
                                 break;
                             case 1:
-                                primitiveName = "surface";
-                                geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
-                                geometryNormals = normals.subarray(eachGeometryNormalsPortion [geometryIndex], atLastGeometry ? normals.length : eachGeometryNormalsPortion [geometryIndex + 1]);
-                                geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
-                                geometryEdgeIndices = edgeIndices.subarray(eachGeometryEdgeIndicesPortion [geometryIndex], atLastGeometry ? edgeIndices.length : eachGeometryEdgeIndicesPortion [geometryIndex + 1]);
-                                geometryValid = (geometryPositions.length > 0 && geometryIndices.length > 0);
+                                geometryArrays.primitiveName = "surface";
+                                geometryArrays.geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
+                                geometryArrays.geometryNormals = normals.subarray(eachGeometryNormalsPortion [geometryIndex], atLastGeometry ? normals.length : eachGeometryNormalsPortion [geometryIndex + 1]);
+                                geometryArrays.geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
+                                geometryArrays.geometryEdgeIndices = edgeIndices.subarray(eachGeometryEdgeIndicesPortion [geometryIndex], atLastGeometry ? edgeIndices.length : eachGeometryEdgeIndicesPortion [geometryIndex + 1]);
+                                geometryValid = (geometryArrays.geometryPositions.length > 0 && geometryArrays.geometryIndices.length > 0);
                                 break;
                             case 2:
-                                primitiveName = "points";
-                                geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
-                                geometryColors = convertColorsRGBToRGBA(colors.subarray(eachGeometryColorsPortion [geometryIndex], atLastGeometry ? colors.length : eachGeometryColorsPortion [geometryIndex + 1]));
-                                geometryValid = (geometryPositions.length > 0);
+                                geometryArrays.primitiveName = "points";
+                                geometryArrays.geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
+                                geometryArrays.geometryColors = convertColorsRGBToRGBA(colors.subarray(eachGeometryColorsPortion [geometryIndex], atLastGeometry ? colors.length : eachGeometryColorsPortion [geometryIndex + 1]));
+                                geometryValid = (geometryArrays.geometryPositions.length > 0);
                                 break;
                             case 3:
-                                primitiveName = "lines";
-                                geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
-                                geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
-                                geometryValid = (geometryPositions.length > 0 && geometryIndices.length > 0);
+                                geometryArrays.primitiveName = "lines";
+                                geometryArrays.geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
+                                geometryArrays.geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
+                                geometryValid = (geometryArrays.geometryPositions.length > 0 && geometryArrays.geometryIndices.length > 0);
                                 break;
                             default:
                                 continue;
                         }
 
-                        if (geometryValid) {
-
-                            performanceModel.createGeometry({
-                                id: geometryId,
-                                origin: tileCenter,
-                                primitive: primitiveName,
-                                positions: geometryPositions,
-                                normals: geometryNormals,
-                                colorsCompressed: geometryColors,
-                                indices: geometryIndices,
-                                edgeIndices: geometryEdgeIndices,
-                                positionsDecodeMatrix: reusedGeometriesDecodeMatrix
-                            });
+                        if (!geometryValid) {
+                            geometryArrays = null;
+                        }
 
-                            geometryCreated[geometryId] = true;
+                        if (geometryArrays) {
+                            if (geometryArrays.geometryPositions.length > 1000) ;
+                            if (geometryArrays.batchThisMesh) {
+                                geometryArrays.decompressedPositions = new Float32Array(geometryArrays.geometryPositions.length);
+                                const geometryPositions = geometryArrays.geometryPositions;
+                                const decompressedPositions = geometryArrays.decompressedPositions;
+                                for (let i = 0, len = geometryPositions.length; i < len; i += 3) {
+                                    decompressedPositions[i + 0] = geometryPositions[i + 0] * reusedGeometriesDecodeMatrix[0] + reusedGeometriesDecodeMatrix[12];
+                                    decompressedPositions[i + 1] = geometryPositions[i + 1] * reusedGeometriesDecodeMatrix[5] + reusedGeometriesDecodeMatrix[13];
+                                    decompressedPositions[i + 2] = geometryPositions[i + 2] * reusedGeometriesDecodeMatrix[10] + reusedGeometriesDecodeMatrix[14];
+                                }
+                                geometryArrays.geometryPositions = null;
+                                geometryArraysCache[geometryId] = geometryArrays;
+                            }
                         }
                     }
 
-                    if (geometryCreated[geometryId]) {
+                    if (geometryArrays) {
+
+                        if (geometryArrays.batchThisMesh) {
+
+                            const decompressedPositions = geometryArrays.decompressedPositions;
+                            const positions = new Uint16Array(decompressedPositions.length);
+                            for (let i = 0, len = decompressedPositions.length; i < len; i += 3) {
+                                tempVec4a$3[0] = decompressedPositions[i + 0];
+                                tempVec4a$3[1] = decompressedPositions[i + 1];
+                                tempVec4a$3[2] = decompressedPositions[i + 2];
+                                tempVec4a$3[3] = 1;
+                                math.transformVec4(meshMatrix, tempVec4a$3, tempVec4b$3);
+                                geometryCompressionUtils.compressPosition(tempVec4b$3, rtcAABB, tempVec4a$3);
+                                positions[i + 0] = tempVec4a$3[0];
+                                positions[i + 1] = tempVec4a$3[1];
+                                positions[i + 2] = tempVec4a$3[2];
+                            }
 
-                        performanceModel.createMesh(utils.apply(meshDefaults, {
-                            id: meshId,
-                            geometryId: geometryId,
-                            matrix: meshMatrix,
-                            color: meshColor,
-                            metallic: meshMetallic,
-                            roughness: meshRoughness,
-                            opacity: meshOpacity
-                        }));
+                            performanceModel.createMesh(utils.apply(meshDefaults, {
+                                id: meshId,
+                                origin: tileCenter,
+                                primitive: geometryArrays.primitiveName,
+                                positions: positions,
+                                normals: geometryArrays.geometryNormals,
+                                colorsCompressed: geometryArrays.geometryColors,
+                                indices: geometryArrays.geometryIndices,
+                                edgeIndices: geometryArrays.geometryEdgeIndices,
+                                positionsDecodeMatrix: tileDecodeMatrix,
+                                color: meshColor,
+                                metallic: meshMetallic,
+                                roughness: meshRoughness,
+                                opacity: meshOpacity
+                            }));
+
+                            meshIds.push(meshId);
 
-                        meshIds.push(meshId);
+                        } else {
+
+                            if (!geometryCreatedInTile[geometryId]) {
+
+                                performanceModel.createGeometry({
+                                    id: geometryId,
+                                    origin: tileCenter,
+                                    primitive: geometryArrays.primitiveName,
+                                    positions: geometryArrays.geometryPositions,
+                                    normals: geometryArrays.geometryNormals,
+                                    colorsCompressed: geometryArrays.geometryColors,
+                                    indices: geometryArrays.geometryIndices,
+                                    edgeIndices: geometryArrays.geometryEdgeIndices,
+                                    positionsDecodeMatrix: reusedGeometriesDecodeMatrix
+                                });
+
+                                geometryCreatedInTile[geometryId] = true;
+                            }
+
+                            performanceModel.createMesh(utils.apply(meshDefaults, {
+                                id: meshId,
+                                geometryId: geometryId,
+                                matrix: meshMatrix,
+                                color: meshColor,
+                                metallic: meshMetallic,
+                                roughness: meshRoughness,
+                                opacity: meshOpacity
+                            }));
+
+                            meshIds.push(meshId);
+                        }
                     }
 
                 } else {
@@ -89059,6 +89240,9 @@ if (!pako.inflate) {  // See https://github.com/nodeca/pako/issues/97
     pako = pako.default;
 }
 
+const tempVec4a$2 = math.vec4();
+const tempVec4b$2 = math.vec4();
+
 function extract(elements) {
 
     return {
@@ -89223,6 +89407,8 @@ function load(viewer, options, inflatedData, performanceModel) {
     const tileCenter = math.vec3();
     const rtcAABB = math.AABB3();
 
+    const geometryArraysCache = {};
+
     for (let tileIndex = 0; tileIndex < numTiles; tileIndex++) {
 
         const lastTileIndex = (numTiles - 1);
@@ -89246,7 +89432,7 @@ function load(viewer, options, inflatedData, performanceModel) {
 
         const tileDecodeMatrix = geometryCompressionUtils.createPositionsDecodeMatrix(rtcAABB);
 
-        const geometryCreated = {};
+        const geometryCreatedInTile = {};
 
         // Iterate over each tile's entities
 
@@ -89336,82 +89522,136 @@ function load(viewer, options, inflatedData, performanceModel) {
 
                     const geometryId = "geometry." + tileIndex + "." + geometryIndex; // These IDs are local to the PerformanceModel
 
-                    if (!geometryCreated[geometryId]) {
+                    let geometryArrays = geometryArraysCache[geometryId];
 
+                    if (!geometryArrays) {
+                        geometryArrays = {
+                            batchThisMesh: (!options.reuseGeometries)
+                        };
                         const primitiveType = eachGeometryPrimitiveType[geometryIndex];
-
-                        let primitiveName;
-                        let geometryPositions;
-                        let geometryNormals;
-                        let geometryColors;
-                        let geometryIndices;
-                        let geometryEdgeIndices;
                         let geometryValid = false;
-
                         switch (primitiveType) {
                             case 0:
-                                primitiveName = "solid";
-                                geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
-                                geometryNormals = normals.subarray(eachGeometryNormalsPortion [geometryIndex], atLastGeometry ? normals.length : eachGeometryNormalsPortion [geometryIndex + 1]);
-                                geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
-                                geometryEdgeIndices = edgeIndices.subarray(eachGeometryEdgeIndicesPortion [geometryIndex], atLastGeometry ? edgeIndices.length : eachGeometryEdgeIndicesPortion [geometryIndex + 1]);
-                                geometryValid = (geometryPositions.length > 0 && geometryIndices.length > 0);
+                                geometryArrays.primitiveName = "solid";
+                                geometryArrays.geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
+                                geometryArrays.geometryNormals = normals.subarray(eachGeometryNormalsPortion [geometryIndex], atLastGeometry ? normals.length : eachGeometryNormalsPortion [geometryIndex + 1]);
+                                geometryArrays.geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
+                                geometryArrays.geometryEdgeIndices = edgeIndices.subarray(eachGeometryEdgeIndicesPortion [geometryIndex], atLastGeometry ? edgeIndices.length : eachGeometryEdgeIndicesPortion [geometryIndex + 1]);
+                                geometryValid = (geometryArrays.geometryPositions.length > 0 && geometryArrays.geometryIndices.length > 0);
                                 break;
                             case 1:
-                                primitiveName = "surface";
-                                geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
-                                geometryNormals = normals.subarray(eachGeometryNormalsPortion [geometryIndex], atLastGeometry ? normals.length : eachGeometryNormalsPortion [geometryIndex + 1]);
-                                geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
-                                geometryEdgeIndices = edgeIndices.subarray(eachGeometryEdgeIndicesPortion [geometryIndex], atLastGeometry ? edgeIndices.length : eachGeometryEdgeIndicesPortion [geometryIndex + 1]);
-                                geometryValid = (geometryPositions.length > 0 && geometryIndices.length > 0);
+                                geometryArrays.primitiveName = "surface";
+                                geometryArrays.geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
+                                geometryArrays.geometryNormals = normals.subarray(eachGeometryNormalsPortion [geometryIndex], atLastGeometry ? normals.length : eachGeometryNormalsPortion [geometryIndex + 1]);
+                                geometryArrays.geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
+                                geometryArrays.geometryEdgeIndices = edgeIndices.subarray(eachGeometryEdgeIndicesPortion [geometryIndex], atLastGeometry ? edgeIndices.length : eachGeometryEdgeIndicesPortion [geometryIndex + 1]);
+                                geometryValid = (geometryArrays.geometryPositions.length > 0 && geometryArrays.geometryIndices.length > 0);
                                 break;
                             case 2:
-                                primitiveName = "points";
-                                geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
-                                geometryColors = colors.subarray(eachGeometryColorsPortion [geometryIndex], atLastGeometry ? colors.length : eachGeometryColorsPortion [geometryIndex + 1]);
-                                geometryValid = (geometryPositions.length > 0);
+                                geometryArrays.primitiveName = "points";
+                                geometryArrays.geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
+                                geometryArrays.geometryColors = colors.subarray(eachGeometryColorsPortion [geometryIndex], atLastGeometry ? colors.length : eachGeometryColorsPortion [geometryIndex + 1]);
+                                geometryValid = (geometryArrays.geometryPositions.length > 0);
                                 break;
                             case 3:
-                                primitiveName = "lines";
-                                geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
-                                geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
-                                geometryValid = (geometryPositions.length > 0 && geometryIndices.length > 0);
+                                geometryArrays.primitiveName = "lines";
+                                geometryArrays.geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
+                                geometryArrays.geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
+                                geometryValid = (geometryArrays.geometryPositions.length > 0 && geometryArrays.geometryIndices.length > 0);
                                 break;
                             default:
                                 continue;
                         }
 
-                        if (geometryValid) {
-
-                            performanceModel.createGeometry({
-                                id: geometryId,
-                                origin: tileCenter,
-                                primitive: primitiveName,
-                                positions: geometryPositions,
-                                normals: geometryNormals,
-                                colorsCompressed: geometryColors,
-                                indices: geometryIndices,
-                                edgeIndices: geometryEdgeIndices,
-                                positionsDecodeMatrix: reusedGeometriesDecodeMatrix
-                            });
+                        if (!geometryValid) {
+                            geometryArrays = null;
+                        }
 
-                            geometryCreated[geometryId] = true;
+                        if (geometryArrays) {
+                            if (geometryArrays.geometryPositions.length > 1000) ;
+                            if (geometryArrays.batchThisMesh) {
+                                geometryArrays.decompressedPositions = new Float32Array(geometryArrays.geometryPositions.length);
+                                const geometryPositions = geometryArrays.geometryPositions;
+                                const decompressedPositions = geometryArrays.decompressedPositions;
+                                for (let i = 0, len = geometryPositions.length; i < len; i += 3) {
+                                    decompressedPositions[i + 0] = geometryPositions[i + 0] * reusedGeometriesDecodeMatrix[0] + reusedGeometriesDecodeMatrix[12];
+                                    decompressedPositions[i + 1] = geometryPositions[i + 1] * reusedGeometriesDecodeMatrix[5] + reusedGeometriesDecodeMatrix[13];
+                                    decompressedPositions[i + 2] = geometryPositions[i + 2] * reusedGeometriesDecodeMatrix[10] + reusedGeometriesDecodeMatrix[14];
+                                }
+                                geometryArrays.geometryPositions = null;
+                                geometryArraysCache[geometryId] = geometryArrays;
+                            }
                         }
                     }
 
-                    if (geometryCreated[geometryId]) {
+                    if (geometryArrays) {
 
-                        performanceModel.createMesh(utils.apply(meshDefaults, {
-                            id: meshId,
-                            geometryId: geometryId,
-                            matrix: meshMatrix,
-                            color: meshColor,
-                            metallic: meshMetallic,
-                            roughness: meshRoughness,
-                            opacity: meshOpacity
-                        }));
+                        if (geometryArrays.batchThisMesh) {
 
-                        meshIds.push(meshId);
+                            const decompressedPositions = geometryArrays.decompressedPositions;
+                            const transformedAndRecompressedPositions = new Uint16Array(decompressedPositions.length);
+
+                            for (let i = 0, len = decompressedPositions.length; i < len; i += 3) {
+                                tempVec4a$2[0] = decompressedPositions[i + 0];
+                                tempVec4a$2[1] = decompressedPositions[i + 1];
+                                tempVec4a$2[2] = decompressedPositions[i + 2];
+                                tempVec4a$2[3] = 1;
+                                math.transformVec4(meshMatrix, tempVec4a$2, tempVec4b$2);
+                                geometryCompressionUtils.compressPosition(tempVec4b$2, rtcAABB, tempVec4a$2);
+                                transformedAndRecompressedPositions[i + 0] = tempVec4a$2[0];
+                                transformedAndRecompressedPositions[i + 1] = tempVec4a$2[1];
+                                transformedAndRecompressedPositions[i + 2] = tempVec4a$2[2];
+                            }
+
+                            performanceModel.createMesh(utils.apply(meshDefaults, {
+                                id: meshId,
+                                origin: tileCenter,
+                                primitive: geometryArrays.primitiveName,
+                                positions: transformedAndRecompressedPositions,
+                                normals: geometryArrays.geometryNormals,
+                                colorsCompressed: geometryArrays.geometryColors,
+                                indices: geometryArrays.geometryIndices,
+                                edgeIndices: geometryArrays.geometryEdgeIndices,
+                                positionsDecodeMatrix: tileDecodeMatrix,
+                                color: meshColor,
+                                metallic: meshMetallic,
+                                roughness: meshRoughness,
+                                opacity: meshOpacity
+                            }));
+
+                            meshIds.push(meshId);
+
+                        } else {
+
+                            if (!geometryCreatedInTile[geometryId]) {
+
+                                performanceModel.createGeometry({
+                                    id: geometryId,
+                                    origin: tileCenter,
+                                    primitive: geometryArrays.primitiveName,
+                                    positions: geometryArrays.geometryPositions,
+                                    normals: geometryArrays.geometryNormals,
+                                    colorsCompressed: geometryArrays.geometryColors,
+                                    indices: geometryArrays.geometryIndices,
+                                    edgeIndices: geometryArrays.geometryEdgeIndices,
+                                    positionsDecodeMatrix: reusedGeometriesDecodeMatrix
+                                });
+
+                                geometryCreatedInTile[geometryId] = true;
+                            }
+
+                            performanceModel.createMesh(utils.apply(meshDefaults, {
+                                id: meshId,
+                                geometryId: geometryId,
+                                matrix: meshMatrix,
+                                color: meshColor,
+                                metallic: meshMetallic,
+                                roughness: meshRoughness,
+                                opacity: meshOpacity
+                            }));
+
+                            meshIds.push(meshId);
+                        }
                     }
 
                 } else {
@@ -89883,6 +90123,10 @@ 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
+     * 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.
      * @param {Number} [cfg.maxGeometryBatchSize=50000000] Maximum geometry batch size, as number of vertices. This is optionally supplied
      * to limit the size of the batched geometry arrays that {@link PerformanceModel} internally creates for batched geometries.
      * A low value means less heap allocation/de-allocation while loading batched geometries, but more draw calls and
@@ -89900,6 +90144,7 @@ class XKTLoaderPlugin extends Plugin {
         this.includeTypes = cfg.includeTypes;
         this.excludeTypes = cfg.excludeTypes;
         this.excludeUnclassifiedObjects = cfg.excludeUnclassifiedObjects;
+        this.reuseGeometries = cfg.reuseGeometries;
     }
 
     /**
@@ -90070,6 +90315,36 @@ class XKTLoaderPlugin extends Plugin {
         this._globalizeObjectIds = !!value;
     }
 
+    /**
+     * Gets whether XKTLoaderPlugin enables geometry reuse when loading models.
+     *
+     * Default value is ````true````.
+     *
+     * @type {Boolean}
+     */
+    get reuseGeometries() {
+        return this._reuseGeometries;
+    }
+
+    /**
+     * Sets whether XKTLoaderPlugin enables geometry reuse when loading models.
+     *
+     * Default value is ````true````.
+     *
+     * Geometry reuse saves memory, but can impact Viewer performance when there are many reused geometries. For
+     * this reason, we can set this ````false```` to disable geometry reuse for models loaded by this XKTLoaderPlugin
+     * (which will then "expand" the geometry instances into batches instead).
+     *
+     * The result will be be less WebGL draw calls (which are expensive), at the cost of increased memory footprint.
+     *
+     * See [#769](https://github.com/xeokit/xeokit-sdk/issues/769) for more info.
+     *
+     * @type {Boolean}
+     */
+    set reuseGeometries(value) {
+        this._reuseGeometries = value !== false;
+    }
+
     /**
      * Loads an ````.xkt```` model into this XKTLoaderPlugin's {@link Viewer}.
      *
@@ -90102,6 +90377,10 @@ 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
+     * browser and GPU memory used by the model. See [#769](https://github.com/xeokit/xeokit-sdk/issues/769) for more info.
      * @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 = {}) {
@@ -90129,6 +90408,8 @@ class XKTLoaderPlugin extends Plugin {
         const excludeTypes = params.excludeTypes || this._excludeTypes;
         const objectDefaults = params.objectDefaults || this._objectDefaults;
 
+        options.reuseGeometries = (params.reuseGeometries !== null && params.reuseGeometries !== undefined ) ? params.reuseGeometries : (this._reuseGeometries !== false);
+
         if (includeTypes) {
             options.includeTypesMap = {};
             for (let i = 0, len = includeTypes.length; i < len; i++) {