@woosh/meep-engine 2.43.17 → 2.43.19

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

@@ -0,0 +1,42 @@
+import { v3_length } from "../../../../core/geom/v3_length.js";
+
+/**
+ *
+ * @param {number[]} output
+ * @param {number[]} hit
+ * @param {number[]} m 4x4 matrix
+ */
+export function ray_hit_apply_transform(output, hit, m) {
+
+    // transform position
+    const p_x = hit[0];
+    const p_y = hit[1];
+    const p_z = hit[2];
+
+    // compute perspective projection
+    const w = 1 / (m[3] * p_x + m[7] * p_y + m[11] * p_z + m[15]);
+
+    const result_p_x = (m[0] * p_x + m[4] * p_y + m[8] * p_z + m[12]) * w;
+    const result_p_y = (m[1] * p_x + m[5] * p_y + m[9] * p_z + m[13]) * w;
+    const result_p_z = (m[2] * p_x + m[6] * p_y + m[10] * p_z + m[14]) * w;
+
+    output[0] = result_p_x;
+    output[1] = result_p_y;
+    output[2] = result_p_z;
+
+    // transform normal
+    const n_x = hit[3];
+    const n_y = hit[4];
+    const n_z = hit[5];
+
+    const result_n_x = m[0] * n_x + m[4] * n_y + m[8] * n_z;
+    const result_n_y = m[1] * n_x + m[5] * n_y + m[9] * n_z;
+    const result_n_z = m[2] * n_x + m[6] * n_y + m[10] * n_z;
+
+    const normal_multiplier = 1 / v3_length(result_n_x, result_n_y, result_n_z);
+
+    output[3] = result_n_x * normal_multiplier;
+    output[4] = result_n_y * normal_multiplier;
+    output[5] = result_n_z * normal_multiplier;
+
+}

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

@@ -0,0 +1,27 @@
+import { v3_dot } from "../../../../core/geom/v3_dot.js";
+
+/**
+ *
+ * @param {number[]} out
+ * @param {number} output_offset
+ * @param {number[]} v
+ * @param {number} input_offset
+ * @param {number[]} n
+ * @param {number} normal_offset
+ */
+function ray_reflect(out, output_offset, v, input_offset, n, normal_offset) {
+    const input_x = v[0 + input_offset];
+    const input_y = v[1 + input_offset];
+    const input_z = v[2 + input_offset];
+
+    const nx = n[normal_offset + 0];
+    const ny = n[normal_offset + 1];
+    const nz = n[normal_offset + 2];
+
+    const dot = v3_dot(input_x, input_y, input_z, nx, ny, nz);
+
+    out[output_offset + 0] = input_x - 2 * dot * nx;
+    out[output_offset + 1] = input_y - 2 * dot * ny;
+    out[output_offset + 2] = input_z - 2 * dot * nz;
+
+}

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

@@ -0,0 +1,35 @@
+/**
+ *
+ * @param {number[]} out
+ * @param {number} out_offset
+ * @param {number} a vertex index 0
+ * @param {number} b vertex index 0
+ * @param {number} c vertex index 0
+ * @param {number[]} attribute_array
+ * @param {number} dimensions
+ * @param {number} u
+ * @param {number} v
+ */
+export function sample_triangle_attribute(
+    out, out_offset,
+    a, b, c,
+    attribute_array, dimensions,
+    u, v
+) {
+
+    const a_address = a * dimensions;
+    const b_address = b * dimensions;
+    const c_address = c * dimensions;
+
+    for (let i = 0; i < dimensions; i++) {
+
+        // construct edges
+        const a_v = attribute_array[a_address + i];
+
+        const edge1_v = attribute_array[b_address + i] - a_v;
+        const edge2_v = attribute_array[c_address + i] - a_v;
+
+        // sample edge
+        out[out_offset + i] = edge1_v * u + edge2_v * v + a_v;
+    }
+}

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

@@ -0,0 +1,12 @@
+import { uint82float } from "../../../../core/binary/uint82float.js";
+
+/**
+ *
+ * @param {number[]} out
+ * @param {number[]} input
+ */
+export function vec3_uint8_to_float(out, input) {
+    out[0] = uint82float(input[0]);
+    out[1] = uint82float(input[1]);
+    out[2] = uint82float(input[2]);
+}

package/engine/graphics/sh3/sky/hosek/README.md

@@ -0,0 +1,4 @@
+based on The Hosek Clear Sky model. (From "An Analytic Model for Full Spectral Sky-Dome Radiance", Hosek & Wilkie.)
+
+code is heavily influenced by this implementation:
+https://github.com/andrewwillmott/sun-sky

package/engine/graphics/sh3/sky/hosek/prototype_hosek.js

@@ -0,0 +1,71 @@
+import { Sampler2D } from "../../../texture/sampler/Sampler2D.js";
+import { CanvasView } from "../../../../../view/elements/CanvasView.js";
+import sampler2D2Canvas from "../../../texture/sampler/Sampler2D2Canvas.js";
+import { vec3 } from "gl-matrix";
+import { make_sky_hosek } from "../../path_tracer/make_sky_hosek.js";
+
+const view = new CanvasView();
+
+view.css({
+    position: 'fixed',
+    left: '10px',
+    top: '10px',
+    zIndex: 5
+});
+view.size.set(400, 400);
+
+document.body.append(view.el);
+
+view.link();
+
+const sampler = Sampler2D.float32(4, 400, 400);
+
+
+const sky = make_sky_hosek(
+    [0, 0.8, 0.4],
+    1,
+    0,
+    [0,0,0]
+);
+const vl_halfPi = Math.PI / 2;
+const color = [1, 1, 1, 1];
+for (let i = 0; i < sampler.width; i++) {
+    const u = i / (sampler.width - 1);
+
+    const x = u * 2 - 1;
+
+    for (let j = 0; j < sampler.height; j++) {
+        const v = j / (sampler.height - 1);
+
+        const y = v * 2 - 1;
+        const y2 = y * y;
+        // fisheye projection
+
+        const x2 = x * x;
+        const h2 = x2 + y2;
+
+        const theta = vl_halfPi - vl_halfPi * Math.sqrt(h2);
+        const phi = Math.atan2(y, x);
+        const v_x = Math.cos(phi) * Math.cos(theta);
+        const v_y = Math.sin(phi) * Math.cos(theta);
+        const v_z = Math.sin(theta);
+
+        const direction = [v_x, v_z, v_y];
+
+        vec3.normalize(direction, direction);
+
+        sky(color, 0, direction, 0);
+
+        sampler.set(i, j, color);
+
+        // sampler.set(i, j, [f, f, f, 1]);
+
+    }
+    // sampler.set(i, sampler.height - 1, [f, f, f, 1]);
+}
+
+console.log(sampler);
+
+sampler2D2Canvas(sampler, 255, 0, view.el);
+
+