@woosh/meep-engine 2.108.2 → 2.108.3

package/src/core/geom/3d/sphere/harmonics/sh_compute_K.js

@@ -0,0 +1,17 @@
+import { factorial } from "../../../../math/factorial.js";
+
+/**
+ * computes K(m,l) normalization constant
+ * @see "Deringing Spherical Harmonics" by Peter-Pike Sloan
+ * @param {number} m
+ * @param {number} l
+ * @returns {number}
+ */
+export function sh_compute_K(m, l) {
+
+    const a = (2 * l + 1) * factorial(l - Math.abs(m))
+
+    const b = 4 * Math.PI * factorial(l + Math.abs(m))
+
+    return Math.sqrt(a / b);
+}

package/src/core/geom/3d/tetrahedra/TetrahedralMesh.d.ts

@@ -209,11 +209,14 @@ export class TetrahedralMesh {
     removeTetrasConnectedToPoints(range_start: number, range_end: number): void;
     /**
      *
-     * @param {number[]} points
-     * @param {number} index
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number[]} points Positions of vertices of tetrahedrons
+     * @param {number} [hint_tetrahedron]
      * @returns {number} index of tetra or -1 if no containing tetra found
      */
-    findTetraContainingPoint(points: number[], index: number): number;
+    findTetraContainingPoint(x: number, y: number, z: number, points: number[], hint_tetrahedron?: number): number;
     /**
      * Relocate tetrahedron in memory, patches neighbourhood links as well
      * NOTE: The destination slot will be overwritten. This is a dangerous method that can break the topology, make sure you fully understand what you are doing when using it

package/src/core/geom/3d/tetrahedra/TetrahedralMesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TetrahedralMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/TetrahedralMesh.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,qCAFU,MAAM,CAEkD;AAElE;;;GAGG;AACH,gCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,4BAFU,MAAM,CAEwB;AAoBxC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACI;;;OAGG;IACH,2BAFW,MAAM,EAqDhB;IAhDG;;;;OAIG;IACH,iBAAsE;IAEtE;;;;OAIG;IACH,sBAAmD;IAEnD;;;;OAIG;IACH,eAAyC;IAEzC;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,mBAAmB;IAEnB;;;;OAIG;IACH,eAAgB;IAEhB;;;;OAIG;IACH,uBAAuB;IAG3B;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,2CAQC;IAED;;OAEG;IACH,cAWC;IAED;;;OAGG;IACH,sBAFW,MAAM,QA8BhB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,uBAFW,MAAM,QAchB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAShB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAiBlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,aACN,MAAM,QAchB;IAGD;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,UACN,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAUlB;IAGD;;;;OAIG;IACH,YAFY,MAAM,CA4BjB;IAED;;;;;;;;OAQG;IACH,eAPW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAmBhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,2CAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,EAAE,SACR,MAAM,GACJ,MAAM,CAsBlB;IAGD;;;;;OAKG;IACH,uBAHW,MAAM,qBACN,MAAM,QA6BhB;IAED;;;;OAIG;IACH,WAFa,MAAM,CA2ClB;IAED;;;OAGG;IACH,kBAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,oBAFW,YAAY,QAiBtB;IAED;;;OAGG;IACH,oBAFY,MAAM,CAUjB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAQhB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;6BArrB4B,iCAAiC"}
+{"version":3,"file":"TetrahedralMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/TetrahedralMesh.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,qCAFU,MAAM,CAEkD;AAElE;;;GAGG;AACH,gCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,4BAFU,MAAM,CAEwB;AAoBxC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACI;;;OAGG;IACH,2BAFW,MAAM,EAqDhB;IAhDG;;;;OAIG;IACH,iBAAsE;IAEtE;;;;OAIG;IACH,sBAAmD;IAEnD;;;;OAIG;IACH,eAAyC;IAEzC;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,mBAAmB;IAEnB;;;;OAIG;IACH,eAAgB;IAEhB;;;;OAIG;IACH,uBAAuB;IAG3B;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,2CAQC;IAED;;OAEG;IACH,cAWC;IAED;;;OAGG;IACH,sBAFW,MAAM,QA8BhB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,uBAFW,MAAM,QAchB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAShB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAiBlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,aACN,MAAM,QAchB;IAGD;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,UACN,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAUlB;IAGD;;;;OAIG;IACH,YAFY,MAAM,CA4BjB;IAED;;;;;;;;OAQG;IACH,eAPW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAmBhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,2CAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;;;;OAQG;IACH,4BAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,qBACR,MAAM,GACJ,MAAM,CAyDlB;IAGD;;;;;OAKG;IACH,uBAHW,MAAM,qBACN,MAAM,QA6BhB;IAED;;;;OAIG;IACH,WAFa,MAAM,CA2ClB;IAED;;;OAGG;IACH,kBAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,oBAFW,YAAY,QAiBtB;IAED;;;OAGG;IACH,oBAFY,MAAM,CAUjB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAQhB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;6BA1tB4B,iCAAiC"}

package/src/core/geom/3d/tetrahedra/TetrahedralMesh.js

@@ -1,12 +1,12 @@
+import { orient3d } from "robust-predicates";
 import { assert } from "../../../assert.js";
 import { Base64 } from "../../../binary/Base64.js";
 import { BinaryBuffer } from "../../../binary/BinaryBuffer.js";
 import { array_copy } from "../../../collection/array/array_copy.js";
-import { array_quick_sort_by_comparator } from "../../../collection/array/arrayQuickSort.js";
+import { array_quick_sort_by_comparator } from "../../../collection/array/array_quick_sort_by_comparator.js";
 import { typed_array_copy } from "../../../collection/array/typed/typed_array_copy.js";
 import { max3 } from "../../../math/max3.js";
 import { number_compare_descending } from "../../../primitives/numbers/number_compare_descending.js";
-import { tetrahedron_contains_point } from "./tetrahedron_contains_point.js";
 
 /**
  * @readonly
@@ -523,30 +523,68 @@ export class TetrahedralMesh {
 
     /**
      *
-     * @param {number[]} points
-     * @param {number} index
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number[]} points Positions of vertices of tetrahedrons
+     * @param {number} [hint_tetrahedron]
      * @returns {number} index of tetra or -1 if no containing tetra found
      */
-    findTetraContainingPoint(points, index) {
-        const data_view = this.__view;
+    findTetraContainingPoint(x, y, z, points, hint_tetrahedron = 0) {
 
-        // TODO improve this
-        const n = this.__used_end;
-        for (let i = 0; i < n; i++) {
+        let entering_face = 4;
 
-            const tet_address = i * LAYOUT_TETRA_BYTE_SIZE;
+        let cur_tet = hint_tetrahedron;
 
-            const a = data_view.getUint32(tet_address);
-            const b = data_view.getUint32(tet_address + 4);
-            const c = data_view.getUint32(tet_address + 8);
-            const d = data_view.getUint32(tet_address + 12);
+        let i;
+        while (true) {
+            for (i = 0; i < 4; i++) {
 
-            if (tetrahedron_contains_point(points, a, b, c, d, index)) {
-                return i;
+                // we walk whenever the volume is positive
+                const a_i = (i + 1) & 3;
+                const b_i = (i & 2) ^ 3;
+                const c_i = (i + 3) & 2;
+
+                const a_index = this.getVertexIndex(cur_tet, a_i);
+                const b_index = this.getVertexIndex(cur_tet, b_i);
+                const c_index = this.getVertexIndex(cur_tet, c_i);
+
+                const a3 = a_index * 3;
+                const b3 = b_index * 3;
+                const c3 = c_index * 3;
+
+                const ax = points[a3];
+                const ay = points[a3 + 1];
+                const az = points[a3 + 2];
+
+                const bx = points[b3];
+                const by = points[b3 + 1];
+                const bz = points[b3 + 2];
+
+                const cx = points[c3];
+                const cy = points[c3 + 1];
+                const cz = points[c3 + 2];
+
+                if (i !== entering_face && orient3d(ax, ay, az, bx, by, bz, cx, cy, cz, x, y, z) < 0.0) {
+
+                    // point is outside the tet on the neighbour's side, move in that direction
+                    const neighbour = this.getNeighbour(cur_tet, i);
+
+                    assert.notEqual(neighbour, INVALID_NEIGHBOUR, 'walked outside of the mesh');
+
+                    cur_tet = neighbour >>> 2;
+                    entering_face = neighbour & 3;
+
+                    break;
+
+                }
             }
-        }
 
-        return -1;
+            if (i === 4) {
+                // point is inside the tet
+                return cur_tet;
+            }
+        }
     }
 
 

package/src/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_walk_towards_containing_tetrahedron.d.ts

@@ -7,7 +7,7 @@
  * @param {TetrahedralMesh} mesh
  * @param {number[]|Float32Array} points
  * @param {number} hint_tetrahedron we will start here and walk towards our target
- * @param {number} search_vertex_index
+ * @param {number} search_vertex_index resolved by indexing into {@link points} array
  * @returns {number}
  */
 export function tetrahedral_mesh_walk_towards_containing_tetrahedron(mesh: TetrahedralMesh, points: number[] | Float32Array, hint_tetrahedron: number, search_vertex_index: number): number;

package/src/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_walk_towards_containing_tetrahedron.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tetrahedral_mesh_walk_towards_containing_tetrahedron.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_walk_towards_containing_tetrahedron.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,oGALW,MAAM,EAAE,GAAC,YAAY,oBACrB,MAAM,uBACN,MAAM,GACJ,MAAM,CA2ClB"}
+{"version":3,"file":"tetrahedral_mesh_walk_towards_containing_tetrahedron.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_walk_towards_containing_tetrahedron.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,oGALW,MAAM,EAAE,GAAC,YAAY,oBACrB,MAAM,uBACN,MAAM,GACJ,MAAM,CAkDlB"}

package/src/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_walk_towards_containing_tetrahedron.js

@@ -1,6 +1,6 @@
 import { assert } from "../../../../assert.js";
-import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
 import { orient3d_robust } from "../../plane/orient3d_robust.js";
+import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
 
 /**
  * Walk from a given tetrahedron in the mesh towards tetrahedron that contains input point
@@ -11,18 +11,25 @@ import { orient3d_robust } from "../../plane/orient3d_robust.js";
  * @param {TetrahedralMesh} mesh
  * @param {number[]|Float32Array} points
  * @param {number} hint_tetrahedron we will start here and walk towards our target
- * @param {number} search_vertex_index
+ * @param {number} search_vertex_index resolved by indexing into {@link points} array
  * @returns {number}
  */
-export function tetrahedral_mesh_walk_towards_containing_tetrahedron(mesh, points, hint_tetrahedron, search_vertex_index) {
+export function tetrahedral_mesh_walk_towards_containing_tetrahedron(
+    mesh,
+    points,
+    hint_tetrahedron,
+    search_vertex_index
+) {
+
+    assert.isNonNegativeInteger(search_vertex_index, 'search_vertex_index');
 
     let entering_face = 4;
 
     let cur_tet = hint_tetrahedron;
 
+    let i;
     while (true) {
 
-        let i;
         for (i = 0; i < 4; i++) {
 
             // we walk whenever the volume is positive

package/src/core/geom/3d/tetrahedra/{GetDepthForTetrahedronProbe.glsl → triangle/GetDepthForTetrahedronProbe.glsl}

@@ -1,40 +1,47 @@
 // Sample triangular depth map
 // see CoD SIGGRAPH 2017 "Advances in Real-Time Graphics in Games" course
-float GetDepthForTetrahedronProbe(float2 bary, uint4 encodedDepth)
+// depth is encoded as 4 * uint32
+float GetDepthForTetrahedronProbe(vec2 bary, uvec4 encodedDepth)
 {
     float sampleY = floor(bary.y * 4.0f);
     float sampleX = floor(bary.x * 4.0f);
 
-    int baseIndex = (int)(((11.0f - sampleY) * sampleY) * 0.5f + sampleX + 0.5f);
-    int lineLength = 5 - (int)sampleY;
+    int baseIndex = int((((11.0f - sampleY) * sampleY) * 0.5f + sampleX + 0.5f));
+    int lineLength = 5 - int(sampleY);
 
-    float2 baseBary = float2(sampleX * 0.25f, sampleY * 0.25f);
+    vec2 baseBary = vec2(sampleX * 0.25f, sampleY * 0.25f);
 
-    int3 indices = int3(baseIndex + 1, baseIndex + lineLength, baseIndex);
+    ivec3 indices = ivec3(baseIndex + 1, baseIndex + lineLength, baseIndex);
 
-    float3 sampleBary;
+    // figure out barycentric coordinates within the triangular sample, this will be needed for bilinear interpolation
+    vec3 sampleBary;
     sampleBary.x = (bary.x - baseBary.x) * 4.0f;
     sampleBary.y = (bary.y - baseBary.y) * 4.0f;
 
     if (sampleBary.x + sampleBary.y > 1.0f)
     {
         // above the diagonal
-        indices = int3(baseIndex + lineLength, baseIndex + 1, baseIndex + lineLength + 1);
+        indices = ivec3(baseIndex + lineLength, baseIndex + 1, baseIndex + lineLength + 1);
+
+        vec3 newSampleBary;
 
-        float3 newSampleBary;
         newSampleBary.x = -(sampleBary.y - 1.0f);
         newSampleBary.y = -(sampleBary.x - 1.0f);
+
         sampleBary = newSampleBary;
     }
 
     sampleBary.z = 1.0f - sampleBary.x - sampleBary.y;
 
+    // perform bilinear interpolation of depth
     float result = 0.0f;
-    for (int i=0; i<3; ++i)
+    for (int i = 0; i < 3; ++i)
     {
         uint currIndex = indices[i];
+
         int intDepth = (encodedDepth[currIndex / 4] >> ((currIndex % 4) * 8)) & 0xFF;
-        float depth = (float)intDepth / 255.0f;
+
+        float depth = float(intDepth / 255.0f);
 
         result += sampleBary[i] * depth;
     }

package/src/core/geom/3d/tetrahedra/triangle/prototype.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prototype.d.ts.map

package/src/core/geom/3d/tetrahedra/triangle/prototype.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prototype.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/tetrahedra/triangle/prototype.js"],"names":[],"mappings":""}

package/src/core/geom/3d/tetrahedra/triangle/prototype.js

@@ -0,0 +1,128 @@
+import { BoxBufferGeometry, MeshStandardMaterial } from "three";
+import { Transform } from "../../../../../engine/ecs/transform/Transform.js";
+import { PathTracedScene } from "../../../../../engine/graphics/sh3/path_tracer/PathTracedScene.js";
+import { Sampler2D } from "../../../../../engine/graphics/texture/sampler/Sampler2D.js";
+import sampler2D2Canvas from "../../../../../engine/graphics/texture/sampler/Sampler2D2Canvas.js";
+import { CanvasView } from "../../../../../view/elements/CanvasView.js";
+import { Color } from "../../../../color/Color.js";
+import { halton_sequence } from "../../../../math/statistics/halton_sequence.js";
+import { triangle2d_get_barycentric } from "../../../2d/triangle2d_get_barycentric.js";
+import { trace_triangular_depth_map } from "./trace_triangular_depth_map.js";
+import { triangle_decode_depth, triangle_encode_rasterized_depth } from "./triangle_encode_rasterized_depth.js";
+
+const RESOLUTION = 512;
+
+const v = new CanvasView();
+
+v.size.set(RESOLUTION, RESOLUTION);
+
+const ctx = v.context2d;
+
+const points = [
+    0, 0,
+    0, RESOLUTION,
+    RESOLUTION, RESOLUTION
+];
+
+function getDeterminant(
+    ax, ay,
+    bx, by,
+    cx, cy
+) {
+
+    const edge1_x = bx - ax;
+    const edge1_y = by - ay;
+
+    const edge2_x = cx - ax;
+    const edge2_y = cy - ay;
+
+    return edge1_y * edge2_x - edge1_x * edge2_y;
+}
+
+const sampler = Sampler2D.float32(3, RESOLUTION, RESOLUTION);
+
+const color = new Color();
+
+const barycentric = [];
+
+async function main() {
+
+    const scene = new PathTracedScene();
+
+
+    const transform = new Transform();
+
+    transform.scale.setScalar(1.5);
+
+    scene.addMesh(
+        new BoxBufferGeometry(),
+        new MeshStandardMaterial(),
+        transform.matrix
+    );
+
+    await scene.build();
+
+    const depth_map = new Uint32Array(4);
+
+    trace_triangular_depth_map(depth_map, 0,
+        [
+            0, 0, -2,
+            -1, -1, 0,
+            -1, 1, 0,
+            1, 1, 0,
+        ],
+        0, 1, 2, 3,
+        scene
+    );
+
+    for (let y = 0; y < sampler.height; y++) {
+        for (let x = 0; x < sampler.width; x++) {
+            const ax = points[0];
+            const ay = points[1];
+
+            const bx = points[2];
+            const by = points[3];
+
+            const cx = points[3];
+            const cy = points[4];
+
+            triangle2d_get_barycentric(
+                barycentric, 0,
+                ax, ay,
+                bx, by,
+                cx, cy,
+                x, y
+            );
+
+            const w0 = barycentric[0];
+            const w1 = barycentric[1];
+            const w2 = barycentric[2];
+
+            if (w0 < 0 || w1 < 0 || w2 < 0) {
+                // outside the triangle
+                continue;
+            }
+
+            const index = triangle_encode_rasterized_depth(w0, w1);
+
+            color.setHSL(
+                halton_sequence(15, index), 0.6 + halton_sequence(15, (index * 5 + 31) % 15) * 0.3, 0.5
+            );
+
+            const depth = 1 - triangle_decode_depth(depth_map, 0, w0, w1);
+
+            color.set(depth, depth, depth, 1);
+
+            sampler.set(x, y, color)
+        }
+    }
+
+    sampler2D2Canvas(sampler, 255, 0, v.el);
+
+}
+
+
+main();
+v.link();
+
+document.body.appendChild(v.el);

package/src/core/geom/3d/tetrahedra/triangle/trace_triangular_depth_map.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ * @param {Uint32Array} result
+ * @param {number} result_offset
+ * @param {number[]|Float32Array} points
+ * @param {number} source
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {PathTracedScene} scene
+ */
+export function trace_triangular_depth_map(result: Uint32Array, result_offset: number, points: number[] | Float32Array, source: number, a: number, b: number, c: number, scene: PathTracedScene): void;
+//# sourceMappingURL=trace_triangular_depth_map.d.ts.map

package/src/core/geom/3d/tetrahedra/triangle/trace_triangular_depth_map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace_triangular_depth_map.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/tetrahedra/triangle/trace_triangular_depth_map.js"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,mDATW,WAAW,iBACX,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,UACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,gCAyGhB"}

package/src/core/geom/3d/tetrahedra/triangle/trace_triangular_depth_map.js

@@ -0,0 +1,120 @@
+import { v3_length } from "../../../vec3/v3_length.js";
+import { ray3_array_compose } from "../../ray/ray3_array_compose.js";
+
+const scratch = [];
+const ray = [];
+
+/**
+ *
+ * @param {Uint32Array} result
+ * @param {number} result_offset
+ * @param {number[]|Float32Array} points
+ * @param {number} source
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {PathTracedScene} scene
+ */
+export function trace_triangular_depth_map(
+    result, result_offset,
+    points, source, a, b, c,
+    scene
+) {
+
+    const a3 = a * 3;
+
+    const a_x = points[a3];
+    const a_y = points[a3 + 1];
+    const a_z = points[a3 + 2];
+
+    const b3 = b * 3;
+
+    const b_x = points[b3];
+    const b_y = points[b3 + 1];
+    const b_z = points[b3 + 2];
+
+    const c3 = c * 3;
+
+    const c_x = points[c3];
+    const c_y = points[c3 + 1];
+    const c_z = points[c3 + 2];
+
+    const origin3 = source * 3;
+
+    const origin_x = points[origin3];
+    const origin_y = points[origin3 + 1];
+    const origin_z = points[origin3 + 2];
+
+    const edge0_x = b_x - a_x;
+    const edge0_y = b_y - a_y;
+    const edge0_z = b_z - a_z;
+
+    const edge1_x = c_x - a_x;
+    const edge1_y = c_y - a_y;
+    const edge1_z = c_z - a_z;
+
+    for (let i = 0; i < 4; i++) {
+        // clear
+        result[result_offset + i] = 0;
+    }
+
+
+    // generate samples on discrete mapping points
+    for (let sample_y = 4; sample_y >= 0; sample_y--) {
+
+        for (let sample_x = 0; sample_x <= (4 - sample_y); sample_x++) {
+
+            const barycentric_x = sample_x / 4;
+            const barycentric_y = sample_y / 4;
+
+
+            const target_x = a_x + barycentric_x * edge0_x + barycentric_y * edge1_x;
+            const target_y = a_y + barycentric_x * edge0_y + barycentric_y * edge1_y;
+            const target_z = a_z + barycentric_x * edge0_z + barycentric_y * edge1_z;
+
+
+            // convert target to direction
+            const relative_x = target_x - origin_x;
+            const relative_y = target_y - origin_y;
+            const relative_z = target_z - origin_z;
+
+            const distance_to_target = v3_length(relative_x, relative_y, relative_z);
+
+            const norm = 1 / distance_to_target;
+
+            const ray_direction_x = relative_x * norm;
+            const ray_direction_y = relative_y * norm;
+            const ray_direction_z = relative_z * norm;
+
+            ray3_array_compose(
+                ray,
+                origin_x, origin_y, origin_z,
+                ray_direction_x, ray_direction_y, ray_direction_z
+            );
+
+            const distance = scene.trace(scratch, ray, 0, distance_to_target);
+
+            let depth;
+            if (distance < 0) {
+                // nothing was hit
+                depth = distance_to_target;
+            } else {
+                depth = distance;
+            }
+
+            const index = ((((11 - sample_y) * sample_y)) * 0.5 + sample_x + 0.5) >>> 0;
+
+            const encoded_index_0 = index >>> 2;
+            const encoded_index_1 = index & 3;
+
+            const depth_normalized = depth / distance_to_target;
+
+            // depth is quantized to closer value to be conservative
+            const depth_quantized = Math.floor(depth_normalized / 255);
+
+            result[result_offset + encoded_index_0] |= depth_quantized << (encoded_index_1 * 8);
+        }
+
+    }
+
+}

package/src/core/geom/3d/tetrahedra/triangle/triangle_encode_rasterized_depth.d.ts

@@ -0,0 +1,3 @@
+export function triangle_encode_rasterized_depth(barycentric_x: any, barycentric_y: any): number;
+export function triangle_decode_depth(encodedDepth: any, input_offset: any, barycentric_x: any, barycentric_y: any): number;
+//# sourceMappingURL=triangle_encode_rasterized_depth.d.ts.map

package/src/core/geom/3d/tetrahedra/triangle/triangle_encode_rasterized_depth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triangle_encode_rasterized_depth.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/tetrahedra/triangle/triangle_encode_rasterized_depth.js"],"names":[],"mappings":"AAEA,iGA6CC;AAkBD,4HAwCC"}

package/src/core/geom/3d/tetrahedra/triangle/triangle_encode_rasterized_depth.js

@@ -0,0 +1,106 @@
+import { uint8_to_float } from "../../../../binary/uint8_to_float.js";
+
+export function triangle_encode_rasterized_depth(barycentric_x, barycentric_y) {
+    const sampleY = (barycentric_y * 4.0) >>> 0;
+    const sampleX = (barycentric_x * 4.0) >>> 0;
+
+    const baseIndex = ((((11.0 - sampleY) * sampleY) * 0.5 + sampleX + 0.5)) >>> 0;
+    const lineLength = 5 - sampleY;
+
+    const baseBary_x = sampleX * 0.25;
+    const baseBary_y = sampleY * 0.25;
+
+    let indices_0 = baseIndex + 1;
+    let indices_1 = baseIndex + lineLength;
+    let indices_2 = baseIndex;
+
+    // figure out barycentric coordinates within the triangular sample, this will be needed for bilinear interpolation
+
+    let sampleBary_x = (barycentric_x - baseBary_x) * 4.0;
+    let sampleBary_y = (barycentric_y - baseBary_y) * 4.0;
+
+    const above = sampleBary_x + sampleBary_y > 1.0;
+
+    if (above) {
+        // above the diagonal
+        indices_0 = baseIndex + lineLength;
+        indices_1 = baseIndex + 1;
+        indices_2 = baseIndex + lineLength + 1;
+
+        const newSampleBary_x = -(sampleBary_y - 1.0);
+        const newSampleBary_y = -(sampleBary_x - 1.0);
+
+        sampleBary_x = newSampleBary_x;
+        sampleBary_y = newSampleBary_y;
+    }
+
+    const sampleBary_z = 1.0 - sampleBary_x - sampleBary_y;
+
+    return indices_0;
+
+    if (sampleBary_x > sampleBary_y && sampleBary_x > sampleBary_z) {
+        return above ? indices_1 : indices_0;
+    } else if (sampleBary_y > sampleBary_z && sampleBary_y > sampleBary_x) {
+        return above ? indices_0 : indices_1;
+    } else {
+        return indices_2;
+    }
+}
+
+/**
+ *
+ * @param {Uint32Array} encodedDepth
+ * @param {number} input_offset
+ * @param {number} index
+ * @return {number}
+ */
+function decode_index(encodedDepth, input_offset, index) {
+    const encoded_index_0 = index >>> 2;
+    const encoded_index_1 = index & 3;
+
+    const uint8 = (encodedDepth[input_offset + encoded_index_0] >> ((encoded_index_1) * 8)) & 0xFF;
+
+    return uint8_to_float(uint8);
+}
+
+export function triangle_decode_depth(encodedDepth, input_offset, barycentric_x, barycentric_y) {
+    const sampleY = (barycentric_y * 4.0) >>> 0;
+    const sampleX = (barycentric_x * 4.0) >>> 0;
+
+    const baseIndex = ((((11.0 - sampleY) * sampleY) * 0.5 + sampleX + 0.5)) >>> 0;
+    const lineLength = 5 - sampleY;
+
+    const baseBary_x = sampleX * 0.25;
+    const baseBary_y = sampleY * 0.25;
+
+    let indices_0 = baseIndex + 1;
+    let indices_1 = baseIndex + lineLength;
+    let indices_2 = baseIndex;
+
+    // figure out barycentric coordinates within the triangular sample, this will be needed for bilinear interpolation
+
+    let sampleBary_x = (barycentric_x - baseBary_x) * 4.0;
+    let sampleBary_y = (barycentric_y - baseBary_y) * 4.0;
+
+    const above = sampleBary_x + sampleBary_y > 1.0;
+
+    if (above) {
+        // above the diagonal
+        // indices_0 = baseIndex + lineLength;
+        // indices_1 = baseIndex + 1;
+        indices_2 = baseIndex + lineLength + 1;
+
+        const newSampleBary_x = -(sampleBary_y - 1.0);
+        const newSampleBary_y = -(sampleBary_x - 1.0);
+
+        sampleBary_x = newSampleBary_x;
+        sampleBary_y = newSampleBary_y;
+    }
+
+    const sampleBary_z = 1.0 - sampleBary_x - sampleBary_y;
+
+    // perform bilinear interpolation of depth
+    return sampleBary_x * decode_index(encodedDepth, input_offset, indices_0)
+        + sampleBary_y * decode_index(encodedDepth, input_offset, indices_1)
+        + sampleBary_z * decode_index(encodedDepth, input_offset, indices_2);
+}

package/src/core/math/factorial.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Compute factorial of X
+ * @param {number} x
+ * @return {number}
+ */
+export function factorial(x: number): number;
+//# sourceMappingURL=factorial.d.ts.map

package/src/core/math/factorial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factorial.d.ts","sourceRoot":"","sources":["../../../../src/core/math/factorial.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,6BAHW,MAAM,GACL,MAAM,CAWjB"}