@woosh/meep-engine 2.35.8 → 2.35.12

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

@@ -0,0 +1,32 @@
+import { CatmullRomCurve3 } from "three";
+import { computeFrenetFrames } from "./computeFrenetFrames.js";
+import { makeTubeGeometry } from "./makeTubeGeometry.js";
+
+/**
+ *
+ * @param {THREE.Vector3[]} points
+ * @param {number} point_count
+ * @param {TubePathStyle} style
+ * @return {THREE.BufferGeometry}
+ */
+export function build_geometry_catmullrom(points, point_count, style) {
+
+    const path = new CatmullRomCurve3(points, false, "centripetal");
+
+    const sample_points = [];
+
+    // resample curve
+    const total_points = Math.ceil(point_count * style.resolution);
+
+    for (let i = 0; i < total_points; i++) {
+        const t = i / (total_points - 1);
+
+        const point = path.getPoint(t);
+
+        sample_points.push(point);
+    }
+
+    const frames = computeFrenetFrames(sample_points, false);
+
+    return makeTubeGeometry(sample_points, frames.normals, frames.binormals, style.width, style.radial_resolution, false);
+}

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

@@ -0,0 +1,16 @@
+import { computeFrenetFrames } from "./computeFrenetFrames.js";
+import { makeTubeGeometry } from "./makeTubeGeometry.js";
+
+/**
+ *
+ * @param {THREE.Vector3[]} points
+ * @param {number} point_count
+ * @param {TubePathStyle} style
+ * @return {THREE.BufferGeometry}
+ */
+export function build_geometry_linear(points, point_count, style) {
+
+    const frames = computeFrenetFrames(points, false);
+
+    return makeTubeGeometry(points, frames.normals, frames.binormals, style.width, style.radial_resolution, false);
+}

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

@@ -0,0 +1,153 @@
+import { Vector3 } from "three";
+import { Matrix4 } from "three/src/math/Matrix4.js";
+import { max2 } from "../../../../../../core/math/max2.js";
+import { min2 } from "../../../../../../core/math/min2.js";
+import * as MathUtils from "three/src/math/MathUtils.js";
+
+/**
+ * @see https://github.com/mrdoob/three.js/blob/c12c9a166a1369cdd58622fff2aff7e3a84305d7/src/extras/core/Curve.js#L260
+ * @param {Vector3[]} points
+ * @param {boolean} [closed]
+ */
+export function computeFrenetFrames(points, closed = false) {
+// see http://www.cs.indiana.edu/pub/techreports/TR425.pdf
+
+    const normal = new Vector3();
+
+    const tangents = [];
+    const normals = [];
+    const binormals = [];
+
+    const vec = new Vector3();
+    const mat = new Matrix4();
+
+    const segments = points.length - 1;
+
+    const v3_0 = new Vector3();
+    const v3_1 = new Vector3();
+
+    /**
+     *
+     * @param {number} i
+     * @param {Vector3} destination
+     */
+    function getTangent(i, destination) {
+        // get points on either side
+        const i0 = max2(i - 1, 0);
+        const i1 = min2(i + 1, segments);
+
+        const p0 = points[i0];
+        const pR = points[i];
+        const p1 = points[i1];
+
+        // get points along the lines close to the reference
+        v3_0.subVectors(p0, pR);
+        v3_0.normalize();
+
+        v3_1.subVectors(p1, pR);
+        v3_1.normalize();
+
+        destination.subVectors(v3_1, v3_0);
+        destination.normalize();
+    }
+
+    // compute the tangent vectors for each segment on the curve
+
+    for (let i = 0; i <= segments; i++) {
+
+        const tangent = new Vector3();
+        getTangent(i, tangent);
+
+        tangents[i] = tangent;
+
+    }
+
+    // select an initial normal vector perpendicular to the first tangent vector,
+    // and in the direction of the minimum tangent xyz component
+
+    normals[0] = new Vector3();
+    binormals[0] = new Vector3();
+    let min = Number.MAX_VALUE;
+    const tx = Math.abs(tangents[0].x);
+    const ty = Math.abs(tangents[0].y);
+    const tz = Math.abs(tangents[0].z);
+
+    if (tx <= min) {
+
+        min = tx;
+        normal.set(1, 0, 0);
+
+    }
+
+    if (ty <= min) {
+
+        min = ty;
+        normal.set(0, 1, 0);
+
+    }
+
+    if (tz <= min) {
+
+        normal.set(0, 0, 1);
+
+    }
+
+    vec.crossVectors(tangents[0], normal).normalize();
+
+    normals[0].crossVectors(tangents[0], vec);
+    binormals[0].crossVectors(tangents[0], normals[0]);
+
+
+    // compute the slowly-varying normal and binormal vectors for each segment on the curve
+
+    for (let i = 1; i <= segments; i++) {
+
+        normals[i] = normals[i - 1].clone();
+
+        binormals[i] = binormals[i - 1].clone();
+
+        vec.crossVectors(tangents[i - 1], tangents[i]);
+
+        if (vec.length() > Number.EPSILON) {
+
+            vec.normalize();
+
+            const theta = Math.acos(MathUtils.clamp(tangents[i - 1].dot(tangents[i]), -1, 1)); // clamp for floating pt errors
+
+            normals[i].applyMatrix4(mat.makeRotationAxis(vec, theta));
+
+        }
+
+        binormals[i].crossVectors(tangents[i], normals[i]);
+
+    }
+
+    // if the curve is closed, postprocess the vectors so the first and last normal vectors are the same
+
+    if (closed === true) {
+
+        let theta = Math.acos(MathUtils.clamp(normals[0].dot(normals[segments]), -1, 1));
+        theta /= segments;
+
+        if (tangents[0].dot(vec.crossVectors(normals[0], normals[segments])) > 0) {
+
+            theta = -theta;
+
+        }
+
+        for (let i = 1; i <= segments; i++) {
+
+            // twist a little...
+            normals[i].applyMatrix4(mat.makeRotationAxis(tangents[i], theta * i));
+            binormals[i].crossVectors(tangents[i], normals[i]);
+
+        }
+
+    }
+
+    return {
+        tangents: tangents,
+        normals: normals,
+        binormals: binormals
+    };
+}

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

