@woosh/meep-engine 2.43.20 → 2.43.21

package/engine/graphics/ecs/mesh-v2/aggregate/SGMeshHighlightSystem.js

@@ -16,12 +16,21 @@ export class SGMeshHighlightSystem extends System {
      * @param {number} entity
      * @private
      */
-    __apply_highlight( event, entity) {
+    __apply_highlight(event, entity) {
         const ecd = this.entityManager.dataset;
 
         const sg_mesh = ecd.getComponent(entity, SGMesh);
+
+        if (sg_mesh === undefined) {
+            return;
+        }
+
         const highlight = ecd.getComponent(entity, Highlight);
 
+        if (highlight === undefined) {
+            return;
+        }
+
         const node = sg_mesh.__node;
 
         node.traverse(t => {
@@ -35,7 +44,7 @@ export class SGMeshHighlightSystem extends System {
      * @param {number} entity
      * @private
      */
-    __remove_highlight( event, entity) {
+    __remove_highlight(event, entity) {
 
         const ecd = this.entityManager.dataset;
 
@@ -56,7 +65,7 @@ export class SGMeshHighlightSystem extends System {
      */
     link(highlight, mesh, entity) {
         if (mesh.__node !== null) {
-            this.__apply_highlight(undefined,  entity);
+            this.__apply_highlight(undefined, entity);
         }
 
         const ecd = this.entityManager.dataset;

package/engine/graphics/micron/format/MicronGeometryPatch.d.ts

@@ -1,3 +1,3 @@
 export class MicronGeometryPatch {
-
+    allocate_metadata(buffer: ArrayBuffer, offset: number): number
 }

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

@@ -35,7 +35,7 @@ export class MicronGeometryPatch {
         this.group_bounding_box = null;
 
         /**
-         *
+         * TODO get rid of this, use bounding box instead for smaller memory footprint
          * @type {number[]|Float32Array}
          */
         this.group_bounding_box_corners = null;
@@ -124,6 +124,7 @@ export class MicronGeometryPatch {
      * @returns {number}
      */
     allocate_metadata(buffer, offset) {
+        assert.isNonNegativeInteger(offset, 'offset');
         assert.greaterThanOrEqual(buffer.byteLength, offset + 144, 'buffer underflow');
 
         this.bounding_box = new Float32Array(buffer, offset, 6);

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

@@ -54,6 +54,10 @@ export class PathTracedMesh {
         this.__local_scale_inverse = Math.hypot(scale_x, scale_y, scale_z);
     }
 
+    get transform() {
+        return this.__transform;
+    }
+
     /**
      *
      * @param {number[]} out

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

@@ -23,14 +23,12 @@ import { linear_to_sRGB } from "../../../../core/color/linear_to_sRGB.js";
 import { random_in_hemisphere } from "./random_in_hemisphere.js";
 import { sample_triangle_attribute } from "./sample_triangle_attribute.js";
 import { vec3_uint8_to_float } from "./vec3_uint8_to_float.js";
-import { make_sky_rtiw } from "./make_sky_rtiw.js";
 import { apply_texture_clamping_to_coordinate } from "./apply_texture_clamping_to_coordinate.js";
 import { ebvh_sort_for_traversal_depth_first } from "../../../../core/bvh2/bvh3/ebvh_sort_for_traversal_depth_first.js";
-import { clamp01 } from "../../../../core/math/clamp01.js";
 import { v3_dot } from "../../../../core/geom/v3_dot.js";
-import { LightType } from "../../ecs/light/LightType.js";
-import { make_zero_vector3 } from "./make_zero_vector3.js";
 import { make_one_vector3 } from "./make_one_vector3.js";
+import { transform_normal_m4 } from "./ray_hit_apply_transform.js";
+import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
 
 /*
  Ray hit data layout:
@@ -49,13 +47,22 @@ const texture_uv = [0, 0];
 const color = [];
 
 const irradiance = [0, 0, 0];
+
+/**
+ *
+ * @type {number[]|vec3}
+ */
+const throughputColor = [1, 1, 1];
 const trace_result = [];
 
-const _ray = [];
+const _ray_0 = [];
+const _ray_1 = [];
 
 const tmp_0 = [];
 const tmp_1 = [];
 
+const null_output = [];
+
 
 export class PathTracer {
     constructor() {
@@ -320,6 +327,9 @@ export class PathTracer {
             const normal_array = normal_attribute.array;
 
             sample_triangle_attribute(out, 3, index_0, index_1, index_2, normal_array, 3, u, v);
+
+            // apply transform
+            transform_normal_m4(out, 3, out, 3, mesh.transform);
         } else {
             // copy hit normal
             array_copy(hit, 3, out, 3, 3);
@@ -417,16 +427,17 @@ export class PathTracer {
      *
      * @param {number[]} out
      * @param {number} out_offset
-     * @param {number[]} hit_info
-     * @param {number} hit_info_address
+     * @param {number[]} ray
+     * @param {number} ray_address
      */
-    sample_lights(out, out_offset, hit_info, hit_info_address) {
+    sample_lights(out, out_offset, ray, ray_address) {
         let lights_sampled = false;
 
         const lights = this.__lights;
         const light_count = lights.length;
 
         for (let i = 0; i < 3; i++) {
+            // initialize contribution to 0
             out[out_offset + i] = 0;
         }
 
@@ -436,25 +447,47 @@ export class PathTracer {
             if (light.isDirectionalLight === true) {
                 const dir = light.direction;
 
+                // see https://github.com/mrdoob/three.js/blob/f0a9e0cf90a2f1ba5017fcb7fd46f02748b920cf/src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl.js#L172
+
+                const ray_direction_x = ray[ray_address + 3];
+                const ray_direction_y = ray[ray_address + 4];
+                const ray_direction_z = ray[ray_address + 5];
+
+                const light_dir_inv_x = -dir.x;
+                const light_dir_inv_y = -dir.y;
+                const light_dir_inv_z = -dir.z;
+
+                const dotNL = v3_dot(ray_direction_x, ray_direction_y, ray_direction_z, light_dir_inv_x, light_dir_inv_y, light_dir_inv_z);
+
+                if (dotNL <= 0) {
+                    // no contribution, facing away from the light
+                    continue;
+                }
+
+                const ray_origin_x = ray[ray_address + 0];
+                const ray_origin_y = ray[ray_address + 1];
+                const ray_origin_z = ray[ray_address + 2];
+
+                ray3_array_compose(_ray_1,
+                    ray_origin_x, ray_origin_y, ray_origin_z,
+                    light_dir_inv_x, light_dir_inv_y, light_dir_inv_z
+                );
+
                 // check if there are any obstacles in the direction of the light
-                if (this.trace([], [
-                    hit_info[hit_info_address + 0],
-                    hit_info[hit_info_address + 1],
-                    hit_info[hit_info_address + 2],
-                    -dir.x, -dir.y, -dir.z
-                ], 0.0001, Infinity) > 0) {
+                if (this.trace(null_output, _ray_1, 0.0001, Infinity) > 0) {
                     // light is occluded
-                    break;
+                    continue;
                 }
 
-                // see https://github.com/mrdoob/three.js/blob/f0a9e0cf90a2f1ba5017fcb7fd46f02748b920cf/src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl.js#L172
 
-                const dotNL = clamp01(v3_dot(hit_info[hit_info_address + 3], hit_info[hit_info_address + 4], hit_info[hit_info_address + 5], -dir.x, -dir.y, -dir.z));
+                const intensity = dotNL * light.intensity.getValue();
 
                 for (let j = 0; j < 3; j++) {
                     // irradiance
-                    out[out_offset + j] += dotNL * light.color[j] * light.intensity.getValue();
+                    out[out_offset + j] += light.color[j] * intensity;
                 }
+
+                lights_sampled = true;
             }
         }
 
@@ -464,28 +497,30 @@ export class PathTracer {
     path_trace(out, ray, max_distance, max_bounce, random = Math.random) {
         //TODO add importance sampling, see https://raytracing.github.io/books/RayTracingTheRestOfYourLife.html#lightscattering/thescatteringpdf
 
-        array_copy(ray, 0, _ray, 0, 6);
+        array_copy(ray, 0, _ray_0, 0, 6);
 
-        irradiance[0] = 0;
-        irradiance[1] = 0;
-        irradiance[2] = 0;
+        irradiance[0] = 1;
+        irradiance[1] = 1;
+        irradiance[2] = 1;
 
         let got_emission = false;
 
         let i;
         for (i = 0; i < max_bounce; i++) {
 
-            const hit_distance = this.trace(trace_result, _ray, 0.0001, max_distance);
+            const hit_distance = this.trace(trace_result, _ray_0, 0.0001, max_distance);
+
 
             if (hit_distance < 0) {
                 // ray didn't hit anything
 
                 // sample "environment" and terminate path as there is nothing to reflect off of
 
-                this.sample_background(tmp_0, 0, _ray, 3);
+                this.sample_background(tmp_0, 0, _ray_0, 3);
 
                 vec3.multiply(irradiance, irradiance, tmp_0);
 
+
                 got_emission = true;
 
                 break;
@@ -498,28 +533,36 @@ export class PathTracer {
             this.sample_material(tmp_0, trace_result);
 
             // adjust normal on the hit
-            // array_copy(tmp_0, 3, trace_result, 3, 3);
+            array_copy(tmp_0, 3, trace_result, 3, 3);
 
-            // sample light
-            this.sample_lights(tmp_1, 0, trace_result, 0);
-            vec3.add(irradiance, irradiance, tmp_1);
 
             // reflect ray
-            array_copy(trace_result, 0, _ray, 0, 3);
+            array_copy(trace_result, 0, _ray_0, 0, 3);
 
             // getBiasedNormalSample(_ray, 3, tmp, 3, 1, random);
-            random_in_hemisphere(random, _ray, 3, tmp_0, 3);
+            random_in_hemisphere(random, _ray_0, 3, tmp_0, 3);
 
+            // accumulate
             vec3.multiply(irradiance, irradiance, tmp_0);
         }
 
-        if (got_emission === false) {
-            // no light source was hit, propagate shadow(darkness) along the ray
-            irradiance[0] = 0;
-            irradiance[1] = 0;
-            irradiance[2] = 0;
+
+        if (i > 0) {
+
+            // directly sample light at the end of the path
+            this.sample_lights(tmp_1, 0, trace_result, 0);
+
+            vec3.multiply(irradiance, irradiance, tmp_1);
         }
 
+        //
+        // if (got_emission === false) {
+        //     // no light source was hit, propagate shadow(darkness) along the ray
+        //     irradiance[0] = 0;
+        //     irradiance[1] = 0;
+        //     irradiance[2] = 0;
+        // }
+
         array_copy(irradiance, 0, out, 0, 3);
     }
 }
@@ -534,3 +577,13 @@ function compute_hit_reaction_standard_material(material, hit) {
 }
 
 
+/**
+ *
+ * @param {number[]|vec3} out
+ * @param {number} value
+ */
+function vec3_set_scalar(out, value) {
+    out[0] = value;
+    out[1] = value;
+    out[2] = value;
+}

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

@@ -21,7 +21,7 @@ import { Camera } from "../../ecs/camera/Camera.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { scaleSampler2D } from "../../texture/sampler/scaleSampler2D.js";
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
-import { mat4 } from "gl-matrix";
+import { mat4, vec3 } from "gl-matrix";
 import { v3_distance } from "../../../../core/geom/v3_distance.js";
 import ConcurrentExecutor from "../../../../core/process/executor/ConcurrentExecutor.js";
 import Task from "../../../../core/process/task/Task.js";
@@ -38,6 +38,7 @@ import { Color } from "../../../../core/color/Color.js";
 import { min2 } from "../../../../core/math/min2.js";
 import { makeGeometryIndexed } from "../../geometry/buffered/makeGeometryIndexed.js";
 import { DirectionalLight } from "../../render/forward_plus/model/DirectionalLight.js";
+import { kelvin_to_rgb } from "../../../../core/color/kelvin_to_rgb.js";
 
 document.body.style.margin = 0;
 document.body.style.overflow = "hidden";
@@ -103,6 +104,32 @@ const gltfLoader = new GLTFLoader();
 // );
 //
 
+function make_sun({
+                      temperature = 5000, // around clear-sky day
+                      color = '#FFFFFF',
+                      intensity = 1,
+                      direction = new Vector3(-0.5, -1, -0.05)
+                  } = {}) {
+
+    const temp_c = new Color();
+
+    kelvin_to_rgb(temp_c, 0, temperature);
+
+    const light = new DirectionalLight();
+
+    light.color.parse(color);
+    vec3.multiply(light.color, light.color, temp_c);
+
+    const n = vec3.length(light.color);
+    vec3.scale(light.color, light.color, 1 / n); // normalize color vector
+
+    light.intensity.set(intensity * n);
+    light.direction.copy(direction);
+    light.direction.normalize();
+
+
+    return light;
+}
 
 function prepare_scene_sphere_01(pt, camera) {
     camera.position.set(0, 0, -2.1);
@@ -132,7 +159,7 @@ function prepare_scene_sphere_01(pt, camera) {
     light.direction.set(-1, -1, 0);
     light.direction.normalize();
 
-    pt.addLight(light);
+    pt.addLight(make_sun());
 }
 
 function promise_ply(url) {
@@ -189,6 +216,8 @@ async function prepare_scene_gltf(pt, camera, url) {
 
     box3.getBoundingSphere(sphere);
 
+    pt.addLight(make_sun());
+
     camera.position.set(1, 1.3, 1)
         .normalize()
         .multiplyScalar(sphere.radius * 2.6);
@@ -226,6 +255,8 @@ async function prepare_scene_lucy(pt, camera) {
     }).matrix);
 
 
+    pt.addLight(make_sun());
+
     camera.position.set(0, 0, -2300);
     camera.lookAt(0, 0, 0);
 }
@@ -336,6 +367,8 @@ async function prepare_scene_rtiow(pt, camera) {
     }
 
 
+    pt.addLight(make_sun());
+
     camera.position.set(13, 2, 3);
     camera.lookAt(0, 0, 0);
 
@@ -376,7 +409,7 @@ function* render(target, pt, camera, progress = { current: 0, total: 0 }) {
     const pixel_scale_x = 1 / (width - 1);
     const pixel_scale_y = 1 / (height - 1);
 
-    const pixel_sample_count = 64;
+    const pixel_sample_count = 500;
 
     progress.total = width * height;
 
@@ -426,7 +459,7 @@ function* render(target, pt, camera, progress = { current: 0, total: 0 }) {
                             ray_direction.x, ray_direction.y, ray_direction.z
                         );
 
-                        pt.path_trace(out, ray, Infinity, 4, random);
+                        pt.path_trace(out, ray, Infinity, 16, random);
 
                         out2[0] += out[0];
                         out2[1] += out[1];
@@ -476,12 +509,12 @@ const camera = new PerspectiveCamera();
 async function start_renderer(camera) {
     camera.aspect = vCanvas.size.x / vCanvas.size.y;
 
-    // const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
-    const path = 'data/models/road_bike/road_bike.gltf'; //large CAD-type model
+    const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
+    // const path = 'data/models/road_bike/road_bike.gltf'; //large CAD-type model
 
     // await prepare_scene_lucy(pt, camera);
-    // await prepare_scene_rtiow(pt, camera);
-    await prepare_scene_sphere_01(pt, camera);
+    await prepare_scene_rtiow(pt, camera);
+    // await prepare_scene_sphere_01(pt, camera);
     // await prepare_scene_gltf(pt, camera, path);
 
     pt.build();

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

@@ -1,5 +1,32 @@
 import { v3_length } from "../../../../core/geom/v3_length.js";
 
+/**
+ *
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number[]} normal
+ * @param {number} normal_offset
+ * @param {number[]} m 4x4 matrix
+ */
+export function transform_normal_m4(output, output_offset, normal, normal_offset, m) {
+
+    const n_x = normal[normal_offset];
+    const n_y = normal[normal_offset + 1];
+    const n_z = normal[normal_offset + 2];
+
+    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 vec_length = v3_length(result_n_x, result_n_y, result_n_z);
+
+    const normal_multiplier = vec_length === 0 ? 0 : 1 / vec_length;
+
+    output[output_offset] = result_n_x * normal_multiplier;
+    output[output_offset + 1] = result_n_y * normal_multiplier;
+    output[output_offset + 2] = result_n_z * normal_multiplier;
+}
+
 /**
  *
  * @param {number[]} output
@@ -25,18 +52,6 @@ export function ray_hit_apply_transform(output, hit, m) {
     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;
+    transform_normal_m4(output, 3, hit, 3, m);
 
 }

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.43.20",
+  "version": "2.43.21",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",