@woosh/meep-engine 2.35.8 → 2.35.12

package/engine/graphics/micron/render/VirtualGeometryBuilder.js

@@ -1,17 +1,10 @@
 import { array_copy } from "../../../../core/collection/array/copyArray.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
 import { RefinementSpec } from "./refinement/RefinementSpec.js";
-import { ActivePatchList } from "./refinement/ActivePatchList.js";
 import { mat4 } from "gl-matrix";
 import { get_geometry_patch_cut } from "./refinement/get_geometry_patch_cut.js";
 import { traverseThreeObject } from "../../ecs/highlight/renderer/traverseThreeObject.js";
 
-/**
- * @readonly
- * @type {RefinementSpec}
- */
-const refinement_spec = new RefinementSpec();
-
 export class VirtualGeometryBuilder {
     constructor() {
 
@@ -60,13 +53,6 @@ export class VirtualGeometryBuilder {
          */
         this.resolution = new Vector2();
 
-        /**
-         *
-         * @type {ActivePatchList}
-         * @private
-         */
-        this.__acl = new ActivePatchList();
-
         /**
          * How much error to accept when deciding to subdivide a cluster
          * Measured in pixels
@@ -74,10 +60,15 @@ export class VirtualGeometryBuilder {
          * @type {number}
          */
         this.error_bias = 2;
+
+        /**
+         *
+         * @type {RefinementSpec}
+         */
+        this.refinement_spec = new RefinementSpec();
     }
 
     dropCache() {
-        this.__acl.clear();
     }
 
     /**
@@ -103,7 +94,7 @@ export class VirtualGeometryBuilder {
         mat4.multiply(this.view_projection_matrix, this.matrix_projection, this.matrix_world_inverse);
 
         //
-        refinement_spec.focal_length = camera.fov / 180;
+        this.refinement_spec.focal_length = camera.fov / 180;
     }
 
     /**
@@ -121,17 +112,15 @@ export class VirtualGeometryBuilder {
              * @type {MicronGeometry|undefined}
              */
             const micron_geometry = object.geometry;
-            if (micron_geometry !== undefined) {
-                // get acl
-                const acl = this.__acl;
 
+            if (micron_geometry !== undefined) {
 
                 this.buildForMesh(
                     object.instance_id,
                     micron_geometry,
-                    object.matrixWorld.elements,
-                    acl
+                    object.matrixWorld.elements
                 );
+
             }
         }
     }
@@ -147,6 +136,8 @@ export class VirtualGeometryBuilder {
         geometry,
         transform
     ) {
+        const refinement_spec = this.refinement_spec;
+
         refinement_spec.build(transform, this.view_projection_matrix);
 
         const output = this.output;
@@ -183,17 +174,21 @@ export class VirtualGeometryBuilder {
         this.input_scene_length += object_count;
     }
 
-    build() {
+    initialize_build() {
 
         // update refinement spec
-        refinement_spec.error_threshold = this.error_bias;
+        this.refinement_spec.error_threshold = this.error_bias;
 
         const resolution = this.resolution;
 
-        refinement_spec.setResolution(resolution.x, resolution.y);
+        this.refinement_spec.setResolution(resolution.x, resolution.y);
 
         // clear output
         this.output.clear();
+    }
+
+    build() {
+        this.initialize_build();
 
 
         const n = this.input_scene_length;

package/engine/graphics/micron/render/instanced/ThreeInstancedAdapter.js

@@ -125,7 +125,7 @@ export class ThreeInstancedAdapter {
 
     /**
      *
-     * @param {Uint32Array[]} patches
+     * @param {Uint32Array} patches
      * @param {number} patch_count
      * @param {VirtualGeometry} virtual_geometry
      */

package/engine/graphics/micron/render/v1/MaterialContext.js

@@ -52,7 +52,7 @@ export class MaterialContext {
 
         /**
          *
-         * @type {MicronGeometryPatchOccurrence[]}
+         * @type {Uint32Array|number[]}
          */
         this.__patches = [];
 
@@ -63,16 +63,6 @@ export class MaterialContext {
         this.__patch_count = 0;
     }
 
-
-    /**
-     *
-     * @param {MicronGeometryPatchOccurrence} occurrence
-     * @returns {boolean}
-     */
-    filter(occurrence) {
-        return this.instances.has(occurrence.instance_id);
-    }
-
     init() {
 
         const material = this.material.clone();

package/engine/graphics/micron/render/v1/MaterialVertexSpec.js

@@ -1,3 +1,8 @@
+export const MaterialVertexSpecFlags = {
+    CastShadow: 1,
+    ReceiveShadow: 2
+};
+
 export class MaterialVertexSpec {
     constructor() {
         /**
@@ -10,6 +15,52 @@ export class MaterialVertexSpec {
          * @type {THREE.Material|null}
          */
         this.material = null;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.flags = 0;
+    }
+
+    /**
+     *
+     * @param {number|MaterialVertexSpecFlags} flag
+     * @returns {void}
+     */
+    setFlag(flag) {
+        this.flags |= flag;
+    }
+
+    /**
+     *
+     * @param {number|MaterialVertexSpecFlags} flag
+     * @returns {void}
+     */
+    clearFlag(flag) {
+        this.flags &= ~flag;
+    }
+
+    /**
+     *
+     * @param {number|MaterialVertexSpecFlags} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag, value) {
+        if (value) {
+            this.setFlag(flag);
+        } else {
+            this.clearFlag(flag);
+        }
+    }
+
+    /**
+     *
+     * @param {number|MaterialVertexSpecFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag) {
+        return (this.flags & flag) === flag;
     }
 
     /**
@@ -19,6 +70,7 @@ export class MaterialVertexSpec {
     copy(other) {
         this.spec = other.spec;
         this.material = other.material;
+        this.flags = other.flags;
     }
 
     /**
@@ -47,7 +99,7 @@ export class MaterialVertexSpec {
     }
 
     hash() {
-        return this.spec.hash() ^ this.material.id;
+        return this.spec.hash() ^ this.material.id ^ this.flags;
     }
 
     equals(other) {
@@ -55,8 +107,9 @@ export class MaterialVertexSpec {
             return true;
         }
 
-        return this.spec.equals(other.spec)
+        return this.flags === other.flags
             && this.material === other.material
+            && this.spec.equals(other.spec)
             ;
     }
 }

package/engine/graphics/micron/render/v1/MicronRenderContext.js

@@ -0,0 +1,151 @@
+import { VirtualGeometry } from "../../format/VirtualGeometry.js";
+import { VirtualGeometryBuilder } from "../VirtualGeometryBuilder.js";
+import { HashMap } from "../../../../../core/collection/HashMap.js";
+import Signal from "../../../../../core/events/signal/Signal.js";
+import { MaterialContext } from "./MaterialContext.js";
+import { MaterialVertexSpec, MaterialVertexSpecFlags } from "./MaterialVertexSpec.js";
+
+/**
+ *
+ * @type {MaterialVertexSpec}
+ */
+const scratch_mvc = new MaterialVertexSpec();
+
+export class MicronRenderContext {
+    constructor() {
+
+        this.geometry = new VirtualGeometry();
+
+        this.builder = new VirtualGeometryBuilder();
+
+        /**
+         *
+         * @type {Map<MaterialVertexSpec, MaterialContext>}
+         */
+        this.material_contexts = new HashMap();
+
+        /**
+         *
+         * @type {MaterialContext[]}
+         * @private
+         */
+        this.__contexts_array = [];
+
+        this.on = {
+            /**
+             * @type {Signal<MaterialContext>}
+             */
+            contextAdded: new Signal()
+        };
+    }
+
+    /**
+     *
+     * @returns {MaterialContext[]}
+     */
+    get contexts_array() {
+        return this.__contexts_array;
+    }
+
+    /**
+     * Enable/disable wireframe rendering
+     * @param {boolean} x
+     */
+    set wireframe(x) {
+        this.material_contexts.forEach((ctx, mv) => {
+
+
+            ctx.compiled_material.wireframe = x;
+
+        });
+    }
+
+
+    /**
+     *
+     * @param {MaterialVertexSpec} descriptor
+     * @returns {MaterialContext}
+     */
+    obtain_material(descriptor) {
+
+        const existing = this.material_contexts.get(descriptor);
+
+        if (existing !== undefined) {
+            return existing;
+        }
+
+        // create a separate instance to be stored alongside the context
+        const key = descriptor.clone();
+
+        const ctx = new MaterialContext(descriptor.spec, descriptor.material);
+
+        ctx.init();
+
+        ctx.mesh.castShadow = descriptor.getFlag(MaterialVertexSpecFlags.CastShadow);
+        ctx.mesh.receiveShadow = descriptor.getFlag(MaterialVertexSpecFlags.ReceiveShadow);
+
+        this.material_contexts.set(key, ctx);
+        this.__contexts_array.push(ctx);
+
+        this.on.contextAdded.send1(ctx);
+
+        return ctx;
+    }
+
+    render() {
+        const render_context = this;
+        const contexts = render_context.__contexts_array;
+        const context_count = contexts.length;
+
+        /**
+         *
+         * @type {Map<number, MaterialContext>}
+         */
+        const instance_to_ctx = new Map();
+
+        let i = 0;
+
+        for (i = 0; i < context_count; i++) {
+            const ctx = contexts[i];
+            ctx.__patch_count = 0;
+
+            for (const instance of ctx.instances) {
+                instance_to_ctx.set(instance, ctx);
+            }
+        }
+
+        // sort patches into relevant contexts
+        const geometry = render_context.geometry;
+        const patch_count = geometry.patch_count;
+        const patches = geometry.patches;
+
+        for (i = 0; i < patch_count; i++) {
+            const i3 = i * 3;
+
+            const instance_id = patches[i3];
+            const geometry_id = patches[i3 + 1];
+            const patch_id = patches[i3 + 2];
+
+            const ctx = instance_to_ctx.get(instance_id);
+
+            const target_index = ctx.__patch_count;
+            const target_address = target_index * 3;
+
+            ctx.__patch_count++;
+
+            const ctx_patches = ctx.__patches;
+
+            ctx_patches[target_address] = instance_id;
+            ctx_patches[target_address + 1] = geometry_id;
+            ctx_patches[target_address + 2] = patch_id;
+        }
+
+        // build each context
+        for (i = 0; i < context_count; i++) {
+            const ctx = contexts[i];
+
+            ctx.build(geometry);
+        }
+    }
+
+}

package/engine/graphics/micron/render/v1/VGThreeRenderer.js

@@ -1,11 +1,8 @@
-import { VirtualGeometryBuilder } from "../VirtualGeometryBuilder.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
-import { VirtualGeometry } from "../../format/VirtualGeometry.js";
 import { MaterialContext } from "./MaterialContext.js";
-import { MaterialVertexSpec } from "./MaterialVertexSpec.js";
-import { HashMap } from "../../../../../core/collection/HashMap.js";
-import Signal from "../../../../../core/events/signal/Signal.js";
 import { array_copy } from "../../../../../core/collection/array/copyArray.js";
+import { MicronRenderContext } from "./MicronRenderContext.js";
+import { MaterialVertexSpec, MaterialVertexSpecFlags } from "./MaterialVertexSpec.js";
 
 /**
  *
@@ -15,23 +12,6 @@ const scratch_mvc = new MaterialVertexSpec();
 
 export class VGThreeRenderer {
     constructor() {
-        this.geometry = new VirtualGeometry();
-
-        this.builder = new VirtualGeometryBuilder();
-
-        /**
-         *
-         * @type {Map<MaterialVertexSpec, MaterialContext>}
-         */
-        this.material_contexts = new HashMap();
-
-        /**
-         *
-         * @type {MaterialContext[]}
-         * @private
-         */
-        this.__contexts_array = [];
-
         /**
          *
          * @type {Object3D[]}
@@ -39,82 +19,51 @@ export class VGThreeRenderer {
          */
         this.__inputs = [];
 
+        this.ctx = new MicronRenderContext();
+
         this.on = {
             /**
              * @type {Signal<MaterialContext>}
              */
-            contextAdded: new Signal()
+            contextAdded: this.ctx.on.contextAdded
         };
     }
 
+    get geometry() {
+        return this.ctx.geometry;
+    }
+
     /**
      * Enable/disable wireframe rendering
      * @param {boolean} x
      */
     set wireframe(x) {
-        this.material_contexts.forEach((ctx, mv) => {
-
-
-            ctx.compiled_material.wireframe = x;
-
-        });
+        this.ctx.wireframe = x;
     }
 
-    /**
-     *
-     * @param {VertexDataSpec} spec
-     * @param {Material} m
-     * @returns {MaterialContext}
-     * @private
-     */
-    __obtain_material(spec, m) {
-        scratch_mvc.material = m;
-        scratch_mvc.spec = spec;
-
-        const existing = this.material_contexts.get(scratch_mvc);
-
-        if (existing !== undefined) {
-            return existing;
-        }
-
-        // create a separate instance to be stored alongside the context
-        const key = scratch_mvc.clone();
-
-        const ctx = new MaterialContext(spec, m);
-
-        ctx.init();
-
-        this.material_contexts.set(key, ctx);
-        this.__contexts_array.push(ctx);
-
-        this.on.contextAdded.send1(ctx);
-
-        return ctx;
-    }
-
-
     /**
      *
      * @param {THREE.Scene} scene
      */
     attach(scene) {
         this.__inputs.push(scene);
-        this.builder.appendToScene([scene]);
+        this.ctx.builder.appendToScene([scene]);
     }
 
     attachMany(objects) {
         array_copy(objects, 0, this.__inputs, this.__inputs.length, objects.length);
-        this.builder.appendToScene(objects);
+        this.ctx.builder.appendToScene(objects);
     }
 
     clear() {
         this.__inputs = [];
-        this.builder.clearScene();
+        this.ctx.builder.clearScene();
     }
 
     __prepare_contexts() {
         // clear contexts
-        const contexts = this.__contexts_array;
+        const render_context = this.ctx;
+        const contexts = render_context.__contexts_array;
         const context_count = contexts.length;
 
         for (let i = 0; i < context_count; i++) {
@@ -131,7 +80,12 @@ export class VGThreeRenderer {
                  */
                 const m = o;
 
-                const ctx = this.__obtain_material(m.geometry.vertex_spec, m.material);
+                scratch_mvc.material = m.material;
+                scratch_mvc.spec = m.geometry.vertex_spec;
+                scratch_mvc.writeFlag(MaterialVertexSpecFlags.CastShadow, m.castShadow);
+                scratch_mvc.writeFlag(MaterialVertexSpecFlags.ReceiveShadow, m.receiveShadow);
+
+                const ctx = render_context.obtain_material(scratch_mvc);
 
                 ctx.instances.add(o.instance_id);
             }
@@ -149,54 +103,7 @@ export class VGThreeRenderer {
     }
 
     render() {
-        const contexts = this.__contexts_array;
-        const context_count = contexts.length;
-
-        /**
-         *
-         * @type {Map<number, MaterialContext>}
-         */
-        const instance_to_ctx = new Map();
-
-        for (let i = 0; i < context_count; i++) {
-            const ctx = contexts[i];
-            ctx.__patch_count = 0;
-
-            for (const instance of ctx.instances) {
-                instance_to_ctx.set(instance, ctx);
-            }
-        }
-
-        // sort patches into relevant contexts
-        const geometry = this.geometry;
-        const patch_count = geometry.patch_count;
-        const patches = geometry.patches;
-
-        for (let i = 0; i < patch_count; i++) {
-            const i3 = i * 3;
-
-            const instance_id = patches[i3];
-            const geometry_id = patches[i3 + 1];
-            const patch_id = patches[i3 + 2];
-
-            const ctx = instance_to_ctx.get(instance_id);
-
-            const target_address = ctx.__patch_count * 3;
-            ctx.__patch_count++;
-
-            const ctx_patches = ctx.__patches;
-
-            ctx_patches[target_address] = instance_id;
-            ctx_patches[target_address + 1] = geometry_id;
-            ctx_patches[target_address + 2] = patch_id;
-        }
-
-        // build each context
-        for (let i = 0; i < context_count; i++) {
-            const ctx = contexts[i];
-
-            ctx.build(this.geometry);
-        }
+        this.ctx.render();
     }
 
 
@@ -224,11 +131,11 @@ export class VGThreeRenderer {
             pixelRatio = renderer.getPixelRatio();
         }
 
-        const vg_builder = this.builder;
+        const vg_builder = this.ctx.builder;
 
         vg_builder.resolution.set(resolution.x * pixelRatio, resolution.y * pixelRatio);
         vg_builder.setMatricesFromCamera(camera);
-        vg_builder.setOutput(this.geometry);
+        vg_builder.setOutput(this.ctx.geometry);
 
         vg_builder.build();
     }

package/engine/graphics/particles/particular/engine/utils/volume/ParticleVolume.js

@@ -390,6 +390,7 @@ export class ParticleVolume {
 
         // request bounds update
         emitter.setFlag(ParticleEmitterFlag.ParticleBoundsNeedUpdate);
+        emitter.computeBoundingBox();
     }
 
     /**

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.35.8",
+  "version": "2.35.12",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",