@xeokit/xeokit-sdk 2.6.29 → 2.6.31

package/dist/xeokit-sdk.es.js

@@ -17467,7 +17467,7 @@ class OcclusionLayer {
         for (let i = 0; i < this.numMarkers; i++) {
             if (this.markerList[i]) {
                 const marker = this.markerList[i];
-                const worldPos = marker.worldPos;
+                const worldPos = marker.rtcPos;
                 this.positions[j++] = worldPos[0];
                 this.positions[j++] = worldPos[1];
                 this.positions[j++] = worldPos[2];
@@ -17909,10 +17909,7 @@ class OcclusionTester {
                 continue;
             }
 
-            // The `origin` has been changed from `occlusionLayer.origin` to `[ 0, 0, 0 ]`
-            // because OcclusionLayer markers' transformation is being applied through the
-            // OcclusionLayer::positions array. See XEOK-33
-            const origin = [ 0, 0, 0 ];
+            const origin = occlusionLayer.origin;
 
             gl.uniformMatrix4fv(this._uViewMatrix, false, createRTCViewMat(camera.viewMatrix, origin));
 
@@ -20503,6 +20500,8 @@ const Renderer$1 = function (scene, options) {
             // result 1) regular hi-precision world position
 
             let worldPos = null;
+            let worldNormal = null;
+            let pickable = null;
 
             const middleX = snapRadiusInPixels;
             const middleY = snapRadiusInPixels;
@@ -20520,7 +20519,7 @@ const Renderer$1 = function (scene, options) {
                     pickResultMiddleXY[1] * scale[1] + origin[1],
                     pickResultMiddleXY[2] * scale[2] + origin[2],
                 ];
-                math.normalizeVec3([
+                worldNormal = math.normalizeVec3([
                     pickNormalResultMiddleXY[0] / math.MAX_INT,
                     pickNormalResultMiddleXY[1] / math.MAX_INT,
                     pickNormalResultMiddleXY[2] / math.MAX_INT,
@@ -20532,7 +20531,7 @@ const Renderer$1 = function (scene, options) {
                     + (pickPickableResultMiddleXY[2] << 16)
                     + (pickPickableResultMiddleXY[3] << 24);
 
-                pickIDs.items[pickID];
+                pickable = pickIDs.items[pickID];
             }
 
             // result 2) hi-precision snapped (to vertex/edge) world position
@@ -20629,13 +20628,16 @@ const Renderer$1 = function (scene, options) {
             }
 
             const snappedEntity = (snappedPickable && snappedPickable.delegatePickedEntity) ? snappedPickable.delegatePickedEntity() : snappedPickable;
+            if (!snappedEntity && pickable) {
+                pickable = pickable.delegatePickedEntity ? pickable.delegatePickedEntity() : pickable;
+            }
 
             pickResult.reset();
             pickResult.snappedToEdge = (snapType === "edge");
             pickResult.snappedToVertex = (snapType === "vertex");
-            pickResult.worldPos = snappedWorldPos;
-            pickResult.worldNormal = snappedWorldNormal;
-            pickResult.entity = snappedEntity;
+            pickResult.worldPos = snappedWorldPos || worldPos;
+            pickResult.worldNormal = snappedWorldNormal || worldNormal;
+            pickResult.entity = snappedEntity || pickable;
             pickResult.canvasPos = canvasPos || scene.camera.projectWorldPos(worldPos || snappedWorldPos);
             pickResult.snappedCanvasPos = snappedCanvasPos || canvasPos;
 
@@ -51502,11 +51504,12 @@ const tempMat4a$r = math.mat4();
  * @private
  */
 class VBORenderer {
-    constructor(scene, withSAO = false, {instancing = false, edges = false} = {}) {
+    constructor(scene, withSAO = false, {instancing = false, edges = false, useAlphaCutoff = false} = {}) {
         this._scene = scene;
         this._withSAO = withSAO;
         this._instancing = instancing;
         this._edges = edges;
+        this._useAlphaCutoff = useAlphaCutoff;
         this._hash = this._getHash();
 
         /**
@@ -51757,6 +51760,10 @@ class VBORenderer {
             this._uSAOParams = program.getLocation("uSAOParams");
         }
 
+        if (this._useAlphaCutoff) {
+            this._alphaCutoffLocation = program.getLocation("materialAlphaCutoff");
+        }
+
         if (scene.logarithmicDepthBufferEnabled) {
             this._uLogDepthBufFC = program.getLocation("logDepthBufFC");
         }
@@ -52094,6 +52101,10 @@ class VBORenderer {
             }
         }
 
+        if (this._useAlphaCutoff) {
+            gl.uniform1f(this._alphaCutoffLocation, textureSet.alphaCutoff);
+        }
+
         if (colorUniform) {
             const colorKey = this._edges ? "edgeColor" : "fillColor";
             const alphaKey = this._edges ? "edgeAlpha" : "fillAlpha";
@@ -52144,8 +52155,8 @@ class VBORenderer {
  */
 class TrianglesBatchingRenderer extends VBORenderer {
 
-    constructor(scene, withSAO, {edges = false} = {}) {
-        super(scene, withSAO, {instancing: false, edges});
+    constructor(scene, withSAO, {edges = false, useAlphaCutoff = false} = {}) {
+        super(scene, withSAO, {instancing: false, edges, useAlphaCutoff});
     }
 
     _draw(drawCfg) {
@@ -52162,7 +52173,6 @@ class TrianglesBatchingRenderer extends VBORenderer {
         } else {
             const count = frameCtx.pickElementsCount || state.indicesBuf.numItems;
             const offset = frameCtx.pickElementsOffset ? frameCtx.pickElementsOffset * state.indicesBuf.itemByteSize : 0;
-
             gl.drawElements(gl.TRIANGLES, count, state.indicesBuf.itemType, offset);
 
             if (incrementDrawState) {
@@ -54615,6 +54625,7 @@ class TrianglesPickNormalsFlatRenderer$1 extends TrianglesBatchingRenderer {
 /**
  * @private
  */
+
 class TrianglesColorTextureRenderer$1 extends TrianglesBatchingRenderer {
     _getHash() {
         const scene = this._scene;
@@ -54622,11 +54633,10 @@ class TrianglesColorTextureRenderer$1 extends TrianglesBatchingRenderer {
     }
 
     drawLayer(frameCtx, layer, renderPass) {
-        super.drawLayer(frameCtx, layer, renderPass, {incrementDrawState: true});
+        super.drawLayer(frameCtx, layer, renderPass, { incrementDrawState: true });
     }
 
     _buildVertexShader() {
-
         const scene = this._scene;
         const sectionPlanesState = scene._sectionPlanesState;
         const clipping = sectionPlanesState.getNumAllocatedSectionPlanes() > 0;
@@ -54681,6 +54691,7 @@ class TrianglesColorTextureRenderer$1 extends TrianglesBatchingRenderer {
         if (scene.entityOffsetsEnabled) {
             src.push("worldPosition.xyz = worldPosition.xyz + offset;");
         }
+
         src.push("vec4 viewPosition  = viewMatrix * worldPosition; ");
         src.push("vViewPosition = viewPosition;");
         src.push("vColor = vec4(float(color.r) / 255.0, float(color.g) / 255.0, float(color.b) / 255.0, float(color.a) / 255.0);");
@@ -54691,10 +54702,12 @@ class TrianglesColorTextureRenderer$1 extends TrianglesBatchingRenderer {
             src.push("vFragDepth = 1.0 + clipPos.w;");
             src.push("isPerspective = float (isPerspectiveMatrix(projMatrix));");
         }
+
         if (clipping) {
             src.push("vWorldPosition = worldPosition;");
             src.push("vFlags = flags;");
         }
+
         src.push("gl_Position = clipPos;");
         src.push("}");
         src.push("}");
@@ -54707,6 +54720,7 @@ class TrianglesColorTextureRenderer$1 extends TrianglesBatchingRenderer {
         const lightsState = scene._lightsState;
         const sectionPlanesState = scene._sectionPlanesState;
         const clipping = sectionPlanesState.getNumAllocatedSectionPlanes() > 0;
+        const useAlphaCutoff = this._useAlphaCutoff;
         const src = [];
         src.push("#version 300 es");
         src.push("// Triangles batching color texture fragment shader");
@@ -54765,6 +54779,7 @@ class TrianglesColorTextureRenderer$1 extends TrianglesBatchingRenderer {
             src.push("uniform vec4 sliceColor;");
         }
         this._addMatricesUniformBlockLines(src);
+
         src.push("uniform vec4 lightAmbient;");
         for (let i = 0, len = lightsState.lights.length; i < len; i++) {
             const light = lightsState.lights[i];
@@ -54784,6 +54799,10 @@ class TrianglesColorTextureRenderer$1 extends TrianglesBatchingRenderer {
             }
         }
 
+        if (useAlphaCutoff) {
+            src.push("uniform float materialAlphaCutoff;");
+        }
+
         src.push("in vec4 vViewPosition;");
         src.push("in vec4 vColor;");
         src.push("in vec2 vUV;");
@@ -54851,11 +54870,21 @@ class TrianglesColorTextureRenderer$1 extends TrianglesBatchingRenderer {
         }
 
         src.push("vec4 color =  vec4((lightAmbient.rgb * lightAmbient.a * newColor.rgb) + (reflectedColor * newColor.rgb), newColor.a);");
+
+        src.push("vec4 sampleColor = texture(uColorMap, vUV);");
+
+        if (useAlphaCutoff) {
+            src.push("if (sampleColor.a < materialAlphaCutoff) {");
+            src.push("   discard;");
+            src.push("}");
+        }
+
         if (gammaOutput) {
-            src.push("vec4 colorTexel = color * sRGBToLinear(texture(uColorMap, vUV));");
-        } else {
-            src.push("vec4 colorTexel = color * texture(uColorMap, vUV);");
+            src.push("sampleColor = sRGBToLinear(sampleColor);");
         }
+
+        src.push("vec4 colorTexel = color * sampleColor;");
+
         src.push("float opacity = color.a;");
 
         if (this._withSAO) {
@@ -55402,7 +55431,7 @@ class TrianglesSnapRenderer$1 extends VBORenderer{
 
         src.push(`int pickFlag = int(flags) >> 12 & 0xF;`);
         src.push(`if (pickFlag != renderPass) {`);
-        src.push("      gl_Position = vec4(0.0, 0.0, 0.0, 0.0);"); // Cull vertex
+        src.push("      gl_Position = vec4(2.0, 0.0, 0.0, 0.0);"); // Cull vertex
         src.push("  } else {");
         src.push("      vec4 worldPosition = worldMatrix * (positionsDecodeMatrix * vec4(position, 1.0)); ");
         if (scene.entityOffsetsEnabled) {
@@ -55529,6 +55558,14 @@ class Renderers$1 {
             this._colorTextureRendererWithSAO.destroy();
             this._colorTextureRendererWithSAO = null;
         }
+        if (this._colorTextureRendererAlphaCutoff && (!this._colorTextureRendererAlphaCutoff.getValid())) {
+            this._colorTextureRendererAlphaCutoff.destroy();
+            this._colorTextureRendererAlphaCutoff = null;
+        }
+        if (this._colorTextureRendererWithSAOAlphaCutoff && (!this._colorTextureRendererWithSAOAlphaCutoff.getValid())) {
+            this._colorTextureRendererWithSAOAlphaCutoff.destroy();
+            this._colorTextureRendererWithSAOAlphaCutoff = null;
+        }
         if (this._pbrRenderer && (!this._pbrRenderer.getValid())) {
             this._pbrRenderer.destroy();
             this._pbrRenderer = null;
@@ -55656,6 +55693,20 @@ class Renderers$1 {
         return this._colorTextureRendererWithSAO;
     }
 
+    get colorTextureRendererAlphaCutoff() {
+        if (!this._colorTextureRendererAlphaCutoff) {
+            this._colorTextureRendererAlphaCutoff = new TrianglesColorTextureRenderer$1(this._scene, false, { useAlphaCutoff: true });
+        }
+        return this._colorTextureRendererAlphaCutoff;
+    }
+
+    get colorTextureRendererWithSAOAlphaCutoff() {
+        if (!this._colorTextureRendererWithSAOAlphaCutoff) {
+            this._colorTextureRendererWithSAOAlphaCutoff = new TrianglesColorTextureRenderer$1(this._scene, true, { useAlphaCutoff: true });
+        }
+        return this._colorTextureRendererWithSAOAlphaCutoff;
+    }
+
     get pbrRenderer() {
         if (!this._pbrRenderer) {
             this._pbrRenderer = new TrianglesPBRRenderer$1(this._scene, false);
@@ -55780,6 +55831,12 @@ class Renderers$1 {
         if (this._colorTextureRendererWithSAO) {
             this._colorTextureRendererWithSAO.destroy();
         }
+        if (this._colorTextureRendererAlphaCutoff) {
+            this._colorTextureRendererAlphaCutoff.destroy();
+        }
+        if (this._colorTextureRendererWithSAOAlphaCutoff) {
+            this._colorTextureRendererWithSAOAlphaCutoff.destroy();
+        }
         if (this._pbrRenderer) {
             this._pbrRenderer.destroy();
         }
@@ -55828,29 +55885,29 @@ class Renderers$1 {
     }
 }
 
-const cachdRenderers$1 = {};
+const cachedRenderers$6 = {};
 
 /**
  * @private
  */
 function getRenderers$7(scene) {
     const sceneId = scene.id;
-    let batchingRenderers = cachdRenderers$1[sceneId];
-    if (!batchingRenderers) {
-        batchingRenderers = new Renderers$1(scene);
-        cachdRenderers$1[sceneId] = batchingRenderers;
-        batchingRenderers._compile();
-        batchingRenderers.eagerCreateRenders();
+    let renderers = cachedRenderers$6[sceneId];
+    if (!renderers) {
+        renderers = new Renderers$1(scene);
+        cachedRenderers$6[sceneId] = renderers;
+        renderers._compile();
+        renderers.eagerCreateRenders();
         scene.on("compile", () => {
-            batchingRenderers._compile();
-            batchingRenderers.eagerCreateRenders();
+            renderers._compile();
+            renderers.eagerCreateRenders();
         });
         scene.on("destroyed", () => {
-            delete cachdRenderers$1[sceneId];
-            batchingRenderers._destroy();
+            delete cachedRenderers$6[sceneId];
+            renderers._destroy();
         });
     }
-    return batchingRenderers;
+    return renderers;
 }
 
 let maxDataTextureHeight = 1 << 16;
@@ -57014,14 +57071,21 @@ class VBOBatchingTrianglesLayer {
             return;
         }
         this._updateBackfaceCull(renderFlags, frameCtx);
+        const useAlphaCutoff = this._state.textureSet && (typeof(this._state.textureSet.alphaCutoff) === "number");
         if (frameCtx.withSAO && this.model.saoEnabled) {
             if (frameCtx.pbrEnabled && this.model.pbrEnabled && this._state.pbrSupported) {
                 if (this._renderers.pbrRendererWithSAO) {
                     this._renderers.pbrRendererWithSAO.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
                 }
             } else if (frameCtx.colorTextureEnabled && this.model.colorTextureEnabled && this._state.colorTextureSupported) {
-                if (this._renderers.colorTextureRendererWithSAO) {
-                    this._renderers.colorTextureRendererWithSAO.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                if (useAlphaCutoff) {
+                    if (this._renderers.colorTextureRendererWithSAOAlphaCutoff) {
+                        this._renderers.colorTextureRendererWithSAOAlphaCutoff.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                    }
+                } else {
+                    if (this._renderers.colorTextureRendererWithSAO) {
+                        this._renderers.colorTextureRendererWithSAO.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                    }
                 }
             } else if (this._state.normalsBuf) {
                 if (this._renderers.colorRendererWithSAO) {
@@ -57038,8 +57102,14 @@ class VBOBatchingTrianglesLayer {
                     this._renderers.pbrRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
                 }
             } else if (frameCtx.colorTextureEnabled && this.model.colorTextureEnabled && this._state.colorTextureSupported) {
-                if (this._renderers.colorTextureRenderer) {
-                    this._renderers.colorTextureRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                if (useAlphaCutoff) {
+                    if (this._renderers.colorTextureRendererAlphaCutoff) {
+                        this._renderers.colorTextureRendererAlphaCutoff.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                    }
+                } else {
+                    if (this._renderers.colorTextureRenderer) {
+                        this._renderers.colorTextureRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                    }
                 }
             } else if (this._state.normalsBuf) {
                 if (this._renderers.colorRenderer) {
@@ -57076,8 +57146,15 @@ class VBOBatchingTrianglesLayer {
                 this._renderers.pbrRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_TRANSPARENT);
             }
         } else if (frameCtx.colorTextureEnabled && this.model.colorTextureEnabled && this._state.colorTextureSupported) {
-            if (this._renderers.colorTextureRenderer) {
-                this._renderers.colorTextureRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_TRANSPARENT);
+            const useAlphaCutoff = this._state.textureSet && (typeof(this._state.textureSet.alphaCutoff) === "number");
+            if (useAlphaCutoff) {
+                if (this._renderers.colorTextureRendererAlphaCutoff) {
+                    this._renderers.colorTextureRendererAlphaCutoff.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_TRANSPARENT);
+                }
+            } else {
+                if (this._renderers.colorTextureRenderer) {
+                    this._renderers.colorTextureRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_TRANSPARENT);
+                }
             }
         } else if (this._state.normalsBuf) {
             if (this._renderers.colorRenderer) {
@@ -57421,8 +57498,8 @@ class VBOBatchingTrianglesLayer {
  * @private
  */
 class TrianglesInstancingRenderer extends VBORenderer {
-    constructor(scene, withSAO, {edges = false} = {}) {
-        super(scene, withSAO, {instancing: true, edges});
+    constructor(scene, withSAO, {edges = false, useAlphaCutoff = false} = {}) {
+        super(scene, withSAO, {instancing: true, edges, useAlphaCutoff});
     }
 
     _draw(drawCfg) {
@@ -57431,13 +57508,14 @@ class TrianglesInstancingRenderer extends VBORenderer {
         const {
             state,
             frameCtx,
-            incrementDrawState,
+            incrementDrawState
         } = drawCfg;
 
         if (this._edges) {
             gl.drawElementsInstanced(gl.LINES, state.edgeIndicesBuf.numItems, state.edgeIndicesBuf.itemType, 0, state.numInstances);
         } else {
             gl.drawElementsInstanced(gl.TRIANGLES, state.indicesBuf.numItems, state.indicesBuf.itemType, 0, state.numInstances);
+
             if (incrementDrawState) {
                 frameCtx.drawElements++;
             }
@@ -59966,7 +60044,6 @@ class TrianglesPickNormalsFlatRenderer extends TrianglesInstancingRenderer {
  * @private
  */
 
-
 class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
     _getHash() {
         const scene = this._scene;
@@ -60035,7 +60112,7 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
         src.push("vec4 worldPosition =  positionsDecodeMatrix * vec4(position, 1.0); ");
         src.push("worldPosition = worldMatrix * vec4(dot(worldPosition, modelMatrixCol0), dot(worldPosition, modelMatrixCol1), dot(worldPosition, modelMatrixCol2), 1.0);");
         if (scene.entityOffsetsEnabled) {
-            src.push("      worldPosition.xyz = worldPosition.xyz + offset;");
+            src.push("worldPosition.xyz = worldPosition.xyz + offset;");
         }
 
         src.push("vec4 viewPosition  = viewMatrix * worldPosition; ");
@@ -60063,11 +60140,10 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
     _buildFragmentShader() {
         const scene = this._scene;
         const gammaOutput = scene.gammaOutput; // If set, then it expects that all textures and colors need to be outputted in premultiplied gamma. Default is false.
-        const sectionPlanesState = scene._sectionPlanesState;
         const lightsState = scene._lightsState;
-        let i;
-        let len;
+        const sectionPlanesState = scene._sectionPlanesState;
         const clipping = sectionPlanesState.getNumAllocatedSectionPlanes() > 0;
+        const useAlphaCutoff = this._useAlphaCutoff;
         const src = [];
         src.push("#version 300 es");
         src.push("// Instancing geometry drawing fragment shader");
@@ -60079,6 +60155,7 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
         src.push("precision mediump float;");
         src.push("precision mediump int;");
         src.push("#endif");
+
         if (scene.logarithmicDepthBufferEnabled) {
             src.push("in float isPerspective;");
             src.push("uniform float logDepthBufFC;");
@@ -60127,7 +60204,7 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
         this._addMatricesUniformBlockLines(src);
 
         src.push("uniform vec4 lightAmbient;");
-        for (i = 0, len = lightsState.lights.length; i < len; i++) {
+        for (let i = 0, len = lightsState.lights.length; i < len; i++) {
             const light = lightsState.lights[i];
             if (light.type === "ambient") {
                 continue;
@@ -60145,6 +60222,10 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
             }
         }
 
+        if (useAlphaCutoff) {
+            src.push("uniform float materialAlphaCutoff;");
+        }
+
         src.push("in vec4 vViewPosition;");
         src.push("in vec4 vColor;");
         src.push("in vec2 vUV;");
@@ -60180,7 +60261,7 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
         src.push("vec3 yTangent = dFdy( vViewPosition.xyz );");
         src.push("vec3 viewNormal = normalize( cross( xTangent, yTangent ) );");
 
-        for (i = 0, len = lightsState.lights.length; i < len; i++) {
+        for (let i = 0, len = lightsState.lights.length; i < len; i++) {
             const light = lightsState.lights[i];
             if (light.type === "ambient") {
                 continue;
@@ -60206,16 +60287,27 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
             } else {
                 continue;
             }
+
             src.push("lambertian = max(dot(-viewNormal, viewLightDir), 0.0);");
             src.push("reflectedColor += lambertian * (lightColor" + i + ".rgb * lightColor" + i + ".a);");
         }
 
         src.push("vec4 color =  vec4((lightAmbient.rgb * lightAmbient.a * newColor.rgb) + (reflectedColor * newColor.rgb), newColor.a);");
+
+        src.push("vec4 sampleColor = texture(uColorMap, vUV);");
+
+        if (useAlphaCutoff) {
+            src.push("if (sampleColor.a < materialAlphaCutoff) {");
+            src.push("   discard;");
+            src.push("}");
+        }
+
         if (gammaOutput) {
-            src.push("vec4 colorTexel = color * sRGBToLinear(texture(uColorMap, vUV));");
-        } else {
-            src.push("vec4 colorTexel = color * texture(uColorMap, vUV);");
+            src.push("sampleColor = sRGBToLinear(sampleColor);");
         }
+
+        src.push("vec4 colorTexel = color * sampleColor;");
+
         src.push("float opacity = color.a;");
 
         if (this._withSAO) {
@@ -60227,9 +60319,10 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
             src.push("   float blendFactor       = uSAOParams[3];");
             src.push("   vec2 uv                 = vec2(gl_FragCoord.x / viewportWidth, gl_FragCoord.y / viewportHeight);");
             src.push("   float ambient           = smoothstep(blendCutoff, 1.0, unpackRGBToFloat(texture(uOcclusionTexture, uv))) * blendFactor;");
-            src.push("   outColor                = vec4(newColor.rgb * colorTexel.rgb * ambient, opacity);");
+
+            src.push("   outColor                = vec4(colorTexel.rgb * ambient, opacity);");
         } else {
-            src.push("   outColor                = vec4(newColor.rgb * colorTexel.rgb, opacity);");
+            src.push("   outColor                = vec4(colorTexel.rgb, opacity);");
         }
 
         if (gammaOutput) {
@@ -60237,7 +60330,7 @@ class TrianglesColorTextureRenderer extends TrianglesInstancingRenderer {
         }
 
         if (scene.logarithmicDepthBufferEnabled) {
-            src.push("    gl_FragDepth = isPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;");
+            src.push("gl_FragDepth = isPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;");
         }
 
         src.push("}");
@@ -60807,7 +60900,7 @@ class TrianglesSnapRenderer extends VBORenderer {
         // renderPass = PICK
         src.push(`int pickFlag = int(flags) >> 12 & 0xF;`);
         src.push(`if (pickFlag != renderPass) {`);
-        src.push("   gl_Position = vec4(0.0, 0.0, 0.0, 0.0);"); // Cull vertex
+        src.push("   gl_Position = vec4(2.0, 0.0, 0.0, 0.0);"); // Cull vertex
         src.push("} else {");
         src.push("  vec4 worldPosition = positionsDecodeMatrix * vec4(position, 1.0); ");
         src.push("  worldPosition = worldMatrix * vec4(dot(worldPosition, modelMatrixCol0), dot(worldPosition, modelMatrixCol1), dot(worldPosition, modelMatrixCol2), 1.0);");
@@ -60927,14 +61020,6 @@ class Renderers {
             this._flatColorRendererWithSAO.destroy();
             this._flatColorRendererWithSAO = null;
         }
-        if (this._pbrRenderer && (!this._pbrRenderer.getValid())) {
-            this._pbrRenderer.destroy();
-            this._pbrRenderer = null;
-        }
-        if (this._pbrRendererWithSAO && (!this._pbrRendererWithSAO.getValid())) {
-            this._pbrRendererWithSAO.destroy();
-            this._pbrRendererWithSAO = null;
-        }
         if (this._colorTextureRenderer && (!this._colorTextureRenderer.getValid())) {
             this._colorTextureRenderer.destroy();
             this._colorTextureRenderer = null;
@@ -60943,6 +61028,22 @@ class Renderers {
             this._colorTextureRendererWithSAO.destroy();
             this._colorTextureRendererWithSAO = null;
         }
+        if (this._colorTextureRendererAlphaCutoff && (!this._colorTextureRendererAlphaCutoff.getValid())) {
+            this._colorTextureRendererAlphaCutoff.destroy();
+            this._colorTextureRendererAlphaCutoff = null;
+        }
+        if (this._colorTextureRendererWithSAOAlphaCutoff && (!this._colorTextureRendererWithSAOAlphaCutoff.getValid())) {
+            this._colorTextureRendererWithSAOAlphaCutoff.destroy();
+            this._colorTextureRendererWithSAOAlphaCutoff = null;
+        }
+        if (this._pbrRenderer && (!this._pbrRenderer.getValid())) {
+            this._pbrRenderer.destroy();
+            this._pbrRenderer = null;
+        }
+        if (this._pbrRendererWithSAO && (!this._pbrRendererWithSAO.getValid())) {
+            this._pbrRendererWithSAO.destroy();
+            this._pbrRendererWithSAO = null;
+        }
         if (this._depthRenderer && (!this._depthRenderer.getValid())) {
             this._depthRenderer.destroy();
             this._depthRenderer = null;
@@ -60975,7 +61076,7 @@ class Renderers {
             this._pickNormalsRenderer.destroy();
             this._pickNormalsRenderer = null;
         }
-        if (this._pickNormalsFlatRenderer && (!this._pickNormalsFlatRenderer.getValid())) {
+        if (this._pickNormalsFlatRenderer && this._pickNormalsFlatRenderer.getValid() === false) {
             this._pickNormalsFlatRenderer.destroy();
             this._pickNormalsFlatRenderer = null;
         }
@@ -61048,20 +61149,6 @@ class Renderers {
         return this._flatColorRendererWithSAO;
     }
 
-    get pbrRenderer() {
-        if (!this._pbrRenderer) {
-            this._pbrRenderer = new TrianglesPBRRenderer(this._scene, false);
-        }
-        return this._pbrRenderer;
-    }
-
-    get pbrRendererWithSAO() {
-        if (!this._pbrRendererWithSAO) {
-            this._pbrRendererWithSAO = new TrianglesPBRRenderer(this._scene, true);
-        }
-        return this._pbrRendererWithSAO;
-    }
-
     get colorTextureRenderer() {
         if (!this._colorTextureRenderer) {
             this._colorTextureRenderer = new TrianglesColorTextureRenderer(this._scene, false);
@@ -61076,6 +61163,34 @@ class Renderers {
         return this._colorTextureRendererWithSAO;
     }
 
+    get colorTextureRendererAlphaCutoff() {
+        if (!this._colorTextureRendererAlphaCutoff) {
+            this._colorTextureRendererAlphaCutoff = new TrianglesColorTextureRenderer(this._scene, false, { useAlphaCutoff: true });
+        }
+        return this._colorTextureRendererAlphaCutoff;
+    }
+
+    get colorTextureRendererWithSAOAlphaCutoff() {
+        if (!this._colorTextureRendererWithSAOAlphaCutoff) {
+            this._colorTextureRendererWithSAOAlphaCutoff = new TrianglesColorTextureRenderer(this._scene, true, { useAlphaCutoff: true });
+        }
+        return this._colorTextureRendererWithSAOAlphaCutoff;
+    }
+
+    get pbrRenderer() {
+        if (!this._pbrRenderer) {
+            this._pbrRenderer = new TrianglesPBRRenderer(this._scene, false);
+        }
+        return this._pbrRenderer;
+    }
+
+    get pbrRendererWithSAO() {
+        if (!this._pbrRendererWithSAO) {
+            this._pbrRendererWithSAO = new TrianglesPBRRenderer(this._scene, true);
+        }
+        return this._pbrRendererWithSAO;
+    }
+
     get silhouetteRenderer() {
         if (!this._silhouetteRenderer) {
             this._silhouetteRenderer = new TrianglesSilhouetteRenderer(this._scene);
@@ -61153,13 +61268,6 @@ class Renderers {
         return this._shadowRenderer;
     }
 
-    get snapInitRenderer() {
-        if (!this._snapInitRenderer) {
-            this._snapInitRenderer = new TrianglesSnapInitRenderer(this._scene, false);
-        }
-        return this._snapInitRenderer;
-    }
-
     get snapRenderer() {
         if (!this._snapRenderer) {
             this._snapRenderer = new TrianglesSnapRenderer(this._scene);
@@ -61167,6 +61275,13 @@ class Renderers {
         return this._snapRenderer;
     }
 
+    get snapInitRenderer() {
+        if (!this._snapInitRenderer) {
+            this._snapInitRenderer = new TrianglesSnapInitRenderer(this._scene);
+        }
+        return this._snapInitRenderer;
+    }
+
     _destroy() {
         if (this._colorRenderer) {
             this._colorRenderer.destroy();
@@ -61180,18 +61295,24 @@ class Renderers {
         if (this._flatColorRendererWithSAO) {
             this._flatColorRendererWithSAO.destroy();
         }
-        if (this._pbrRenderer) {
-            this._pbrRenderer.destroy();
-        }
-        if (this._pbrRendererWithSAO) {
-            this._pbrRendererWithSAO.destroy();
-        }
         if (this._colorTextureRenderer) {
             this._colorTextureRenderer.destroy();
         }
         if (this._colorTextureRendererWithSAO) {
             this._colorTextureRendererWithSAO.destroy();
         }
+        if (this._colorTextureRendererAlphaCutoff) {
+            this._colorTextureRendererAlphaCutoff.destroy();
+        }
+        if (this._colorTextureRendererWithSAOAlphaCutoff) {
+            this._colorTextureRendererWithSAOAlphaCutoff.destroy();
+        }
+        if (this._pbrRenderer) {
+            this._pbrRenderer.destroy();
+        }
+        if (this._pbrRendererWithSAO) {
+            this._pbrRendererWithSAO.destroy();
+        }
         if (this._depthRenderer) {
             this._depthRenderer.destroy();
         }
@@ -61241,22 +61362,22 @@ const cachedRenderers$5 = {};
  */
 function getRenderers$6(scene) {
     const sceneId = scene.id;
-    let instancingRenderers = cachedRenderers$5[sceneId];
-    if (!instancingRenderers) {
-        instancingRenderers = new Renderers(scene);
-        cachedRenderers$5[sceneId] = instancingRenderers;
-        instancingRenderers._compile();
-        instancingRenderers.eagerCreateRenders();
+    let renderers = cachedRenderers$5[sceneId];
+    if (!renderers) {
+        renderers = new Renderers(scene);
+        cachedRenderers$5[sceneId] = renderers;
+        renderers._compile();
+        renderers.eagerCreateRenders();
         scene.on("compile", () => {
-            instancingRenderers._compile();
-            instancingRenderers.eagerCreateRenders();
+            renderers._compile();
+            renderers.eagerCreateRenders();
         });
         scene.on("destroyed", () => {
             delete cachedRenderers$5[sceneId];
-            instancingRenderers._destroy();
+            renderers._destroy();
         });
     }
-    return instancingRenderers;
+    return renderers;
 }
 
 const tempUint8Vec4$2 = new Uint8Array(4);
@@ -62038,14 +62159,21 @@ class VBOInstancingTrianglesLayer {
             return;
         }
         this._updateBackfaceCull(renderFlags, frameCtx);
+        const useAlphaCutoff = this._state.textureSet && (typeof(this._state.textureSet.alphaCutoff) === "number");
         if (frameCtx.withSAO && this.model.saoEnabled) {
             if (frameCtx.pbrEnabled && this.model.pbrEnabled && this._state.pbrSupported) {
                 if (this._renderers.pbrRendererWithSAO) {
                     this._renderers.pbrRendererWithSAO.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
                 }
             } else if (frameCtx.colorTextureEnabled && this.model.colorTextureEnabled && this._state.colorTextureSupported) {
-                if (this._renderers.colorTextureRendererWithSAO) {
-                    this._renderers.colorTextureRendererWithSAO.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                if (useAlphaCutoff) {
+                    if (this._renderers.colorTextureRendererWithSAOAlphaCutoff) {
+                        this._renderers.colorTextureRendererWithSAOAlphaCutoff.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                    }
+                } else {
+                    if (this._renderers.colorTextureRendererWithSAO) {
+                        this._renderers.colorTextureRendererWithSAO.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                    }
                 }
             } else if (this._state.normalsBuf) {
                 if (this._renderers.colorRendererWithSAO) {
@@ -62061,8 +62189,14 @@ class VBOInstancingTrianglesLayer {
                 this._renderers.pbrRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
             }
         } else if (frameCtx.colorTextureEnabled && this.model.colorTextureEnabled && this._state.colorTextureSupported) {
-            if (this._renderers.colorTextureRenderer) {
-                this._renderers.colorTextureRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+            if (useAlphaCutoff) {
+                if (this._renderers.colorTextureRendererAlphaCutoff) {
+                    this._renderers.colorTextureRendererAlphaCutoff.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                }
+            } else {
+                if (this._renderers.colorTextureRenderer) {
+                    this._renderers.colorTextureRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+                }
             }
         } else if (this._state.normalsBuf) {
             if (this._renderers.colorRenderer) {
@@ -63237,7 +63371,7 @@ class VBOBatchingLinesSnapRenderer extends VBORenderer{
 
         src.push(`int pickFlag = int(flags) >> 12 & 0xF;`);
         src.push(`if (pickFlag != renderPass) {`);
-        src.push("      gl_Position = vec4(0.0, 0.0, 0.0, 0.0);"); // Cull vertex
+        src.push("      gl_Position = vec4(2.0, 0.0, 0.0, 0.0);"); // Cull vertex
         src.push("  } else {");
         src.push("      vec4 worldPosition = worldMatrix * (positionsDecodeMatrix * vec4(position, 1.0)); ");
         if (scene.entityOffsetsEnabled) {
@@ -64979,7 +65113,7 @@ class VBOInstancingLinesSnapRenderer extends VBORenderer {
         // renderPass = PICK
         src.push(`int pickFlag = int(flags) >> 12 & 0xF;`);
         src.push(`if (pickFlag != renderPass) {`);
-        src.push("   gl_Position = vec4(0.0, 0.0, 0.0, 0.0);"); // Cull vertex
+        src.push("   gl_Position = vec4(2.0, 0.0, 0.0, 0.0);"); // Cull vertex
         src.push("} else {");
         src.push("  vec4 worldPosition = positionsDecodeMatrix * vec4(position, 1.0); ");
         src.push("  worldPosition = worldMatrix * vec4(dot(worldPosition, modelMatrixCol0), dot(worldPosition, modelMatrixCol1), dot(worldPosition, modelMatrixCol2), 1.0);");
@@ -75746,6 +75880,14 @@ class DTXTrianglesSnapRenderer {
         src.push("uvec4 flags = texelFetch (uObjectPerObjectColorsAndFlags, ivec2(objectIndexCoords.x*8+2, objectIndexCoords.y), 0);");
         src.push("uvec4 flags2 = texelFetch (uObjectPerObjectColorsAndFlags, ivec2(objectIndexCoords.x*8+3, objectIndexCoords.y), 0);");
 
+        // flags.w = NOT_RENDERED | PICK
+        // renderPass = PICK
+
+        src.push(`if (int(flags.w) != renderPass) {`);
+        src.push("   gl_Position = vec4(3.0, 3.0, 3.0, 1.0);"); // Cull vertex
+        src.push("   return;"); // Cull vertex
+        src.push("}");
+
         src.push("{");
 
         // get vertex base
@@ -76161,6 +76303,14 @@ class DTXTrianglesSnapInitRenderer {
         src.push("uvec4 flags = texelFetch (uObjectPerObjectColorsAndFlags, ivec2(objectIndexCoords.x*8+2, objectIndexCoords.y), 0);");
         src.push("uvec4 flags2 = texelFetch (uObjectPerObjectColorsAndFlags, ivec2(objectIndexCoords.x*8+3, objectIndexCoords.y), 0);");
 
+        // flags.w = NOT_RENDERED | PICK
+        // renderPass = PICK
+
+        src.push(`if (int(flags.w) != renderPass) {`);
+        src.push("   gl_Position = vec4(3.0, 3.0, 3.0, 1.0);"); // Cull vertex
+        src.push("   return;"); // Cull vertex
+        src.push("}");
+
         src.push("{");
 
         // get color
@@ -80553,6 +80703,11 @@ class SceneModelTextureSet {
          */
         this.colorTexture = cfg.colorTexture;
 
+        /**
+         * The alpha cutoff [float]
+         */
+        this.alphaCutoff = cfg.alphaCutoff;
+
         /**
          * The metallic-roughness texture.
          * @type {SceneModelTexture|*}
@@ -85109,6 +85264,7 @@ class SceneModel extends Component {
             id: textureSetId,
             model: this,
             colorTexture,
+            alphaCutoff: cfg.alphaCutoff,
             metallicRoughnessTexture,
             normalsTexture,
             emissiveTexture,
@@ -85542,6 +85698,14 @@ class SceneModel extends Component {
         return this._createMesh(cfg);
     }
 
+    _createDefaultIndices(numIndices) {
+        const indices = [];
+        for (let i = 0; i < numIndices; i++) {
+            indices.push(i);
+        }
+        return indices;
+    }
+
     _createMesh(cfg) {
         const mesh = new SceneModelMesh(this, cfg.id, cfg.color, cfg.opacity, cfg.transform, cfg.textureSet);
         mesh.pickId = this.scene._renderer.getPickID(mesh);
@@ -101591,8 +101755,6 @@ class MetaScene {
      * @param {String} modelId ID for the new {@link MetaModel}, which will have {@link MetaModel#id} set to this value.
      * @param {Object} metaModelData Data for the {@link MetaModel}.
      * @param {Object} [options] Options for creating the {@link MetaModel}.
-     * @param {Object} [options.includeTypes] When provided, only create {@link MetaObject}s with types in this list.
-     * @param {Object} [options.excludeTypes] When provided, never create {@link MetaObject}s with types in this list.
      * @param {Boolean} [options.globalizeObjectIds=false] Whether to globalize each {@link MetaObject#id}. Set this ````true```` when you need to load multiple instances of the same meta model, to avoid ID clashes between the meta objects in the different instances.
      * @returns {MetaModel} The new MetaModel.
      */
@@ -117578,40 +117740,6 @@ class GLTFSceneModelLoader {
     }
 }
 
-function getMetaModelCorrections(metaModelJSON) {
-    const eachRootStats = {};
-    const eachChildRoot = {};
-    const metaObjects = metaModelJSON.metaObjects || [];
-    const metaObjectsMap = {};
-    for (let i = 0, len = metaObjects.length; i < len; i++) {
-        const metaObject = metaObjects[i];
-        metaObjectsMap[metaObject.id] = metaObject;
-    }
-    for (let i = 0, len = metaObjects.length; i < len; i++) {
-        const metaObject = metaObjects[i];
-        if (metaObject.parent !== undefined && metaObject.parent !== null) {
-            const metaObjectParent = metaObjectsMap[metaObject.parent];
-            if (metaObject.type === metaObjectParent.type) {
-                let rootMetaObject = metaObjectParent;
-                while (rootMetaObject.parent && metaObjectsMap[rootMetaObject.parent].type === rootMetaObject.type) {
-                    rootMetaObject = metaObjectsMap[rootMetaObject.parent];
-                }
-                const rootStats = eachRootStats[rootMetaObject.id] || (eachRootStats[rootMetaObject.id] = {
-                    numChildren: 0,
-                    countChildren: 0
-                });
-                rootStats.numChildren++;
-                eachChildRoot[metaObject.id] = rootMetaObject;
-            }
-        }
-    }
-    return {
-        metaObjectsMap,
-        eachRootStats,
-        eachChildRoot
-    };
-}
-
 function loadGLTF(plugin, src, metaModelJSON, options, sceneModel, ok, error) {
     const spinner = plugin.viewer.scene.canvas.spinner;
     spinner.processes++;
@@ -117653,7 +117781,9 @@ function parseGLTF(plugin, src, gltf, metaModelJSON, options, sceneModel, ok) {
         const ctx = {
             src: src,
             entityId: options.entityId,
-            metaModelCorrections: metaModelJSON ? getMetaModelCorrections(metaModelJSON) : null,
+            metaModelJSON,
+            autoMetaModel: options.autoMetaModel,
+            metaObjects: [],
             loadBuffer: options.loadBuffer,
             basePath: options.basePath,
             handlenode: options.handlenode,
@@ -117672,8 +117802,20 @@ function parseGLTF(plugin, src, gltf, metaModelJSON, options, sceneModel, ok) {
         };
         loadTextures(ctx);
         loadMaterials(ctx);
+        if (options.autoMetaModel) {
+          ctx.metaObjects.push({
+              id: sceneModel.id,
+              type: "Default",
+              name: sceneModel.id
+          });
+        }
         loadDefaultScene(ctx);
         sceneModel.finalize();
+        if (options.autoMetaModel) {
+            plugin.viewer.metaScene.createMetaModel(sceneModel.id, {
+                metaObjects: ctx.metaObjects
+            });
+        }
         spinner.processes--;
         ok();
     });
@@ -117802,23 +117944,17 @@ function loadTextureSet(ctx, material) {
     if (material.emissiveTexture) {
         textureSetCfg.emissiveTextureId = material.emissiveTexture.texture._textureId;
     }
-    // const alphaMode = material.alphaMode;
-    // switch (alphaMode) {
-    //     case "NORMAL_OPAQUE":
-    //         materialCfg.alphaMode = "opaque";
-    //         break;
-    //     case "MASK":
-    //         materialCfg.alphaMode = "mask";
-    //         break;
-    //     case "BLEND":
-    //         materialCfg.alphaMode = "blend";
-    //         break;
-    //     default:
-    // }
-    // const alphaCutoff = material.alphaCutoff;
-    // if (alphaCutoff !== undefined) {
-    //     materialCfg.alphaCutoff = alphaCutoff;
-    // }
+
+    switch (material.alphaMode) {
+        case "OPAQUE":
+            break;
+        case "MASK":
+            const alphaCutoff = material.alphaCutoff;
+            // Default from the spec https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#reference-material
+            textureSetCfg.alphaCutoff = (alphaCutoff !== undefined) ? alphaCutoff : 0.5;
+            break;
+    }
+
     const metallicPBR = material.pbrMetallicRoughness;
     if (material.pbrMetallicRoughness) {
         const pbrMetallicRoughness = material.pbrMetallicRoughness;
@@ -117864,7 +118000,7 @@ function loadMaterialAttributes(ctx, material) { // Substitute RGBA for material
         opacity: 1,
         metallic: 0,
         roughness: 1,
-        doubleSided : true
+        doubleSided: true
     };
     if (extensions) {
         const specularPBR = extensions["KHR_materials_pbrSpecularGlossiness"];
@@ -117938,9 +118074,22 @@ function loadScene(ctx, scene) {
         const node = nodes[i];
         countMeshUsage(ctx, node);
     }
-    for (let i = 0, len = nodes.length; i < len; i++) {
+    for (let i = 0, len = nodes.length; i < len && !ctx.nodesHaveNames; i++) {
         const node = nodes[i];
-        loadNode(ctx, node, 0, null);
+        if (testIfNodesHaveNames(node)) {
+            ctx.nodesHaveNames = true;
+        }
+    }
+    if (!ctx.nodesHaveNames) {
+        for (let i = 0, len = nodes.length; i < len; i++) {
+            const node = nodes[i];
+            parseNodesWithoutNames(ctx, node, 0, null);
+        }
+    } else {
+        for (let i = 0, len = nodes.length; i < len; i++) {
+            const node = nodes[i];
+            parseNodesWithNames(ctx, node, 0, null);
+        }
     }
 }
 
@@ -117962,10 +118111,131 @@ function countMeshUsage(ctx, node) {
     }
 }
 
-const deferredMeshIds = [];
+function testIfNodesHaveNames(node) {
+    if (node.name) {
+        return true;
+    }
+    if (node.children) {
+        const children = node.children;
+        for (let i = 0, len = children.length; i < len; i++) {
+            const childNode = children[i];
+            if (testIfNodesHaveNames(childNode)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 
-function loadNode(ctx, node, depth, matrix) {
-    ctx.gltfData;
+/**
+ * Parses a glTF node hierarchy that is known to NOT contain "name" attributes on the nodes.
+ * Create a SceneMesh for each mesh primitive, and a single SceneObject.
+ */
+const parseNodesWithoutNames = (function () {
+    const meshIds = [];
+    return function (ctx, node, depth, matrix, parentNode) {
+        matrix = parseNodeMatrix(node, matrix);
+        if (node.mesh) {
+            parseNodeMesh(node, ctx, matrix, meshIds);
+        }
+        if (node.children) {
+            const children = node.children;
+            for (let i = 0, len = children.length; i < len; i++) {
+                const childNode = children[i];
+                parseNodesWithoutNames(ctx, childNode, depth + 1, matrix, node);
+            }
+        }
+        if (depth === 0) {
+            let entityId = "entity-" + ctx.nextId++;
+            if (meshIds && meshIds.length > 0) {
+                ctx.sceneModel.createEntity({
+                    id: entityId,
+                    meshIds,
+                    isObject: true
+                });
+                if (ctx.autoMetaModel) {
+                    ctx.metaObjects.push({
+                        id: entityId,
+                        type: "Default",
+                        name: entityId,
+                        parent: ctx.sceneModel.id
+                    });
+                }
+                meshIds.length = 0;
+            }
+        }
+    }
+})();
+
+const parseNodesWithNames = (function () {
+
+    const objectIdStack = [];
+    const meshIdsStack = [];
+    let meshIds = [];
+
+    return function (ctx, node, depth, matrix) {
+        matrix = parseNodeMatrix(node, matrix);
+        if (meshIds && node.mesh) {
+            parseNodeMesh(node, ctx, matrix, meshIds);
+        }
+
+        if (node.name) {
+            meshIds = [];
+            let entityId = node.name;
+            if (!!entityId && ctx.sceneModel.objects[entityId]) ;
+            while (!entityId || ctx.sceneModel.objects[entityId]) {
+                entityId = "entity-" + ctx.nextId++;
+            }
+            objectIdStack.push(entityId);
+            meshIdsStack.push(meshIds);
+        }
+
+        if (node.children) {
+            const children = node.children;
+            for (let i = 0, len = children.length; i < len; i++) {
+                const childNode = children[i];
+                parseNodesWithNames(ctx, childNode, depth + 1, matrix);
+            }
+        }
+
+        // Post-order visit scene node
+
+        const nodeName = node.name;
+        if ((nodeName !== undefined && nodeName !== null) || depth === 0) {
+            let entityId = objectIdStack.pop();
+            if (!entityId) { // For when there are no nodes with names
+                entityId = "entity-" + ctx.nextId++;
+            }
+            let entityMeshIds = meshIdsStack.pop();
+            if (meshIds && meshIds.length > 0) {
+                ctx.sceneModel.createEntity({
+                    id: entityId,
+                    meshIds: entityMeshIds,
+                    isObject: true
+                });
+                if (ctx.autoMetaModel) {
+                    ctx.metaObjects.push({
+                        id: entityId,
+                        type: "Default",
+                        name: entityId,
+                        parent: ctx.sceneModel.id
+                    });
+                }
+            }
+            meshIds = meshIdsStack.length > 0 ? meshIdsStack[meshIdsStack.length - 1] : null;
+        }
+    };
+})();
+
+
+/**
+ * Parses transform at the given glTF node.
+ *
+ * @param node the glTF node
+ * @param matrix Transfor matrix from parent nodes
+ * @returns {*} Transform matrix for the node
+ */
+function parseNodeMatrix(node, matrix) {
     let localMatrix;
     if (node.matrix) {
         localMatrix = node.matrix;
@@ -117999,171 +118269,96 @@ function loadNode(ctx, node, depth, matrix) {
             matrix = localMatrix;
         }
     }
+    return matrix;
+}
 
-    const sceneModel = ctx.sceneModel;
-    if (node.mesh) {
-        const mesh = node.mesh;
-        if (ctx.handlenode) {
-            const actions = {};
-            if (!ctx.handlenode(ctx.sceneModel.id, node, actions)) {
-                return;
-            }
-            if (actions.createEntity) ;
-        }
-        const worldMatrix = matrix ? matrix.slice() : math.identityMat4();
-        const numPrimitives = mesh.primitives.length;
-
-        if (numPrimitives > 0) {
-
-            for (let i = 0; i < numPrimitives; i++) {
-
-                const primitive = mesh.primitives[i];
-                if (primitive.mode < 4) {
-                    continue;
-                }
-
-                const meshCfg = {
-                    id: sceneModel.id + "." + ctx.numObjects++
-                };
-
-                const material = primitive.material;
-                if (material) {
-                    meshCfg.textureSetId = material._textureSetId;
-                    meshCfg.color = material._attributes.color;
-                    meshCfg.opacity = material._attributes.opacity;
-                    meshCfg.metallic = material._attributes.metallic;
-                    meshCfg.roughness = material._attributes.roughness;
-                } else {
-                    meshCfg.color = new Float32Array([1.0, 1.0, 1.0]);
-                    meshCfg.opacity = 1.0;
-                }
-
-                const backfaces = ((ctx.backfaces !== false) || (material && material.doubleSided !== false));
-
-                switch (primitive.mode) {
-                    case 0: // POINTS
-                        meshCfg.primitive = "points";
-                        break;
-                    case 1: // LINES
-                        meshCfg.primitive = "lines";
-                        break;
-                    case 2: // LINE_LOOP
-                        meshCfg.primitive = "lines";
-                        break;
-                    case 3: // LINE_STRIP
-                        meshCfg.primitive = "lines";
-                        break;
-                    case 4: // TRIANGLES
-                        meshCfg.primitive = backfaces ? "triangles" : "solid";
-                        break;
-                    case 5: // TRIANGLE_STRIP
-                        meshCfg.primitive = backfaces ? "triangles" : "solid";
-                        break;
-                    case 6: // TRIANGLE_FAN
-                        meshCfg.primitive = backfaces ? "triangles" : "solid";
-                        break;
-                    default:
-                        meshCfg.primitive = backfaces ? "triangles" : "solid";
-                }
-
-                const POSITION = primitive.attributes.POSITION;
-                if (!POSITION) {
-                    continue;
-                }
-                meshCfg.localPositions = POSITION.value;
-                meshCfg.positions = new Float64Array(meshCfg.localPositions.length);
-
-                if (primitive.attributes.NORMAL) {
-                    meshCfg.normals = primitive.attributes.NORMAL.value;
-                }
-
-                if (primitive.attributes.TEXCOORD_0) {
-                    meshCfg.uv = primitive.attributes.TEXCOORD_0.value;
-                }
-
-                if (primitive.indices) {
-                    meshCfg.indices = primitive.indices.value;
-                }
-
-                math.transformPositions3(worldMatrix, meshCfg.localPositions, meshCfg.positions);
-                const origin = math.vec3();
-                const rtcNeeded = worldToRTCPositions(meshCfg.positions, meshCfg.positions, origin); // Small cellsize guarantees better accuracy
-                if (rtcNeeded) {
-                    meshCfg.origin = origin;
-                }
-
-                sceneModel.createMesh(meshCfg);
-                deferredMeshIds.push(meshCfg.id);
-            }
-        }
-    }
-
-    if (node.children) {
-        const children = node.children;
-        for (let i = 0, len = children.length; i < len; i++) {
-            const childNode = children[i];
-            loadNode(ctx, childNode, depth + 1, matrix);
-        }
+/**
+ * Parses primitives referenced by the mesh belonging to the given node, creating XKTMeshes in the XKTModel.
+ *
+ * @param node glTF node
+ * @param ctx Parsing context
+ * @param matrix Matrix for the XKTMeshes
+ * @param meshIds returns IDs of the new XKTMeshes
+ */
+function parseNodeMesh(node, ctx, matrix, meshIds) {
+    const mesh = node.mesh;
+    if (!mesh) {
+        return;
     }
-
-    // Post-order visit scene node
-
-    if (ctx.entityId) {
-        if (depth ===0) {
-            sceneModel.createEntity({
-                id: ctx.entityId,
-                meshIds: deferredMeshIds,
-                isObject: true
-            });
-            deferredMeshIds.length = 0;
-        }
-    } else {
-        const nodeName = node.name;
-        if (((nodeName !== undefined && nodeName !== null) || depth === 0) && deferredMeshIds.length > 0) {
-            if (nodeName === undefined || nodeName === null) {
-                ctx.log(`Warning: 'name' properties not found on glTF scene nodes - will randomly-generate object IDs in XKT`);
+    const numPrimitives = mesh.primitives.length;
+    if (numPrimitives > 0) {
+        for (let i = 0; i < numPrimitives; i++) {
+            const primitive = mesh.primitives[i];
+            if (primitive.mode < 4) {
+                continue;
             }
-            let entityId = nodeName; // Fall back on generated ID when `name` not found on glTF scene node(s)
-            // if (!!entityId && sceneModel.entities[entityId]) {
-            //     ctx.log(`Warning: Two or more glTF nodes found with same 'name' attribute: '${nodeName} - will randomly-generating an object ID in XKT`);
-            // }
-            // while (!entityId || sceneModel.entities[entityId]) {
-            //     entityId = "entity-" + ctx.nextId++;
-            // }
-            if (ctx.metaModelCorrections) {
-                // Merging meshes into XKTObjects that map to metaobjects
-                const rootMetaObject = ctx.metaModelCorrections.eachChildRoot[entityId];
-                if (rootMetaObject) {
-                    const rootMetaObjectStats = ctx.metaModelCorrections.eachRootStats[rootMetaObject.id];
-                    rootMetaObjectStats.countChildren++;
-                    if (rootMetaObjectStats.countChildren >= rootMetaObjectStats.numChildren) {
-                        sceneModel.createEntity({
-                            id: rootMetaObject.id,
-                            meshIds: deferredMeshIds,
-                            isObject: true
-                        });
-                        deferredMeshIds.length = 0;
-                    }
-                } else {
-                    const metaObject = ctx.metaModelCorrections.metaObjectsMap[entityId];
-                    if (metaObject) {
-                        sceneModel.createEntity({
-                            id: entityId,
-                            meshIds: deferredMeshIds,
-                            isObject: true
-                        });
-                        deferredMeshIds.length = 0;
-                    }
-                }
+            const meshCfg = {
+                id: ctx.sceneModel.id + "." + ctx.numObjects++
+            };
+            const material = primitive.material;
+            if (material) {
+                meshCfg.textureSetId = material._textureSetId;
+                meshCfg.color = material._attributes.color;
+                meshCfg.opacity = material._attributes.opacity;
+                meshCfg.metallic = material._attributes.metallic;
+                meshCfg.roughness = material._attributes.roughness;
             } else {
-                // Create an XKTObject from the meshes at each named glTF node, don't care about metaobjects
-                sceneModel.createEntity({
-                    id: entityId,
-                    meshIds: deferredMeshIds,
-                    isObject: true
-                });
-                deferredMeshIds.length = 0;
+                meshCfg.color = new Float32Array([1.0, 1.0, 1.0]);
+                meshCfg.opacity = 1.0;
+            }
+            const backfaces = ((ctx.backfaces !== false) || (material && material.doubleSided !== false));
+            switch (primitive.mode) {
+                case 0: // POINTS
+                    meshCfg.primitive = "points";
+                    break;
+                case 1: // LINES
+                    meshCfg.primitive = "lines";
+                    break;
+                case 2: // LINE_LOOP
+                    meshCfg.primitive = "lines";
+                    break;
+                case 3: // LINE_STRIP
+                    meshCfg.primitive = "lines";
+                    break;
+                case 4: // TRIANGLES
+                    meshCfg.primitive = backfaces ? "triangles" : "solid";
+                    break;
+                case 5: // TRIANGLE_STRIP
+                    meshCfg.primitive = backfaces ? "triangles" : "solid";
+                    break;
+                case 6: // TRIANGLE_FAN
+                    meshCfg.primitive = backfaces ? "triangles" : "solid";
+                    break;
+                default:
+                    meshCfg.primitive = backfaces ? "triangles" : "solid";
+            }
+            const POSITION = primitive.attributes.POSITION;
+            if (!POSITION) {
+                continue;
+            }
+            meshCfg.localPositions = POSITION.value;
+            meshCfg.positions = new Float64Array(meshCfg.localPositions.length);
+            if (primitive.attributes.NORMAL) {
+                meshCfg.normals = primitive.attributes.NORMAL.value;
+            }
+            if (primitive.attributes.TEXCOORD_0) {
+                meshCfg.uv = primitive.attributes.TEXCOORD_0.value;
             }
+            if (primitive.indices) {
+                meshCfg.indices = primitive.indices.value;
+            }
+            if (matrix) {
+                math.transformPositions3(matrix, meshCfg.localPositions, meshCfg.positions);
+            } else { // eqiv to math.transformPositions3(math.identityMat4(), meshCfg.localPositions, meshCfg.positions);
+                meshCfg.positions.set(meshCfg.localPositions);
+            }
+            const origin = math.vec3();
+            const rtcNeeded = worldToRTCPositions(meshCfg.positions, meshCfg.positions, origin); // Small cellsize guarantees better accuracy
+            if (rtcNeeded) {
+                meshCfg.origin = origin;
+            }
+            ctx.sceneModel.createMesh(meshCfg);
+            meshIds.push(meshCfg.id);
         }
     }
 }
@@ -118490,8 +118685,6 @@ class GLTFLoaderPlugin extends Plugin {
      * @param {String} [params.metaModelSrc] Path to an optional metadata file, as an alternative to the ````metaModelJSON```` parameter.
      * @param {*} [params.metaModelJSON] JSON model metadata, as an alternative to the ````metaModelSrc```` parameter.
      * @param {{String:Object}} [params.objectDefaults] Map of initial default states for each loaded {@link Entity} that represents an object. Default value is {@link IFCObjectDefaults}.
-     * @param {String[]} [params.includeTypes] When loading metadata, only loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list.
-     * @param {String[]} [params.excludeTypes] When loading metadata, never loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list.
      * @param {Boolean} [params.edges=false] Whether or not xeokit renders the model with edges emphasized.
      * @param {Number[]} [params.origin=[0,0,0]] The double-precision World-space origin of the model's coordinates.
      * @param {Number[]} [params.position=[0,0,0]] The single-precision position, relative to ````origin````.
@@ -118507,150 +118700,47 @@ class GLTFLoaderPlugin extends Plugin {
      * represent the returned model. Set false to always use vertex buffer objects (VBOs). Note that DTX is only applicable
      * to non-textured triangle meshes, and that VBOs are always used for meshes that have textures, line segments, or point
      * primitives. Only works while {@link DTX#enabled} is also ````true````.
-     * @param {String} [params.entityId] When supplied, causes the entire model to be loaded into a single {@link Entity} that gets this ID.
+     * @param {Boolean} [params.autoMetaModel] When supplied, creates a default MetaModel with a single MetaObject.
      * @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 = {}) {
-
         if (params.id && this.viewer.scene.components[params.id]) {
             this.error("Component with this ID already exists in viewer: " + params.id + " - will autogenerate this ID");
             delete params.id;
         }
-
         const sceneModel = new SceneModel(this.viewer.scene, utils.apply(params, {
             isModel: true,
             dtxEnabled: params.dtxEnabled
         }));
-
         const modelId = sceneModel.id;  // In case ID was auto-generated
-
         if (!params.src && !params.gltf) {
             this.error("load() param expected: src or gltf");
             return sceneModel; // Return new empty model
         }
-
         if (params.metaModelSrc || params.metaModelJSON) {
-
-            const objectDefaults = params.objectDefaults || this._objectDefaults || IFCObjectDefaults;
-
             const processMetaModelJSON = (metaModelJSON) => {
-
-                this.viewer.metaScene.createMetaModel(modelId, metaModelJSON, {
-                    includeTypes: params.includeTypes,
-                    excludeTypes: params.excludeTypes
-                });
-
+                this.viewer.metaScene.createMetaModel(modelId, metaModelJSON, {});
                 this.viewer.scene.canvas.spinner.processes--;
-
-                let includeTypes;
-                if (params.includeTypes) {
-                    includeTypes = {};
-                    for (let i = 0, len = params.includeTypes.length; i < len; i++) {
-                        includeTypes[params.includeTypes[i]] = true;
-                    }
-                }
-                if (params.excludeTypes) {
-                    if (!includeTypes) {
-                        includeTypes = {};
-                    }
-                    for (let i = 0, len = params.excludeTypes.length; i < len; i++) {
-                        includeTypes[params.excludeTypes[i]] = true;
-                    }
-                }
-
-                params.readableGeometry = false;
-
-                params.handleGLTFNode = (modelId, glTFNode, actions) => {
-
-                    const name = glTFNode.name;
-
-                    if (!name) {
-                        return true; // Continue descending this node subtree
-                    }
-
-                    const nodeId = name;
-                    const metaObject = this.viewer.metaScene.metaObjects[nodeId];
-                    const type = (metaObject ? metaObject.type : "DEFAULT") || "DEFAULT";
-
-                    actions.createEntity = {
-                        id: nodeId,
-                        isObject: true // Registers the Entity in Scene#objects
-                    };
-
-                    const props = objectDefaults[type];
-
-                    if (props) { // Set Entity's initial rendering state for recognized type
-
-                        if (props.visible === false) {
-                            actions.createEntity.visible = false;
-                        }
-
-                        if (props.colorize) {
-                            actions.createEntity.colorize = props.colorize;
-                        }
-
-                        if (props.pickable === false) {
-                            actions.createEntity.pickable = false;
-                        }
-
-                        if (props.opacity !== undefined && props.opacity !== null) {
-                            actions.createEntity.opacity = props.opacity;
-                        }
-                    }
-
-                    return true; // Continue descending this glTF node subtree
-                };
-
                 if (params.src) {
                     this._sceneModelLoader.load(this, params.src, metaModelJSON, params, sceneModel);
                 } else {
                     this._sceneModelLoader.parse(this, params.gltf, metaModelJSON, params, sceneModel);
                 }
             };
-
             if (params.metaModelSrc) {
-
                 const metaModelSrc = params.metaModelSrc;
-
                 this.viewer.scene.canvas.spinner.processes++;
-
                 this._dataSource.getMetaModel(metaModelSrc, (metaModelJSON) => {
-
                     this.viewer.scene.canvas.spinner.processes--;
-
                     processMetaModelJSON(metaModelJSON);
-
                 }, (errMsg) => {
                     this.error(`load(): Failed to load model metadata for model '${modelId} from  '${metaModelSrc}' - ${errMsg}`);
                     this.viewer.scene.canvas.spinner.processes--;
                 });
-
             } else if (params.metaModelJSON) {
-
                 processMetaModelJSON(params.metaModelJSON);
             }
-
         } else {
-
-            params.handleGLTFNode = (modelId, glTFNode, actions) => {
-
-                const name = glTFNode.name;
-
-                if (!name) {
-                    return true; // Continue descending this node subtree
-                }
-
-                const id = name;
-
-                actions.createEntity = { // Create an Entity for this glTF scene node
-                    id: id,
-                    isObject: true // Registers the Entity in Scene#objects
-                };
-
-                return true; // Continue descending this glTF node subtree
-            };
-
-
             if (params.src) {
                 this._sceneModelLoader.load(this, params.src, null, params, sceneModel);
             } else {
@@ -126986,7 +127076,7 @@ class TreeViewPlugin extends Plugin {
             this._nodeNodes[buildingNode.nodeId] = buildingNode;
         } else if (metaObjectType === "IfcBuildingStorey") {
             if (!buildingNode) {
-                this.error("Failed to build storeys hierarchy for model '" + this.metaModel.id + "' - model does not have an IfcBuilding object, or is not an IFC model");
+                this.error("Failed to build storeys hierarchy for model - model does not have an IfcBuilding object, or is not an IFC model");
                 return;
             }
             storeyNode = {
@@ -139173,49 +139263,126 @@ class DotBIMLoaderPlugin extends Plugin {
 
                 const dbMeshId = element.mesh_id;
 
-                parseDBMesh(dbMeshId);
-
-                const meshId = `${objectId}-mesh`;
                 const vector = element.vector;
                 const rotation = element.rotation;
                 const props = objectDefaults ? objectDefaults[elementType] || objectDefaults["DEFAULT"] : null;
-
                 let visible = true;
                 let pickable = true;
-                let color = element.color ? [element.color.r / 255, element.color.g / 255, element.color.b / 255] : [1, 1, 1];
-                let opacity = element.color ? element.color.a / 255 : 1.0;
 
-                if (props) {
-                    if (props.visible === false) {
-                        visible = false;
-                    }
-                    if (props.pickable === false) {
-                        pickable = false;
-                    }
-                    if (props.colorize) {
-                        color = props.colorize;
-                    }
-                    if (props.opacity !== undefined && props.opacity !== null) {
-                        opacity = props.opacity;
+                if (element.face_colors === undefined) {
+
+                    parseDBMesh(dbMeshId);
+
+                    const meshId = `${objectId}-mesh`;
+
+                    let color = element.color ? [element.color.r / 255.0, element.color.g / 255.0, element.color.b / 255.0] : [1, 1, 1];
+                    let opacity = element.color ? element.color.a / 255.0 : 1.0;
+
+                    if (props) {
+                        if (props.visible === false) {
+                            visible = false;
+                        }
+                        if (props.pickable === false) {
+                            pickable = false;
+                        }
+                        if (props.colorize) {
+                            color = props.colorize;
+                        }
+                        if (props.opacity !== undefined && props.opacity !== null) {
+                            opacity = props.opacity;
+                        }
                     }
+
+                    sceneModel.createMesh({
+                        id: meshId,
+                        geometryId: dbMeshId,
+                        color: color,
+                        opacity: opacity,
+                        quaternion: rotation && (rotation.qz !== 0 || rotation.qy !== 0 || rotation.qx !== 0 || rotation.qw !== 1.0) ? [rotation.qx, rotation.qy, rotation.qz, rotation.qw] : undefined,
+                        position: vector ? [vector.x, vector.y, vector.z] : undefined
+                    });
+
+                    sceneModel.createEntity({
+                        id: objectId,
+                        meshIds: [meshId],
+                        visible: visible,
+                        pickable: pickable,
+                        isObject: true
+                    });
                 }
+                else {
+                    let faceColors = element.face_colors;
+                    let coloredTrianglesDictionary = {};
+                    let currentTriangleIndicesCount = 0;
+                    let dbMesh = fileData.meshes[element.mesh_id];
+                    for (let i = 0, len = faceColors.length; i < len; i+=4) {
+                        let faceColor = [faceColors[i], faceColors[i+1], faceColors[i+2], faceColors[i+3]];
+                        if (coloredTrianglesDictionary[faceColor] === undefined) {
+                            coloredTrianglesDictionary[faceColor] = [];
+                        }
+                        let indexForPoint0 = dbMesh.indices[currentTriangleIndicesCount];
+                        let x0 = dbMesh.coordinates[indexForPoint0*3];
+                        let y0 = dbMesh.coordinates[indexForPoint0*3+1];
+                        let z0 = dbMesh.coordinates[indexForPoint0*3+2];
+                        let indexForPoint1 = dbMesh.indices[currentTriangleIndicesCount+1];
+                        let x1 = dbMesh.coordinates[indexForPoint1*3];
+                        let y1 = dbMesh.coordinates[indexForPoint1*3+1];
+                        let z1 = dbMesh.coordinates[indexForPoint1*3+2];
+                        let indexForPoint2 = dbMesh.indices[currentTriangleIndicesCount+2];
+                        let x2 = dbMesh.coordinates[indexForPoint2*3];
+                        let y2 = dbMesh.coordinates[indexForPoint2*3+1];
+                        let z2 = dbMesh.coordinates[indexForPoint2*3+2];
+                        coloredTrianglesDictionary[faceColor].push(x0, y0, z0, x1, y1, z1, x2, y2, z2);
+
+                        currentTriangleIndicesCount += 3;
+                    }
+                    let meshIds = [];
+                    for (const [faceColor, trianglesCoordinates] of Object.entries(coloredTrianglesDictionary)) {
+                        sceneModel.createGeometry({
+                            id: `${dbMeshId}-${faceColor}`,
+                            primitive: "triangles",
+                            positions: trianglesCoordinates,
+                            indices: [...Array(trianglesCoordinates.length).keys()]
+                        });
+                        const meshId = `${objectId}-mesh-${faceColor}`;
+                        const faceColorArray = faceColor.split(',').map(Number);
 
-                sceneModel.createMesh({
-                    id: meshId,
-                    geometryId: dbMeshId,
-                    color,
-                    opacity,
-                    quaternion: rotation && (rotation.qz !== 0 || rotation.qy !== 0 || rotation.qx !== 0 || rotation.qw !== 1.0) ? [rotation.qx, rotation.qy, rotation.qz, rotation.qw] : undefined,
-                    position: vector ? [vector.x, vector.y, vector.z] : undefined
-                });
+                        let color = [faceColorArray[0] / 255.0, faceColorArray[1] / 255.0, faceColorArray[2] / 255.0];
+                        let opacity = faceColorArray[3] / 255.0;
 
-                sceneModel.createEntity({
-                    id: objectId,
-                    meshIds: [meshId],
-                    visible,
-                    pickable,
-                    isObject: true
-                });
+                        if (props) {
+                            if (props.visible === false) {
+                                visible = false;
+                            }
+                            if (props.pickable === false) {
+                                pickable = false;
+                            }
+                            if (props.colorize) {
+                                color = props.colorize;
+                            }
+                            if (props.opacity !== undefined && props.opacity !== null) {
+                                opacity = props.opacity;
+                            }
+                        }
+
+                        sceneModel.createMesh({
+                            id: meshId,
+                            geometryId: `${dbMeshId}-${faceColor}`,
+                            color: color,
+                            opacity: opacity,
+                            quaternion: rotation && (rotation.qz !== 0 || rotation.qy !== 0 || rotation.qx !== 0 || rotation.qw !== 1.0) ? [rotation.qx, rotation.qy, rotation.qz, rotation.qw] : undefined,
+                            position: vector ? [vector.x, vector.y, vector.z] : undefined
+                        });
+                        meshIds.push(meshId);
+                    }
+                    sceneModel.createEntity({
+                        id: objectId,
+                        meshIds: meshIds,
+                        visible: visible,
+                        pickable: pickable,
+                        isObject: true
+                    });
+                }
 
                 for (let infoKey in info) {
                     let properties;