@woosh/meep-engine 2.35.9 → 2.35.13

package/engine/graphics/micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js

@@ -1,6 +1,8 @@
 import { AbstractRenderAdapter } from "../../../ecs/mesh-v2/render/adapters/AbstractRenderAdapter.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
-import { MaterialVertexSpec } from "../../render/v1/MaterialVertexSpec.js";
+import { buildMicronGeometryFromBufferGeometry } from "../../build/buildMicronGeometryFromBufferGeometry.js";
+import { ShadedGeometryFlags } from "../../../ecs/mesh-v2/ShadedGeometryFlags.js";
+import { MaterialVertexSpec, MaterialVertexSpecFlags } from "../../render/v1/MaterialVertexSpec.js";
 
 /**
  *
@@ -8,35 +10,16 @@ import { MaterialVertexSpec } from "../../render/v1/MaterialVertexSpec.js";
  */
 const scratch_mvc = new MaterialVertexSpec();
 
-class MicronRenderContext {
-
-}
-
 export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
-    constructor({
-                    vgtr
-                }) {
-        super();
-
-        /**
-         * @type {VGThreeRenderer}
-         * @private
-         */
-        this.__vgtr = vgtr;
 
-        /**
-         *
-         * @type {VirtualGeometry|null}
-         * @private
-         */
-        this.__vg = null;
+    constructor() {
+        super();
 
         /**
          *
-         * @type {VirtualGeometryBuilder|null}
-         * @private
+         * @type {MicronRenderContext|null}
          */
-        this.__vgb = null;
+        this.ctx = null;
 
         /**
          *
@@ -47,18 +30,41 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
 
         /**
          *
-         * @type {Set<MaterialContext>}
+         * @type {Map<number, Promise>}
          * @private
          */
-        this.__active_contexts = new Set();
+        this.__geometry_building_promises = new Map();
     }
 
     add(sg) {
 
-        const micron_geometry = this.__geometry_map.get(sg.geometry.id);
+        const geometry_id = sg.geometry.id;
+
+        const micron_geometry = this.__geometry_map.get(geometry_id);
+
+        if (micron_geometry === undefined) {
+            // no micron geometry
+            if (!this.__geometry_building_promises.has(geometry_id)) {
+                const p = buildMicronGeometryFromBufferGeometry(sg.geometry);
+
+                this.__geometry_building_promises.set(geometry_id, p);
+
+                p.then(mg => this.__geometry_map.set(geometry_id, mg));
+            }
+            return;
+        }
 
         // populate virtual geometry for this instance
-        this.__vgb.buildForMesh(sg.entity, micron_geometry, sg.transform);
+        this.ctx.builder.buildForMesh(sg.entity, micron_geometry, sg.transform);
+
+        scratch_mvc.material = sg.material;
+        scratch_mvc.spec = micron_geometry.vertex_spec;
+        scratch_mvc.writeFlag(MaterialVertexSpecFlags.CastShadow, sg.getFlag(ShadedGeometryFlags.CastShadow));
+        scratch_mvc.writeFlag(MaterialVertexSpecFlags.ReceiveShadow, sg.getFlag(ShadedGeometryFlags.ReceiveShadow));
+
+        const material_context = this.ctx.obtain_material(scratch_mvc);
+
+        material_context.instances.add(sg.entity);
 
     }
 
@@ -84,67 +90,30 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
             pixelRatio = renderer.getPixelRatio();
         }
 
-        const vg_builder = this.__vgb;
+        const vg_builder = this.ctx.builder;
 
         vg_builder.resolution.set(resolution.x * pixelRatio, resolution.y * pixelRatio);
         vg_builder.setMatricesFromCamera(view.camera);
-        vg_builder.setOutput(this.__vg);
+        vg_builder.setOutput(this.ctx.geometry);
 
-        vg_builder.build();
+        vg_builder.initialize_build();
     }
 
     build_end() {
-        const contexts = this.__contexts_array;
-        const context_count = contexts.length;
-
-        /**
-         *
-         * @type {Map<number, MaterialContext>}
-         */
-        const instance_to_ctx = new Map();
+        this.ctx.render();
 
-        for (let i = 0; i < context_count; i++) {
-            const ctx = contexts[i];
-            ctx.__patch_count = 0;
+        const material_contexts = this.ctx.contexts_array;
+        const contexts_count = material_contexts.length;
+        for (let i = 0; i < contexts_count; i++) {
+            const mc = material_contexts[i];
 
-            for (const instance of ctx.instances) {
-                instance_to_ctx.set(instance, ctx);
+            if (mc.instances.size > 0) {
+                this.__objects[this.__object_count++] = mc.mesh;
             }
         }
-
-        // 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);
-        }
     }
 
     dispose() {
-
+        // rendering context is not owned, do nothing
     }
 }

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);
+        }
+    }
+
+}