@@ -0,0 +1,17 @@
+import { InterpolationType } from "../../../../../navigation/ecs/components/InterpolationType.js";
+import { estimatePathViaIterativeIntegral } from "./estimatePathViaIterativeIntegral.js";
+
+/**
+ *
+ * @param {Path} path
+ * @returns {number}
+ */
+function estimatePathLength(path) {
+
+    if (path.interpolation === InterpolationType.Linear) {
+        return path.getLength();
+    } else {
+        return estimatePathViaIterativeIntegral(path, 0.01);
+    }
+
+}

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

@@ -0,0 +1,37 @@
+import { Vector3 } from "three";
+
+/**
+ * some useful references:
+ * https://stackoverflow.com/questions/29438398/cheap-way-of-calculating-cubic-bezier-length
+ * https://stackoverflow.com/questions/1147249/connecting-catmull-rom-splines-together-and-calculating-its-length
+ * @param {Path} path
+ * @param {number} epsilon
+ */
+export function estimatePathViaIterativeIntegral(path, epsilon) {
+    let sum = 0;
+
+    let p0 = new Vector3();
+    let p1 = new Vector3();
+
+    if (!path.sample(p0, 0)) {
+        // path has 0 length
+        return 0;
+    }
+
+    for (let p = epsilon; ; i += epsilon) {
+        const ended = path.sample(p1, p);
+
+        if (ended) {
+            break;
+        }
+
+        sum += p0.distanceTo(p1);
+
+        const swap = p1;
+
+        p1 = p0;
+        p0 = swap;
+    }
+
+    return sum;
+}

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/build/buildMicronGeometryFromBufferGeometry.js

@@ -121,7 +121,7 @@ const PRINT_VERBOSE_STATS = false;
 /**
  *
  * @param {THREE.BufferGeometry} input
- * @returns {MicronGeometry}
+ * @returns {Promise<MicronGeometry>}
  */
 export async function buildMicronGeometryFromBufferGeometry(input) {
     const source_geometry = deinterleaveBufferGeometry(input);

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
     }
 }