@woosh/meep-engine 2.109.4 → 2.109.5

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

@@ -1,5 +1,6 @@
 import { vec3 } from "gl-matrix";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { Ray3 } from "../../../../core/geom/3d/Ray3.js";
 import { getBiasedNormalSample } from "./sampling/getBiasedNormalSample.js";
 
 /*
@@ -18,21 +19,25 @@ const irradiance = [0, 0, 0];
 
 const trace_result = [];
 
-const _ray_0 = [];
+const _ray_0 = new Ray3();
 
-const tmp_0 = [];
-const tmp_1 = [];
+const tmp_0 = new Float32Array(6);
 
+/**
+ * Normalized probability of terminating the ray
+ * @type {number}
+ */
 const RUSSIAN_ROULETTE_PROBABILITY = 0.5;
 
+const color_mask = new Float32Array(3);
+
 export class PathTracer {
 
 
     /**
      *
      * @param {number[]|Float32Array} out
-     * @param {number[]|Float32Array} ray
-     * @param {number} max_distance
+     * @param {number[]|Float32Array|Ray3} ray
      * @param {number} min_bounce
      * @param {number} max_bounce
      * @param {function} random
@@ -41,19 +46,21 @@ export class PathTracer {
     path_trace(
         out,
         ray,
-        max_distance,
         min_bounce,
         max_bounce,
         random = Math.random,
         scene
     ) {
-        //TODO add importance sampling, see https://raytracing.github.io/books/RayTracingTheRestOfYourLife.html#lightscattering/thescatteringpdf
 
-        array_copy(ray, 0, _ray_0, 0, 6);
+        _ray_0.copy(ray);
+
+        irradiance[0] = 0;
+        irradiance[1] = 0;
+        irradiance[2] = 0;
 
-        irradiance[0] = 1;
-        irradiance[1] = 1;
-        irradiance[2] = 1;
+        color_mask[0] = 1;
+        color_mask[1] = 1;
+        color_mask[2] = 1;
 
         let i;
         for (i = 0; i < max_bounce; ++i) {
@@ -61,15 +68,13 @@ export class PathTracer {
             if (i >= min_bounce) {
                 const russian_roulette_roll = random();
 
-                if (russian_roulette_roll > RUSSIAN_ROULETTE_PROBABILITY) {
+                if (russian_roulette_roll < RUSSIAN_ROULETTE_PROBABILITY) {
                     // terminate ray
                     break;
                 }
             }
 
-
-            const hit_distance = scene.trace(trace_result, _ray_0, 0.0001, max_distance);
-
+            const hit_distance = scene.trace(trace_result, _ray_0);
 
             if (hit_distance < 0) {
                 // ray didn't hit anything
@@ -77,30 +82,33 @@ export class PathTracer {
                 break;
             }
 
-            scene.sample_material(tmp_0, trace_result);
-
-            // adjust normal on the hit
-            array_copy(tmp_0, 3, trace_result, 3, 3);
-            array_copy(trace_result, 0, _ray_0, 0, 3);
+            scene.sample_material(tmp_0, trace_result, _ray_0);
 
-            // accumulate irradiance
-            vec3.multiply(irradiance, irradiance, tmp_0);
 
-            // reflect ray
-            getBiasedNormalSample(_ray_0, 3, tmp_0, 3, 1, random);
+            vec3.multiply(color_mask, color_mask, tmp_0);
 
-        }
+            // construct new ray, aligned on the normal of the contact
+            array_copy(tmp_0, 3, _ray_0, 3, 3); // copy new direction
+            array_copy(trace_result, 0, _ray_0, 0, 3); // copy new origin
 
+            // move ray forward by a small amount to avoid self-occlusion
+            _ray_0.shiftForward(0.00001);
 
-        if (i > 0) {
             // light sampling
-            scene.sample_lights(tmp_1, 0, trace_result, 0);
+            scene.sample_lights(tmp_0, 0, _ray_0);
+
+            // sample on cosine lobe ray
+            getBiasedNormalSample(_ray_0, 3, _ray_0, 3, 1, random);
+
+            // // accumulate irradiance
+            irradiance[0] += color_mask[0] * tmp_0[0];
+            irradiance[1] += color_mask[1] * tmp_0[1];
+            irradiance[2] += color_mask[2] * tmp_0[2];
+
+        }
 
-            irradiance[0] *= tmp_1[0];
-            irradiance[1] *= tmp_1[1];
-            irradiance[2] *= tmp_1[2];
-        } else {
 
+        if (i === 0) {
             // ray didn't hit anything on the very first bounce
 
             // sample "environment" and terminate path as there is nothing to reflect off of
@@ -113,6 +121,5 @@ export class PathTracer {
         out[1] = irradiance[1]
         out[2] = irradiance[2]
 
-        // array_copy(irradiance, 0, out, 0, 3);
     }
-}
+}

package/src/engine/graphics/sh3/path_tracer/material/MaterialConverter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MaterialConverter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/material/MaterialConverter.js"],"names":[],"mappings":"AASA;IA4BI;;;;OAIG;IACH,kBAHW,MAAM,QAAQ,GACZ,gBAAgB,CA2D5B;;CAEJ;iCA/FgC,uBAAuB"}
+{"version":3,"file":"MaterialConverter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/material/MaterialConverter.js"],"names":[],"mappings":"AA8BA;IA4BI;;;;OAIG;IACH,kBAHW,MAAM,QAAQ,GACZ,gBAAgB,CAyC5B;;CAEJ;iCApGgC,uBAAuB"}

package/src/engine/graphics/sh3/path_tracer/material/MaterialConverter.js

@@ -1,12 +1,33 @@
 import { Color } from "three";
-import {
-    TextureAttachmentsByMaterialType
-} from "../../../../asset/loaders/material/TextureAttachmensByMaterialType.js";
 import { convertTexture2Sampler2D } from "../../../texture/sampler/convertTexture2Sampler2D.js";
 import { sampler_multiply_vector } from "../../../texture/sampler/sampler_multiply_vector.js";
+import { iterate_three_material_textures } from "../../../three/material/iterate_three_material_textures.js";
 import { StandardMaterial } from "./StandardMaterial.js";
 import { StandardTexture } from "./StandardTexture.js";
 
+/**
+ *
+ * @param {Map<number,StandardTexture>} cache
+ * @param {AssetManager} asset_manager
+ * @param {THREE.Material} material
+ * @returns {Promise<void>}
+ */
+async function precache_textures(cache, asset_manager, material) {
+
+    const textures = iterate_three_material_textures(material);
+
+    for (const { name, texture } of textures) {
+        if (cache.has(texture.id)) {
+            // already processed
+            continue;
+        }
+
+
+    }
+
+
+}
+
 export class MaterialConverter {
     /**
      * Maps {@link Texture.id} to relevant sampler
@@ -44,46 +65,28 @@ export class MaterialConverter {
 
         const result = new StandardMaterial();
 
-        //patch textures
-        const materialType = material.type;
-
-        /**
-         *
-         * @type {TextureAttachment[]}
-         */
-        const attachments = TextureAttachmentsByMaterialType[materialType];
-
-        if (attachments !== undefined) {
-
-            for (let i = 0; i < attachments.length; i++) {
-                const attachment = attachments[i];
-
-                const texture = attachment.read(material);
-
-                if (texture === undefined || texture === null) {
-                    continue;
-                }
-
-                const sampler = this.#ensure_texture(texture);
-
-                const name = attachment.name;
-
-                if (name === "diffuse") {
-                    result.diffuse = sampler;
-                } else if (name === "normal") {
-                    result.normal = sampler;
-                } else if (name === "metalness") {
-                    result.metalness = sampler;
-                } else if (name === "roughness") {
-                    result.roughness = sampler;
-                } else if (name === "emissive") {
-                    result.emissive = sampler;
-                } else {
-                    // unused
-                }
+        const textures = iterate_three_material_textures(material);
 
+        //patch textures
 
+        for (const { name, texture } of textures) {
+
+            const sampler = this.#ensure_texture(texture);
+
+            if (name === "diffuse") {
+                result.diffuse = sampler;
+            } else if (name === "normal") {
+                result.normal = sampler;
+            } else if (name === "metalness") {
+                result.metalness = sampler;
+            } else if (name === "roughness") {
+                result.roughness = sampler;
+            } else if (name === "emissive") {
+                result.emissive = sampler;
+            } else {
+                // unused
             }
+
         }
 
         if (material.color !== undefined && !material.color.equals(new Color(1, 1, 1))) {

package/src/engine/graphics/sh3/path_tracer/material/StandardMaterial.d.ts

@@ -5,6 +5,20 @@ export class StandardMaterial {
     emissive: StandardTexture;
     roughness: StandardTexture;
     metalness: StandardTexture;
+    /**
+     *
+     * @param {number} incoming_direction_x
+     * @param {number} incoming_direction_y
+     * @param {number} incoming_direction_z
+     * @param {number} normal_x
+     * @param {number} normal_y
+     * @param {number} normal_z
+     * @param {number} outgoing_x
+     * @param {number}  outgoing_y
+     * @param {number} outgoing_z
+     * @returns {number}
+     */
+    scattering_pdf(incoming_direction_x: number, incoming_direction_y: number, incoming_direction_z: number, normal_x: number, normal_y: number, normal_z: number, outgoing_x: number, outgoing_y: number, outgoing_z: number): number;
 }
 import { StandardTexture } from "./StandardTexture.js";
 //# sourceMappingURL=StandardMaterial.d.ts.map

package/src/engine/graphics/sh3/path_tracer/material/StandardMaterial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StandardMaterial.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/material/StandardMaterial.js"],"names":[],"mappings":"AAWA;IACI,WAAkB;IAElB,yBAA+C;IAC/C,wBAA6C;IAC7C,0BAAiD;IACjD,2BAAmD;IACnD,2BAAmD;CACtD;gCAlB+B,sBAAsB"}
+{"version":3,"file":"StandardMaterial.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/material/StandardMaterial.js"],"names":[],"mappings":"AAaA;IACI,WAAkB;IAElB,yBAA+C;IAC/C,wBAA6C;IAC7C,0BAAiD;IACjD,2BAAmD;IACnD,2BAAmD;IAEnD;;;;;;;;;;;;OAYG;IACH,qCAXW,MAAM,wBACN,MAAM,wBACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,MAAM,CAkBlB;CACJ;gCAjD+B,sBAAsB"}

package/src/engine/graphics/sh3/path_tracer/material/StandardMaterial.js

@@ -1,8 +1,10 @@
+import { v3_dot } from "../../../../../core/geom/vec3/v3_dot.js";
+import { PI_RECIPROCAL } from "../../../../../core/math/PI_RECIPROCAL.js";
 import { one_pixel_sampler_uint8 } from "../../../texture/sampler/one_pixel_sampler_uint8.js";
 import { StandardTexture } from "./StandardTexture.js";
 
 const DEFAULT_DIFFUSE = one_pixel_sampler_uint8([255, 255, 255, 255]);
-const DEFAULT_NORMAL = one_pixel_sampler_uint8([0, 0, 255]);
+const DEFAULT_NORMAL = one_pixel_sampler_uint8([127, 127, 255]);
 const DEFAULT_EMISSIVE = one_pixel_sampler_uint8([0, 0, 0]);
 const DEFAULT_ROUGHNESS = one_pixel_sampler_uint8([255]);
 const DEFAULT_METALNESS = one_pixel_sampler_uint8([0]);
@@ -17,5 +19,36 @@ export class StandardMaterial {
     emissive = StandardTexture.from(DEFAULT_EMISSIVE)
     roughness = StandardTexture.from(DEFAULT_ROUGHNESS)
     metalness = StandardTexture.from(DEFAULT_METALNESS)
+
+    /**
+     *
+     * @param {number} incoming_direction_x
+     * @param {number} incoming_direction_y
+     * @param {number} incoming_direction_z
+     * @param {number} normal_x
+     * @param {number} normal_y
+     * @param {number} normal_z
+     * @param {number} outgoing_x
+     * @param {number}  outgoing_y
+     * @param {number} outgoing_z
+     * @returns {number}
+     */
+    scattering_pdf(
+        incoming_direction_x, incoming_direction_y, incoming_direction_z,
+        normal_x, normal_y, normal_z,
+        outgoing_x, outgoing_y, outgoing_z,
+    ) {
+        const cos_theta = v3_dot(
+            normal_x, normal_y, normal_z,
+            outgoing_x, outgoing_y, outgoing_z
+        );
+
+        if (cos_theta < 0) {
+            // clamp rays below horizon
+            return 0;
+        }
+
+        return cos_theta * PI_RECIPROCAL;
+    }
 }
 

package/src/engine/graphics/sh3/path_tracer/prepare_scene_gltf.d.ts

@@ -0,0 +1,21 @@
+export function make_sun({ temperature, color, intensity, direction }?: {
+    temperature?: number;
+    color?: string;
+    intensity?: number;
+    direction?: Vector3;
+}): DirectionalLight;
+/**
+ *
+ * @param {PathTracedScene} scene
+ * @param {THREE.Camera} camera
+ * @param {string} url
+ * @param {number} [zoom]
+ * @param {number} [floor_level]
+ * @param {Object} [sun]
+ * @param {boolean} [no_materials]
+ * @return {Promise<void>}
+ */
+export function prepare_scene_gltf({ scene, camera, url, zoom, floor_level, sun, no_materials }: PathTracedScene): Promise<void>;
+import Vector3 from "../../../../core/geom/Vector3.js";
+import { DirectionalLight } from "../../render/forward_plus/model/DirectionalLight.js";
+//# sourceMappingURL=prepare_scene_gltf.d.ts.map

package/src/engine/graphics/sh3/path_tracer/prepare_scene_gltf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare_scene_gltf.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/prepare_scene_gltf.js"],"names":[],"mappings":"AAaA;;;;;qBAyBC;AAaD;;;;;;;;;;GAUG;AACH,mHAFY,QAAQ,IAAI,CAAC,CA8CxB;oBAnGmB,kCAAkC;iCAErB,qDAAqD"}

package/src/engine/graphics/sh3/path_tracer/prepare_scene_gltf.js

@@ -0,0 +1,107 @@
+import { vec3 } from "gl-matrix";
+import { Box3, MeshStandardMaterial, PlaneBufferGeometry, Sphere } from "three";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { Color } from "../../../../core/color/Color.js";
+import { kelvin_to_rgb } from "../../../../core/color/kelvin/kelvin_to_rgb.js";
+import { noop } from "../../../../core/function/noop.js";
+import Quaternion from "../../../../core/geom/Quaternion.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { DirectionalLight } from "../../render/forward_plus/model/DirectionalLight.js";
+import { three_object_replace_materials } from "../../three/three_object_replace_materials.js";
+import { three_object_to_path_traced_scene } from "./three_object_to_path_traced_scene.js";
+
+export 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;
+}
+
+/**
+ *
+ * @param {string} url
+ * @return {Promise<GLTF>}
+ */
+function promise_gltf(url) {
+    return new Promise((resolve, reject) => {
+        new GLTFLoader().load(url, resolve, noop, reject);
+    });
+}
+
+/**
+ *
+ * @param {PathTracedScene} scene
+ * @param {THREE.Camera} camera
+ * @param {string} url
+ * @param {number} [zoom]
+ * @param {number} [floor_level]
+ * @param {Object} [sun]
+ * @param {boolean} [no_materials]
+ * @return {Promise<void>}
+ */
+export async function prepare_scene_gltf({
+                                             scene,
+                                             camera,
+                                             url,
+                                             zoom = 1,
+                                             floor_level = 0,
+                                             sun,
+                                             no_materials = false
+                                         }) {
+    const gltf = await promise_gltf(url);
+
+
+    const ground_material = new MeshStandardMaterial({
+        color: '#ffceae'
+    });
+    scene.createMesh(new PlaneBufferGeometry(), ground_material, Transform.fromJSON({
+        position: new Vector3(0, floor_level, 0),
+        scale: 5000,
+        rotation: Quaternion.fromEulerAngles(-Math.PI / 2, 0, 0)
+    }).matrix);
+
+
+    const gltf_scene = gltf.scene;
+
+    if (no_materials) {
+        three_object_replace_materials(gltf_scene, new MeshStandardMaterial({ color: 'white' }));
+    }
+
+    three_object_to_path_traced_scene(gltf_scene, scene);
+
+    const box3 = new Box3();
+    box3.setFromObject(gltf_scene);
+
+    const sphere = new Sphere();
+
+    box3.getBoundingSphere(sphere);
+
+    scene.addLight(make_sun(sun));
+
+    camera.position.set(1, 1.3, 1)
+        .normalize()
+        .multiplyScalar(sphere.radius * 2.6 * (1 / zoom));
+
+    camera.lookAt(sphere.center);
+}