@woosh/meep-engine 2.35.9 → 2.35.10

package/engine/graphics/ecs/path/tube/build/makeTubeGeometry.js

@@ -0,0 +1,156 @@
+import { BufferGeometry, Float32BufferAttribute, Vector3 } from "three";
+
+/**
+ * @see https://github.com/mrdoob/three.js/blob/master/src/geometries/TubeGeometry.js
+ * @param {Vector3[]} points
+ * @param {Vector3[]} _normals
+ * @param {Vector3[]} binormals
+ * @param {number} radius
+ * @param {number} radialSegments
+ * @param {boolean} [closed]
+ * @returns {BufferGeometry}
+ */
+export function makeTubeGeometry(points, _normals, binormals, radius, radialSegments, closed = false) {
+    const geometry = new BufferGeometry();
+    // helper variables
+
+    const vertex = new Vector3();
+    const normal = new Vector3();
+
+    // buffer
+
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    const indices = [];
+
+    const tubularSegments = points.length - 1;
+
+    // create buffer data
+
+    generateBufferData();
+
+    // build geometry
+
+    geometry.setIndex(indices);
+    geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3));
+    geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3));
+    geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
+
+    // functions
+
+    function generateBufferData() {
+
+        for (let i = 0; i < tubularSegments; i++) {
+
+            generateSegment(i);
+
+        }
+
+        // if the geometry is not closed, generate the last row of vertices and normals
+        // at the regular position on the given path
+        //
+        // if the geometry is closed, duplicate the first row of vertices and normals (uvs will differ)
+
+        generateSegment((closed === false) ? tubularSegments : 0);
+
+        // uvs are generated in a separate function.
+        // this makes it easy compute correct values for closed geometries
+
+        generateUVs();
+
+        // finally create faces
+
+        generateIndices();
+
+    }
+
+    function generateSegment(i) {
+
+        // we use getPointAt to sample evenly distributed points from the given path
+
+        const P = points[i];
+
+        // retrieve corresponding normal and binormal
+
+        const N = _normals[i];
+        const B = binormals[i];
+
+        // generate normals and vertices for the current segment
+
+        const angular_step = (Math.PI * 2) / radialSegments;
+
+        for (let j = 0; j <= radialSegments; j++) {
+            const v = j * angular_step;
+
+            const sin = Math.sin(v);
+            const cos = -Math.cos(v);
+
+            // normal
+
+            normal.x = (cos * N.x + sin * B.x);
+            normal.y = (cos * N.y + sin * B.y);
+            normal.z = (cos * N.z + sin * B.z);
+            normal.normalize();
+
+            normals.push(normal.x, normal.y, normal.z);
+
+            // vertex
+
+            vertex.x = P.x + radius * normal.x;
+            vertex.y = P.y + radius * normal.y;
+            vertex.z = P.z + radius * normal.z;
+
+            vertices.push(vertex.x, vertex.y, vertex.z);
+
+        }
+
+    }
+
+    function generateIndices() {
+        let i = 0, j = 0;
+
+        for (j = 1; j <= tubularSegments; j++) {
+
+            for (i = 1; i <= radialSegments; i++) {
+
+                const s_1 = radialSegments + 1;
+
+                const a = s_1 * (j - 1) + (i - 1);
+                const b = s_1 * j + (i - 1);
+                const c = s_1 * j + i;
+                const d = s_1 * (j - 1) + i;
+
+                // faces
+
+                indices.push(a, b, d);
+                indices.push(b, c, d);
+
+            }
+
+        }
+
+    }
+
+    function generateUVs() {
+        let i = 0, j = 0;
+
+        for (i = 0; i <= tubularSegments; i++) {
+
+            const u = i / tubularSegments;
+
+            for (j = 0; j <= radialSegments; j++) {
+
+                const v = j / radialSegments;
+
+                uvs.push(u, v);
+
+            }
+
+        }
+
+    }
+
+
+    return geometry;
+}

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

@@ -1,42 +1,16 @@
 import { AbstractRenderAdapter } from "../../../ecs/mesh-v2/render/adapters/AbstractRenderAdapter.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
-import { MaterialVertexSpec } from "../../render/v1/MaterialVertexSpec.js";
-
-/**
- *
- * @type {MaterialVertexSpec}
- */
-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;
 
         /**
          *
@@ -58,7 +32,7 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
         const micron_geometry = this.__geometry_map.get(sg.geometry.id);
 
         // 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);
 
     }
 
@@ -84,67 +58,20 @@ 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();
-
-        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();
     }
 
     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/v1/MicronRenderContext.js

@@ -0,0 +1,139 @@
+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 } 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()
+        };
+    }
+
+    /**
+     * Enable/disable wireframe rendering
+     * @param {boolean} x
+     */
+    set wireframe(x) {
+        this.material_contexts.forEach((ctx, mv) => {
+
+
+            ctx.compiled_material.wireframe = x;
+
+        });
+    }
+
+
+    /**
+     *
+     * @param {VertexDataSpec} spec
+     * @param {Material} m
+     * @returns {MaterialContext}
+     */
+    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;
+    }
+
+    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();
+
+        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 = render_context.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(geometry);
+        }
+    }
+
+}