@woosh/meep-engine 2.34.35 → 2.34.39

package/engine/graphics/GraphicsEngine.js

@@ -26,7 +26,6 @@ import EmptyView from "../../view/elements/EmptyView.js";
 import { assert } from "../../core/assert.js";
 import { RenderLayerManager } from "./render/layers/RenderLayerManager.js";
 import { FrameBufferManager } from "./render/buffer/FrameBufferManager.js";
-import { SOURCE_RENDER_LAYER_PROPERTY } from "./render/visibility/VisibilityComputer.js";
 import { ColorAndDepthFrameBuffer } from "./render/buffer/buffers/ColorAndDepthFrameBuffer.js";
 import { RenderPassType } from "./render/RenderPassType.js";
 import { renderTextureToScreenQuad } from "./render/utils/renderTextureToScreenQuad.js";
@@ -527,6 +526,26 @@ GraphicsEngine.prototype.clearVisibleGroup = function () {
     this.visibleGroup.children.length = 0;
 };
 
+/**
+ *
+ * @param {THREE.Object3D} object
+ * @returns {RenderPassType}
+ */
+function classifyPassTypeFromObject(object) {
+    if (object.isMesh || object.isPoints) {
+
+        /**
+         * @type {THREE.Material}
+         */
+        const material = object.material;
+        if (material.depthWrite === false && material.depthTest === false) {
+            return RenderPassType.Transparent;
+        }
+    }
+
+    return RenderPassType.Opaque;
+}
+
 /**
  *
  * @param {RenderPassType} passType
@@ -545,7 +564,9 @@ GraphicsEngine.prototype.prepareRenderPass = function (passType) {
     for (let i = 0; i < element_count; i++) {
         const object3D = visible_objects.elements[i];
 
-        if (object3D[SOURCE_RENDER_LAYER_PROPERTY].renderPass === passType) {
+        const object_pass = classifyPassTypeFromObject(object3D);
+
+        if (object_pass === passType) {
 
             //insert object, bypassing Object#add for speed
             //visibleGroup.add(object3D);

package/engine/graphics/ecs/camera/Camera.js

@@ -5,11 +5,13 @@
 
 import ObservedBoolean from "../../../../core/model/ObservedBoolean.js";
 import ObservedEnum from "../../../../core/model/ObservedEnum.js";
-import {Frustum, Vector3 as ThreeVector3} from 'three';
-import {assert} from "../../../../core/assert.js";
+import { Frustum } from 'three';
+import { assert } from "../../../../core/assert.js";
 import Vector1 from "../../../../core/geom/Vector1.js";
-import {frustumFromCamera} from "./CameraSystem.js";
-import {computePointDistanceToPlane} from "../../../../core/geom/Plane.js";
+import { frustumFromCamera } from "./CameraSystem.js";
+import { computePointDistanceToPlane } from "../../../../core/geom/Plane.js";
+import { unprojectPoint } from "./unprojectPoint.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
 
 /**
  *
@@ -116,15 +118,15 @@ export class Camera {
 
     /**
      *
-     * @param {Camera} camera
+     * @param {Camera|THREE.PerspectiveCamera|THREE.OrthographicCamera} camera
      * @param {number} x
      * @param {number} y
      * @param {Vector3} source
      * @param {Vector3} direction
      */
     static projectRay(camera, x, y, source, direction) {
-        assert.notEqual(camera, undefined, "Camera must be defined");
-        assert.notEqual(camera.position, undefined, "Camera.position must be defined");
+        assert.defined(camera, "camera");
+        assert.defined(camera.position, "Camera.position");
 
 
         assert.isNumber(x, 'x');
@@ -136,18 +138,32 @@ export class Camera {
         // assert.ok(y >= -1, `Y(=${y}) must be greater than or equal to -1.0, not a clip-space coordinate`);
         // assert.ok(y <= 1, `Y(=${y}) must be less than or equal to 1.0, not a clip-space coordinate`);
 
-        source.copy(camera.position);
+        if (camera.isPerspectiveCamera) {
+            scratch_v3_1.setFromMatrixPosition(camera.matrixWorld.elements);
 
-        v3.set(x, y, 0.5);
+            scratch_v3_0.set(x, y, 0.5);
 
-        // NOTE: projection inverse and world matrices are used in "unproject" operation, we update those to make things work as intended. This is handled by the camera system
+            // NOTE: projection inverse and world matrices are used in "unproject" operation, we update those to make things work as intended. This is handled by the camera system
 
-        v3.unproject(camera);
+            unprojectPoint(
+                scratch_v3_0,
+                scratch_v3_0,
+                camera.projectionMatrixInverse.elements,
+                camera.matrixWorld.elements
+            );
 
-        //get direction
-        v3.sub(source).normalize();
+            //get direction
+            scratch_v3_0.sub(scratch_v3_1);
+            scratch_v3_0.normalize();
 
-        direction.copy(v3);
+            source.copy(scratch_v3_1);
+            direction.copy(scratch_v3_0);
+
+        } else if (camera.isOrthographicCamera) {
+            throw new Error('Unsupported camera type: "Orthographic" ');
+        } else {
+            throw new Error('Unsupported camera type');
+        }
     }
 
     /**
@@ -179,7 +195,7 @@ export class Camera {
 
         const near = scratch_frustum.planes[0];
 
-        v3.set(x, y, z);
+        scratch_v3_0.set(x, y, z);
 
         const normal = near.normal;
 
@@ -199,7 +215,8 @@ Camera.typeName = "Camera";
 
 Camera.ProjectionType = ProjectionType;
 
-const v3 = new ThreeVector3();
+const scratch_v3_0 = new Vector3();
+const scratch_v3_1 = new Vector3();
 const scratch_frustum = new Frustum();
 
 

package/engine/graphics/ecs/camera/unprojectPoint.js

@@ -0,0 +1,14 @@
+//
+
+/**
+ *
+ * @param {Vector3} result
+ * @param {Vector3} input
+ * @param {number[]} projection_matrix_inverse inverse of projection matrix
+ * @param {number[]} world_matrix world transform
+ */
+export function unprojectPoint(result, input, projection_matrix_inverse, world_matrix) {
+    result.copy(input);
+    result.applyMatrix4(projection_matrix_inverse);
+    result.applyMatrix4(world_matrix);
+}

package/engine/graphics/ecs/light/binding/three/ThreeLightBinding.js

@@ -6,8 +6,6 @@ import { threeUpdateTransform } from "../../../../util/threeUpdateTransform.js";
 import { ShadowMap } from "../../shadow/ShadowMap.js";
 import { CameraView } from "../../../../render/view/CameraView.js";
 import { DoubleSide, Mesh, MeshDepthMaterial, RGBADepthPacking, Scene } from "three";
-import { SOURCE_RENDER_LAYER_PROPERTY } from "../../../../render/visibility/VisibilityComputer.js";
-import { RenderPassType } from "../../../../render/RenderPassType.js";
 import { ThreeBypassRenderer } from "../../../../render/utils/ThreeBypassRenderer.js";
 
 const shadow_scene = new Scene();
@@ -27,7 +25,8 @@ const __depth_material = new MeshDepthMaterial({
  * @private
  */
 function __getDepthMaterial(object) {
-    let result = null;
+    let result;
+
     const customDepthMaterial = object.customDepthMaterial;
 
     if (customDepthMaterial !== undefined) {
@@ -44,24 +43,31 @@ function __getDepthMaterial(object) {
  * @param {THREE.Object3D} object3D
  * @return {boolean}
  */
-function scene_input_filter(object3D) {
-    const layer = object3D[SOURCE_RENDER_LAYER_PROPERTY];
+function scene_object_filter(object3D) {
 
-    if (layer === undefined) {
+    if (object3D.castShadow === false) {
         return false;
     }
 
-    return layer.renderPass === RenderPassType.Opaque
-}
+    if (object3D.visible === false) {
+        return false;
+    }
 
-/**
- *
- * @param {THREE.Object3D} object3D
- * @return {boolean}
- */
-function scene_object_filter(object3D) {
-    return object3D.castShadow
-        && object3D.visible
+    if (object3D.isMesh) {
+
+        /**
+         * @type {THREE.Material|null|undefined}
+         */
+        const material = (object3D.customDepthMaterial !== null ? object3D.customDepthMaterial : object3D.material);
+
+        if (material && material.visible === false) {
+            //material's main
+            return false;
+        }
+
+    }
+
+    return true;
 }
 
 export class ThreeLightBinding extends LightBinding {
@@ -261,7 +267,6 @@ export class ThreeLightBinding extends LightBinding {
             input: visible_objects.elements,
             input_size: visible_object_count,
             material_extractor: __getDepthMaterial,
-            input_filter: scene_input_filter,
             object_filter: scene_object_filter
         })
 

package/engine/graphics/ecs/mesh/updateNodeByTransformAndBBB.js

@@ -1,21 +1,28 @@
-import { Matrix4 as ThreeMatrix4 } from "three";
-import { aabb3_matrix4_project_by_corners } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project_by_corners.js";
+import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
 
+/**
+ * Common buffer for scratch objects for better cache locality
+ * @type {ArrayBuffer}
+ */
+const scratch_buffer = new ArrayBuffer(28 * 4);
 
-const matrix4 = new ThreeMatrix4();
+/**
+ *
+ * @type {Float32Array}
+ */
+const scratch_matrix4 = new Float32Array(scratch_buffer, 0, 16);
 
 /**
- * Used to store AABB3 corners during bounding box calculation
- * @readonly
- * @type {Float64Array}
+ *
+ * @type {Float32Array}
  */
-const corners = new Float64Array(24);
+const scratch_aabb_0 = new Float32Array(scratch_buffer, 64, 6);
 
 /**
  *
  * @type {Float32Array}
  */
-const scratch_aabb = new Float32Array(6);
+const scratch_aabb_1 = new Float32Array(scratch_buffer, 88, 6);
 
 /**
  *
@@ -24,30 +31,23 @@ const scratch_aabb = new Float32Array(6);
  * @param {Transform} transform
  */
 export function updateNodeByTransformAndBBB(bvh, boundingBox, transform) {
-    transform.toThreeMatrix(matrix4);
+    transform.toMatrix4(scratch_matrix4);
 
-    /**
-     * Shortcut elements for faster access
-     * @type {number[]}
-     */
-    const e = matrix4.elements;
-
-    updateNodeByMatrix4AndBBB(bvh, boundingBox, e);
+    updateNodeByMatrix4AndBBB(bvh, boundingBox, scratch_matrix4);
 }
 
 /**
  *
  * @param {LeafNode} bvh
  * @param {AABB3} boundingBox
- * @param {number[]} matrix4
+ * @param {ArrayLike<number>|number[]|Float32Array} matrix4
  */
 export function updateNodeByMatrix4AndBBB(bvh, boundingBox, matrix4) {
-    boundingBox.getCorners(corners);
-
+    boundingBox.writeToArray(scratch_aabb_1, 0);
 
-    aabb3_matrix4_project_by_corners(scratch_aabb, corners, matrix4);
+    aabb3_matrix4_project(scratch_aabb_0, scratch_aabb_1, matrix4);
 
-    bvh.readFromArray(scratch_aabb, 0);
+    bvh.readFromArray(scratch_aabb_0, 0);
 
     bvh.bubbleRefit();
 }

package/engine/graphics/ecs/mesh-v2/ShadedGeometry.js

@@ -4,9 +4,14 @@ import { LeafNode } from "../../../../core/bvh2/LeafNode.js";
 import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
 import { DrawMode } from "./DrawMode.js";
 import { applyTransformToThreeObject } from "../mesh/applyTransformToThreeObject.js";
+import { ShadedGeometryFlags } from "./ShadedGeometryFlags.js";
 
 const _aabb3 = new AABB3();
 
+const DEFAULT_FLAGS = ShadedGeometryFlags.CastShadow
+    | ShadedGeometryFlags.ReceiveShadow
+;
+
 export class ShadedGeometry {
     constructor() {
         /**
@@ -58,7 +63,7 @@ export class ShadedGeometry {
          *
          * @type {number}
          */
-        this.flags = 0;
+        this.flags = DEFAULT_FLAGS;
     }
 
     /**
@@ -147,6 +152,9 @@ export class ShadedGeometry {
         object.matrixAutoUpdate = false;
         object.frustumCulled = false;
 
+        object.castShadow = this.getFlag(ShadedGeometryFlags.CastShadow);
+        object.receiveShadow = this.getFlag(ShadedGeometryFlags.ReceiveShadow);
+
         this.__cached_object = object;
     }
 

package/engine/graphics/ecs/mesh-v2/ShadedGeometryFlags.js

@@ -3,5 +3,8 @@
  * @enum {number}
  */
 export const ShadedGeometryFlags = {
-    InView: 1
+    InView: 1,
+
+    CastShadow: 2,
+    ReceiveShadow: 4,
 };

package/engine/graphics/ecs/mesh-v2/sample/load_gltf.js

@@ -5,6 +5,7 @@ import { EngineConfiguration } from "../../../../EngineConfiguration.js";
 import { GLTFAssetLoader } from "../../../../asset/loaders/GLTFAssetLoader.js";
 import { three_object_to_entity_composition } from "../three_object_to_entity_composition.js";
 import { AttachmentSystem } from "../../../../ecs/attachment/AttachmentSystem.js";
+import { TransformAttachmentSystem } from "../../../../ecs/transform-attachment/TransformAttachmentSystem.js";
 
 const eh = new EngineHarness();
 
@@ -20,6 +21,7 @@ async function init(harness) {
 
     config.addSystem(new ShadedGeometrySystem(engine));
     config.addSystem(new AttachmentSystem());
+    config.addSystem(new TransformAttachmentSystem());
     config.addLoader(GameAssetType.ModelGLTF_JSON, new GLTFAssetLoader());
 
     await config.apply(engine);
@@ -29,20 +31,15 @@ async function init(harness) {
 
 /**
  *
+ * @param {string} path
  * @param {Engine} engine
  */
-async function main(engine) {
-
+async function load_gltf(path, engine) {
     const em = engine.entityManager;
 
-    EngineHarness.buildBasics({
-        engine,
-        enableWater: false
-    })
-
     const ecd = em.dataset;
 
-    const asset = await engine.assetManager.promise('moicon/06_04_hapro/08-clickable-assets-new/model.gltf', GameAssetType.ModelGLTF_JSON);
+    const asset = await engine.assetManager.promise(path, GameAssetType.ModelGLTF_JSON);
 
     const three_object = asset.create();
 
@@ -57,4 +54,31 @@ async function main(engine) {
     console.timeEnd('composition build');
 }
 
+async function timeout(t = 1) {
+    await new Promise((resolve, reject) => setTimeout(resolve, t));
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+async function main(engine) {
+
+    EngineHarness.buildBasics({
+        engine,
+        enableWater: false,
+        enableTerrain: false
+    });
+
+    // a small delay to let background tasks finish, so we can get better performance reading later on
+    timeout(20);
+
+    load_gltf('moicon/06_04_hapro/08-clickable-assets-new/model.gltf', engine);
+    // load_gltf('moicon/06_04_hapro/07-1st-basement/model.gltf', engine);
+    // load_gltf('moicon/06_04_hapro/06-lower-ground/model.gltf', engine);
+    // load_gltf('moicon/06_04_hapro/05-ground-floor/model.gltf', engine);
+    // load_gltf('moicon/06_04_hapro/04-1st-floor/model.gltf', engine);
+    // load_gltf('moicon/06_04_hapro/03-2nd-floor/model.gltf', engine);
+}
+
 init(eh);

package/engine/graphics/ecs/water2/shader/AlexWaterShader.js

@@ -228,7 +228,13 @@ export function makeAlexWaterMaterial() {
         blending: NormalBlending,
         lights: false,
         fog: false,
-        depthTest: true,
+
+        /*
+         forcing transparent pass in Graphics Engine
+         three.js and indeed WebGL doesn't provide a way to pass depth buffer into the main draw pass (to canvas), so this is a workaround
+         */
+        depthTest: false,
+        depthWrite: false,
         transparent: true,
         vertexColors: false
     });

package/engine/graphics/geometry/instancing/InstancedMeshGroup.js

@@ -274,7 +274,7 @@ export class InstancedMeshGroup {
         //get index
         const index = this.count;
         //grow
-        this.setCount(this.count + 1);
+        this.setCount(index + 1);
 
         this.indices[reference] = index;
         this.references[index] = reference;
@@ -320,11 +320,13 @@ export class InstancedMeshGroup {
 
         const lastIndex = this.count - 1;
 
+        const references = this.references;
+
         if (index === lastIndex) {
             //easy case, reference is placed at the end, no swap needed, we can just forget about it
-            delete this.references[index];
+            delete references[index];
         } else {
-            //not at the end, move end reference to this place
+            //not at the end, move the very last reference to this place, effectively shrinking the set
             const index3 = index * 3;
             const start3 = lastIndex * 3;
             const end3 = start3 + 3;
@@ -333,26 +335,30 @@ export class InstancedMeshGroup {
             const start4 = lastIndex * 4;
             const end4 = start4 + 4;
 
-            this.__attributePosition.array.copyWithin(index3, start3, end3);
-            this.__attributeRotation.array.copyWithin(index4, start4, end4);
-            this.__attributeScale.array.copyWithin(index3, start3, end3);
+            const a_position = this.__attributePosition;
+            const a_rotation = this.__attributeRotation;
+            const a_scale = this.__attributeScale;
+
+            a_position.array.copyWithin(index3, start3, end3);
+            a_rotation.array.copyWithin(index4, start4, end4);
+            a_scale.array.copyWithin(index3, start3, end3);
 
-            this.__attributePosition.needsUpdate = true;
-            this.__attributeRotation.needsUpdate = true;
-            this.__attributeScale.needsUpdate = true;
+            a_position.needsUpdate = true;
+            a_rotation.needsUpdate = true;
+            a_scale.needsUpdate = true;
 
             //update moved reference index
-            const movedReference = this.references[lastIndex];
+            const movedReference = references[lastIndex];
 
             if (movedReference === undefined) {
                 //moved reference not found
                 throw new Error(`Moved reference was not found`);
             }
 
-            delete this.references[lastIndex];
+            delete references[lastIndex];
 
             //assume the place of removed reference
-            this.references[index] = movedReference;
+            references[index] = movedReference;
             this.indices[movedReference] = index;
         }
 

package/engine/graphics/micron/build/buildMicronGeometryFromBufferGeometry.js

@@ -14,8 +14,7 @@ import { build_leaf_patches_metis } from "./clustering/build_leaf_patches_metis.
 import { compute_buffer_geometry_byte_size } from "../../geometry/buffered/compute_buffer_geometry_byte_size.js";
 import { deinterleaveBufferGeometry } from "../../geometry/buffered/deinterleaveBufferGeometry.js";
 import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
-import { min2 } from "../../../../core/math/min2.js";
-import { max2 } from "../../../../core/math/max2.js";
+import { aabb3_from_v3_array } from "../../../../core/bvh2/aabb3/aabb3_from_v3_array.js";
 
 /**
  * Returns current time in milliseconds
@@ -118,38 +117,6 @@ function attributes_from_buffer_geometry(buffer_geometry) {
 
 const PRINT_VERBOSE_STATS = false;
 
-/**
- *
- * @param {AABB3} result
- * @param {number[]|ArrayLike<number>} input
- * @param {number} input_length
- */
-function aabb3_from_v3_array(result, input, input_length) {
-    let x0 = Infinity;
-    let y0 = Infinity;
-    let z0 = Infinity;
-
-    let x1 = -Infinity;
-    let y1 = -Infinity;
-    let z1 = -Infinity;
-
-    for (let i = 0; i < input_length; i += 3) {
-        const x = input[i];
-        const y = input[i + 1];
-        const z = input[i + 2];
-
-        x0 = min2(x, x0);
-        y0 = min2(y, y0);
-        z0 = min2(z, z0);
-
-        x1 = max2(x, x1);
-        y1 = max2(y, y1);
-        z1 = max2(z, z1);
-    }
-
-    result.setBounds(x0, y0, z0, x1, y1, z1);
-}
-
 /**
  *
  * @param {THREE.BufferGeometry} input

package/engine/graphics/micron/build/fill_patch_geometry_data.js

@@ -113,6 +113,15 @@ function normalize_to_int8(value) {
     return Math.round(value * 127);
 }
 
+/**
+ *
+ * @param {number} value
+ * @return {number}
+ */
+function normalize_to_uint8(value) {
+    return Math.round(value * 255);
+}
+
 /**
  * @enum {function(number):number}
  */
@@ -120,6 +129,7 @@ const DataConverterType = {
     None: passThrough,
     Number2HalfFloat: to_half_float_uint16,
     Normalize2Int8: normalize_to_int8,
+    Normalize2Uint8: normalize_to_uint8,
     ResampleNormalized_Uint16_to_Uint8: resample_normalized_uint16_to_uint8
 };
 
@@ -137,6 +147,8 @@ function compute_attribute_data_converter(source, spec) {
         // source data can be normalized but isn't
         if (target_type === DataType.Int8) {
             return DataConverterType.Normalize2Int8;
+        } else if (target_type === DataType.Uint8) {
+            return DataConverterType.Normalize2Uint8;
         } else {
             throw new Error(`Unsupported normalized type '${target_type}'`);
         }

package/engine/graphics/micron/format/MicronGeometry.js

@@ -4,6 +4,7 @@ import { computeTriangleRayIntersection } from "../../../../core/geom/3d/triangl
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import { aabb3_array_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_array_intersects_ray.js";
 import { sphere_array_intersects_ray } from "../../../../core/geom/3d/sphere/sphere_array_intersects_ray.js";
+import { BitSet } from "../../../../core/binary/BitSet.js";
 
 let id_counter = 0;
 
@@ -13,6 +14,13 @@ let id_counter = 0;
  */
 const scratch_traversal_stack = [];
 
+/**
+ *
+ * @type {BitSet}
+ */
+const scratch_traversal_bitset = new BitSet();
+scratch_traversal_bitset.preventShrink();
+
 export class MicronGeometry {
     constructor() {
         /**
@@ -79,6 +87,7 @@ export class MicronGeometry {
         origin_x, origin_y, origin_z,
         direction_x, direction_y, direction_z
     ) {
+
         let i;
         let stack_cursor = 1;
 
@@ -99,6 +108,11 @@ export class MicronGeometry {
         // check that position attribute actually exists
         assert.isNonNegativeInteger(position_attribute_index, 'position_attribute_index');
 
+        const included_set = scratch_traversal_bitset;
+        included_set.reset();
+
+        included_set.set(this.root.id, true);
+
         const temp_hit = new SurfacePoint3();
 
         while (stack_cursor > 0) {
@@ -106,6 +120,7 @@ export class MicronGeometry {
 
             const patch = stack[stack_cursor];
 
+
             if (patch.lod === 0) {
                 // LOD 0 - source geometry
 
@@ -206,9 +221,15 @@ export class MicronGeometry {
                 for (i = 0; i < child_count; i++) {
                     const child = children[i];
 
+                    if (included_set.get(child.id)) {
+                        continue;
+                    }
+
                     // push to stack
                     stack[stack_cursor] = child;
 
+                    included_set.set(child.id, true);
+
                     stack_cursor++;
                 }
             }

package/engine/graphics/micron/format/MicronGeometryPatch.js

@@ -68,13 +68,6 @@ export class MicronGeometryPatch {
          */
         this.children = [];
 
-        /**
-         * Runtime dependency patches, if this patch is refined at runtime - dependencies must be refined as well
-         * These dependencies allow for more aggressive simplification of topology
-         * @type {number[]}
-         */
-        this.dependencies = [];
-
         /**
          * Level of detail, lower number means more detailed
          * @type {number}

package/engine/graphics/micron/plugin/MicronRenderPlugin.js

@@ -2,7 +2,6 @@ import { EnginePlugin } from "../../../plugin/EnginePlugin.js";
 import { VGThreeRenderer } from "../render/v1/VGThreeRenderer.js";
 import { RenderLayer } from "../../render/layers/RenderLayer.js";
 import { RenderPassType } from "../../render/RenderPassType.js";
-import { SOURCE_RENDER_LAYER_PROPERTY } from "../../render/visibility/VisibilityComputer.js";
 import { AssetTransformer } from "../../../asset/AssetTransformer.js";
 import { convert_three_object_to_micron } from "../convert_three_object_to_micron.js";
 import { Cache } from "../../../../core/cache/Cache.js";
@@ -180,8 +179,6 @@ export class MicronRenderPlugin extends EnginePlugin {
 
             const mesh = ctx.mesh;
 
-            mesh[SOURCE_RENDER_LAYER_PROPERTY] = layer;
-
             visibleSet.elements.push(mesh);
             visibleSet.size++;