@woosh/meep-engine 2.43.16 → 2.43.18

package/engine/graphics/geometry/AttributeSpec.js

@@ -3,22 +3,28 @@ import { computeStringHash } from "../../../core/primitives/strings/computeStrin
 import { DataTypeByteSizes } from "../../../core/collection/table/DataTypeByteSizes.js";
 import { assert } from "../../../core/assert.js";
 
+/**
+ * Describes data structure of a single data attribute, such as a scalar, or a vector
+ * This structure is designed to map well to GPU shader formats and is intended for larger datasets, such as meshes or particle clouds
+ */
 export class AttributeSpec {
     constructor() {
         /**
-         *
+         * Typically unique within a given set, used to identify the attribute
          * @type {string}
          */
         this.name = "";
 
         /**
-         *
+         * How the attribute is stored in memory and interpreted
          * @type {DataType}
          */
         this.type = DataType.Float32;
 
         /**
-         *
+         * How many elements the attribute uses. This is cardinality of a vector.
+         * 1 means the attribute is a scalar
+         * must be greater or equal to 1
          * @type {number}
          */
         this.itemSize = 1;
@@ -62,6 +68,15 @@ export class AttributeSpec {
         this.normalized = normalized;
     }
 
+    toJSON() {
+        return {
+            name: this.name,
+            type: this.type,
+            itemSize: this.itemSize,
+            normalized: this.normalized
+        };
+    }
+
     hash() {
         return computeStringHash(this.name);
     }

package/engine/graphics/geometry/VertexDataSpec.js

@@ -1,9 +1,19 @@
 import { invokeObjectHash } from "../../../core/model/object/invokeObjectHash.js";
 import { computeHashArray } from "../../../core/collection/array/computeHashArray.js";
 import { isArrayEqual } from "../../../core/collection/array/isArrayEqual.js";
+import { AttributeSpec } from "./AttributeSpec.js";
+import { assert } from "../../../core/assert.js";
 
-const DEFAULT_HASH = 123456;
+/**
+ * @readonly
+ * @type {number}
+ */
+const DEFAULT_HASH = 1234567;
 
+/**
+ * Describes a set of data attributes. A good analogy would be "all data associated with geometry vertex"
+ * @example "uv","position" and "normal" attributes of geometry vertices
+ */
 export class VertexDataSpec {
     constructor() {
         /**
@@ -13,7 +23,7 @@ export class VertexDataSpec {
         this.attributes = [];
 
         /**
-         *
+         * Cached hash for speed
          * @type {number}
          * @private
          */
@@ -92,6 +102,8 @@ export class VertexDataSpec {
      */
     add(attribute) {
 
+        assert.equal(attribute.isAttributeSpec, true, 'attribute.isAttributeSpec !== true');
+
         //check uniqueness of name
         if (this.getAttributeByName(attribute.name) !== undefined) {
             throw new Error(`Attribute named '${attribute.name}' already exists`);
@@ -111,7 +123,19 @@ export class VertexDataSpec {
      * @param {AttributeSpec[]} attributes
      */
     setAttributes(attributes) {
-        this.attributes = attributes;
+
+        this.clear();
+
+        const n = attributes.length;
+
+        for (let i = 0; i < n; i++) {
+            this.add(attributes[i]);
+        }
+
+    }
+
+    clear() {
+        this.attributes.splice(0, this.attributes.length);
 
         // reset hash to trigger hash update
         this.__hash = DEFAULT_HASH;
@@ -142,6 +166,32 @@ export class VertexDataSpec {
         return this.__hash;
     }
 
+    toJSON() {
+        return {
+            attributes: JSON.stringify(this.attributes)
+        };
+    }
+
+    fromJSON({
+                 attributes = []
+             }) {
+
+        this.clear();
+
+        const n = attributes.length;
+
+        for (let i = 0; i < n; i++) {
+
+            const aj = attributes[i];
+
+            const attribute = AttributeSpec.fromJSON(aj);
+
+            this.add(attribute);
+
+        }
+
+    }
+
     /**
      *
      * @returns {number}

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

@@ -57,8 +57,15 @@ export class VirtualGeometry {
         this.stats_source_byte_size = 0;
     }
 
+    /**
+     *
+     * @param {number} patch_count how much must be supported
+     * @return {boolean} true if capacity was sufficient, false if had to be resized
+     */
     ensureCapacity(patch_count) {
         if (this.__capacity < patch_count) {
+            // grow capacity
+
             const new_capacity = Math.ceil(max3(
                 patch_count,
                 patch_count * CAPACITY_GROW_FACTOR,

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

@@ -149,7 +149,7 @@ export class VirtualGeometryBuilder {
         output.loolup_geometries[geometry.id] = geometry;
         output.lookup_instance_transforms[instance_id] = transform;
 
-        // build up occurances
+        // build up occurrences
         get_geometry_patch_cut(
             output,
             refinement_spec,

package/engine/graphics/micron/render/refinement/get_geometry_patch_cut.js

@@ -95,11 +95,13 @@ export function get_geometry_patch_cut(
                 for (i = 0; i < child_count; i++) {
                     const child = children[i];
 
-                    if (included_set.getAndSet(child.id)) {
+                    const child_id = child.id;
+
+                    if (included_set.getAndSet(child_id)) {
                         continue;
                     }
 
-                    stack[stack_cursor++] = child.id;
+                    stack[stack_cursor++] = child_id;
                 }
 
                 continue;
@@ -122,6 +124,7 @@ export function get_geometry_patch_cut(
     if (!destination.ensureCapacity(output_patch_cursor)) {
         // redo the work
         get_geometry_patch_cut(destination, spec, geometry, instance_id, transform);
+
     } else {
 
         destination.patch_count = output_patch_cursor;

package/engine/graphics/particles/particular/engine/parameter/sample/RGBA_LUT_HEATMAP_IR.js

@@ -0,0 +1,11 @@
+import { ParameterLookupTable } from "../ParameterLookupTable.js";
+
+export const RGBA_LUT_HEATMAP_IR = new ParameterLookupTable(4);
+RGBA_LUT_HEATMAP_IR.write([
+    0, 0, 255, 10,
+    0, 179, 179, 10,
+    0, 255, 0, 10,
+    255, 255, 0, 10,
+    255, 5, 5, 10
+]);
+RGBA_LUT_HEATMAP_IR.computeUniformPositions();

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

@@ -81,6 +81,7 @@ import { pick } from "../../../../../../../ecs/grid/pick.js";
 import { clamp01 } from "../../../../../../../core/math/clamp01.js";
 import { randomFromArray } from "../../../../../../../core/math/random/randomFromArray.js";
 import { SamplingFunctionKind } from "./SamplingFunctionKind.js";
+import { RGBA_LUT_HEATMAP_IR } from "../../parameter/sample/RGBA_LUT_HEATMAP_IR.js";
 
 const engineHarness = new EngineHarness();
 
@@ -168,15 +169,7 @@ async function init(harness) {
 }
 
 
-const heatmap_lut_0 = new ParameterLookupTable(4);
-heatmap_lut_0.write([
-    0, 0, 255, 10,
-    0, 179, 179, 10,
-    0, 255, 0, 10,
-    255, 255, 0, 10,
-    255, 5, 5, 10
-]);
-heatmap_lut_0.computeUniformPositions();
+const heatmap_lut_0 = RGBA_LUT_HEATMAP_IR;
 
 const heatmap_lut_orange_to_red = new ParameterLookupTable(4);
 heatmap_lut_orange_to_red.write([

package/engine/graphics/sh3/README.md

@@ -2,3 +2,4 @@ Path tracing ideas:
 * https://raytracing.github.io/books/RayTracingInOneWeekend.html
 * [smallpt](https://www.kevinbeason.com/smallpt/) (100 line c implementation of path tracer)
 * [three path tracer](https://github.com/gkjohnson/three-gpu-pathtracer)
+* http://blog.hvidtfeldts.net/index.php/2015/01/path-tracing-3d-fractals/

package/engine/graphics/sh3/path_tracer/GeometryBVHBatched.js

@@ -0,0 +1,324 @@
+import {
+    ExplicitBinaryBoundingVolumeHierarchy
+} from "../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
+import { min2 } from "../../../../core/math/min2.js";
+import { compute_triangle_group_aabb3 } from "./compute_triangle_group_aabb3.js";
+import { bvh_query_leaves_ray } from "../../../../core/bvh2/bvh3/bvh_query_leaves_ray.js";
+import { aabb3_signed_distance_sqr_to_point } from "../../../../core/bvh2/aabb3/aabb3_signed_distance_sqr_to_point.js";
+import {
+    computeTriangleRayIntersectionBarycentric
+} from "../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const leaf_buffer = [];
+/**
+ *
+ * @type {number[]}
+ */
+const v3_scratch_0 = [];
+const BVH_BATCH_SIZE = 1;
+
+const temp_aabb3 = new Float32Array(6);
+
+export class GeometryBVHBatched {
+    constructor() {
+        /**
+         *
+         * @type {ExplicitBinaryBoundingVolumeHierarchy}
+         * @private
+         */
+        this.__bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+        /**
+         *
+         * @type {THREE.BufferGeometry|null}
+         * @private
+         */
+        this.__geometry = null;
+
+        /**
+         *
+         * @type {number[]|null}
+         * @private
+         */
+        this.__geometry_index = null;
+
+        /**
+         *
+         * @type {number[]|null}
+         * @private
+         */
+        this.__geometry_positions = null;
+
+
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__triangle_count = 0;
+    }
+
+    /**
+     *
+     * @param {THREE.BufferGeometry} geometry
+     */
+    build(geometry) {
+        this.__geometry = geometry;
+
+        const bvh = this.__bvh;
+
+        bvh.release_all();
+
+        const index = geometry.getIndex();
+        const index_array = index.array;
+
+
+        const attribute_position = geometry.getAttribute('position');
+        const array_positions = attribute_position.array;
+
+        this.__geometry_positions = array_positions;
+        this.__geometry_index = index_array;
+
+        const triangle_count = index_array.length / 3;
+
+        this.__triangle_count = triangle_count;
+
+        const leaf_node_count = Math.ceil(triangle_count / BVH_BATCH_SIZE);
+
+        const leaf_aabb = [];
+
+        for (let i = 0; i < leaf_node_count; i++) {
+
+            const index_start = i * BVH_BATCH_SIZE;
+            const index_end = min2(triangle_count, index_start + BVH_BATCH_SIZE);
+
+            const group_size = index_end - index_start;
+
+            compute_triangle_group_aabb3(leaf_aabb, 0, index_array, array_positions, index_start * 3, group_size, 3);
+
+            const node_index = bvh.allocate_node();
+            bvh.node_set_aabb(node_index, leaf_aabb);
+            bvh.node_set_user_data(node_index, i);
+
+            bvh.insert_leaf(node_index);
+        }
+
+        bvh.trim();
+        bvh.sort_for_traversal_depth_first();
+    }
+
+    /**
+     *
+     * @param {number[]} output
+     * @param {number} face_index
+     * @param {number} t
+     * @param {number} u
+     * @param {number} v
+     */
+    construct_output(output, face_index, t, u, v) {
+        const indices = this.__geometry_index;
+        const positions = this.__geometry_positions;
+
+        const index_offset = face_index * 3;
+
+        const a = indices[index_offset];
+        const b = indices[index_offset + 1];
+        const c = indices[index_offset + 2];
+
+
+        const a_address = a * 3;
+        const b_address = b * 3;
+        const c_address = c * 3;
+
+        const ax = positions[a_address];
+        const ay = positions[a_address + 1];
+        const az = positions[a_address + 2];
+
+        const bx = positions[b_address];
+        const by = positions[b_address + 1];
+        const bz = positions[b_address + 2];
+
+        const cx = positions[c_address];
+        const cy = positions[c_address + 1];
+        const cz = positions[c_address + 2];
+
+        // read out interpolated buffer values
+        // const w = 1 - u - v;
+
+        // output[0] = ax * u + bx * v + cx * w;
+        // output[1] = ay * u + by * v + cy * w;
+        // output[2] = az * u + bz * v + cz * w;
+
+        // normal
+        // v3_compute_triangle_normal(output, 3, ax, ay, ax, bx, by, bz, cx, cy, cz);
+
+        // edge1 = a - b
+        const edge1_x = bx - ax;
+        const edge1_y = by - ay;
+        const edge1_z = bz - az;
+
+        // edge2 = c - a
+        const edge2_x = cx - ax;
+        const edge2_y = cy - ay;
+        const edge2_z = cz - az;
+
+        // Compute triangle normal
+
+        // normal = edge1 x edge2
+        const normal_x = edge1_y * edge2_z - edge1_z * edge2_y;
+        const normal_y = edge1_z * edge2_x - edge1_x * edge2_z;
+        const normal_z = edge1_x * edge2_y - edge1_y * edge2_x
+
+
+        output[3] = normal_x;
+        output[4] = normal_y;
+        output[5] = normal_z;
+
+        output[6] = t;
+        output[7] = u;
+        output[8] = v;
+        output[9] = face_index;
+    }
+
+    /**
+     *
+     * @param {number[]} output
+     * @param {number[]} ray
+     * @param {number} min_distance
+     * @param {number} max_distance
+     * @returns {number} distance along the ray, negative if no hit
+     */
+    raycast(output, ray, min_distance, max_distance) {
+
+        const indices = this.__geometry_index;
+        const positions = this.__geometry_positions;
+
+        const origin_x = ray[0];
+        const origin_y = ray[1];
+        const origin_z = ray[2];
+
+        const direction_x = ray[3];
+        const direction_y = ray[4];
+        const direction_z = ray[5];
+
+        const bvh = this.__bvh;
+
+        const count = bvh_query_leaves_ray(
+            bvh, leaf_buffer, 0,
+            origin_x, origin_y, origin_z,
+            direction_x, direction_y, direction_z
+        );
+
+        let best_t = max_distance;
+
+        let best_index = -1;
+        let best_u = 0;
+        let best_v = 0;
+
+        for (let i = 0; i < count; i++) {
+            const leaf_node_id = leaf_buffer[i];
+
+            const triangle_batch_index = bvh.node_get_user_data(leaf_node_id);
+
+            const index_start = triangle_batch_index * BVH_BATCH_SIZE;
+
+            const index_end = min2(index_start + BVH_BATCH_SIZE, this.__triangle_count);
+
+            if (best_t < max_distance) {
+                // early bail-out
+
+                bvh.node_get_aabb(leaf_node_id, temp_aabb3);
+
+                const distance = aabb3_signed_distance_sqr_to_point(temp_aabb3[0], temp_aabb3[1], temp_aabb3[2], temp_aabb3[3], temp_aabb3[4], temp_aabb3[5], ray[0], ray[1], ray[2]);
+
+                if (distance > best_t * best_t) {
+                    // whole AABB is too far
+                    continue;
+                }
+            }
+
+            for (let j = index_start; j < index_end; j++) {
+                const index_offset = j * 3;
+
+                const a = indices[index_offset];
+                const b = indices[index_offset + 1];
+                const c = indices[index_offset + 2];
+
+
+                const a_address = a * 3;
+                const b_address = b * 3;
+                const c_address = c * 3;
+
+
+                const ax = positions[a_address];
+                const ay = positions[a_address + 1];
+                const az = positions[a_address + 2];
+
+                const bx = positions[b_address];
+                const by = positions[b_address + 1];
+                const bz = positions[b_address + 2];
+
+                const cx = positions[c_address];
+                const cy = positions[c_address + 1];
+                const cz = positions[c_address + 2];
+
+                // const sp3 = new SurfacePoint3();
+                //
+                // const intersection_found = computeTriangleRayIntersection(
+                //     sp3,
+                //     origin_x, origin_y, origin_z,
+                //     direction_x, direction_y, direction_z,
+                //     ax, ay, az,
+                //     bx, by, bz,
+                //     cx, cy, cz);
+                //
+                // v3_scratch_0[0] = sp3.position.distanceTo(new Vector3(origin_x, origin_y, origin_z));
+
+                const intersection_found = computeTriangleRayIntersectionBarycentric(
+                    v3_scratch_0,
+                    origin_x, origin_y, origin_z,
+                    direction_x, direction_y, direction_z,
+                    ax, ay, az,
+                    bx, by, bz,
+                    cx, cy, cz
+                );
+
+                if (intersection_found && v3_scratch_0[0] < best_t && v3_scratch_0[0] > min_distance) {
+                    best_t = v3_scratch_0[0];
+
+                    best_index = j;
+                    best_u = v3_scratch_0[1];
+                    best_v = v3_scratch_0[2];
+
+
+                    // output[0] = v3_scratch_0[0];
+                    // output[1] = v3_scratch_0[1];
+                    // output[2] = v3_scratch_0[2];
+                    //
+                    // output[3] = v3_scratch_0[3];
+                    // output[4] = v3_scratch_0[4];
+                    // output[5] = v3_scratch_0[5];
+
+                    // uv
+                    //TODO
+                }
+            }
+        }
+
+        if (best_t === max_distance) {
+            return -1;
+        }
+
+        output[0] = origin_x + direction_x * best_t;
+        output[1] = origin_y + direction_y * best_t;
+        output[2] = origin_z + direction_z * best_t;
+
+        this.construct_output(output, best_index, best_t, best_u, best_v);
+
+        return best_t;
+    }
+}

package/engine/graphics/sh3/path_tracer/PathTracedMesh.js

@@ -0,0 +1,85 @@
+import { array_copy } from "../../../../core/collection/array/copyArray.js";
+import { mat4 } from "gl-matrix";
+import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
+import { ray_hit_apply_transform } from "./ray_hit_apply_transform.js";
+
+const local_ray = new Float32Array(6);
+let mesh_id_counter = 0;
+
+export class PathTracedMesh {
+    constructor() {
+
+        /**
+         *
+         * @type {GeometryBVHBatched|null}
+         */
+        this.geo_bvh = null;
+
+        /**
+         *
+         * @type {THREE.BufferGeometry|null}
+         */
+        this.geometry = null;
+
+        /**
+         *
+         * @type {THREE.Material|null}
+         */
+        this.material = null;
+
+        const buffer = new ArrayBuffer(16 * 2 * 4);
+
+        this.__transform_inverse = new Float32Array(buffer, 0, 16);
+        this.__transform = new Float32Array(buffer, 16 * 4, 16);
+        this.__local_scale_inverse = 1;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.id = mesh_id_counter++;
+    }
+
+    set transform(m) {
+        array_copy(m, 0, this.__transform, 0, 16);
+        mat4.invert(this.__transform_inverse, m);
+
+        // precompute scaling factor for rays
+        const m4 = this.__transform_inverse;
+
+        const scale_x = Math.hypot(m4[0], m4[1], m4[2]);
+        const scale_y = Math.hypot(m4[4], m4[5], m4[6]);
+        const scale_z = Math.hypot(m4[8], m4[9], m4[10]);
+
+        this.__local_scale_inverse = Math.hypot(scale_x, scale_y, scale_z);
+    }
+
+    /**
+     *
+     * @param {number[]} out
+     * @param {number[]} ray
+     * @param {number} min_distance
+     * @param {number} max_distance
+     * @returns {number} distance along the ray to contact
+     */
+    hit(out, ray, min_distance, max_distance) {
+        //transform ray
+        const m4 = this.__transform_inverse;
+        ray3_array_apply_matrix4(local_ray, ray, m4);
+
+        const scale_d = this.__local_scale_inverse;
+
+        let distance_to_hit = this.geo_bvh.raycast(out, local_ray, min_distance * scale_d, max_distance * scale_d);
+
+        if (distance_to_hit >= 0) {
+            // transform output
+            ray_hit_apply_transform(out, out, this.__transform);
+
+            out[10] = this.id;
+
+            distance_to_hit /= scale_d;
+        }
+
+        return distance_to_hit;
+    }
+}