@woosh/meep-engine 2.109.4 → 2.109.6

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);
+}

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

@@ -1,23 +1,15 @@
-import { mat4, vec3 } from "gl-matrix";
-import {
-    Box3,
-    MeshStandardMaterial,
-    OctahedronBufferGeometry,
-    PerspectiveCamera,
-    PlaneBufferGeometry,
-    Sphere
-} from "three";
-import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { mat4 } from "gl-matrix";
+import { MeshStandardMaterial, OctahedronBufferGeometry, PerspectiveCamera, PlaneBufferGeometry } from "three";
 import { PLYLoader } from "three/examples/jsm/loaders/PLYLoader.js";
 
 import '../../../../../../../../css/game.scss';
 import { float_to_uint8 } from "../../../../core/binary/float_to_uint8.js";
 import { Color } from "../../../../core/color/Color.js";
-import { kelvin_to_rgb } from "../../../../core/color/kelvin/kelvin_to_rgb.js";
 import { linear_to_sRGB } from "../../../../core/color/sRGB/linear_to_sRGB.js";
 
 import { noop } from "../../../../core/function/noop.js";
 import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
+import { Ray3 } from "../../../../core/geom/3d/Ray3.js";
 import Quaternion from "../../../../core/geom/Quaternion.js";
 import { v3_distance } from "../../../../core/geom/vec3/v3_distance.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
@@ -40,10 +32,9 @@ import { DirectionalLight } from "../../render/forward_plus/model/DirectionalLig
 import { sampler2d_scale } from "../../texture/sampler/resize/sampler2d_scale.js";
 import { Sampler2D } from "../../texture/sampler/Sampler2D.js";
 import sampler2D2Canvas from "../../texture/sampler/Sampler2D2Canvas.js";
-import { three_object_replace_materials } from "../../three/three_object_replace_materials.js";
 import { PathTracedScene } from "./PathTracedScene.js";
 import { PathTracer } from "./PathTracer.js";
-import { three_object_to_path_traced_scene } from "./three_object_to_path_traced_scene.js";
+import { make_sun, prepare_scene_gltf } from "./prepare_scene_gltf.js";
 
 document.body.style.margin = 0;
 document.body.style.overflow = "hidden";
@@ -76,40 +67,14 @@ vCanvas.css({
  * How many rays to use per-pixel
  * @type {number}
  */
-const PIXEL_SAMPLE_COUNT = 1;
+const PIXEL_SAMPLE_COUNT = 256;
+const PIXEL_RENDER_RATIO = 1;
 
 const scene = new PathTracedScene();
 const pt = new PathTracer();
 
 window.scene = scene;
 
-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);
     camera.lookAt(0, 0, 0);
@@ -153,74 +118,6 @@ function promise_ply(url) {
     });
 }
 
-/**
- *
- * @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>}
- */
-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);
-}
-
 /**
  *
  * @param {PathTracedScene} scene
@@ -316,8 +213,10 @@ async function prepare_sponza(scene, camera) {
         scene: scene,
         camera: camera,
         url: path,
+        no_materials: false,
         sun: {
-            direction: new Vector3(0.2, -1, 0.2)
+            direction: new Vector3(0.2, -1, 0.2),
+            intensity: 3
         }
     });
 
@@ -474,7 +373,7 @@ function* render(target, pt, camera, scene, progress = { current: 0, total: 0 })
 
     const pixel_color = [];
     const pixel_accummulation = [];
-    const ray = [];
+    const ray = new Ray3();
 
     const ray_origin = new Vector3();
     const ray_direction = new Vector3();
@@ -544,7 +443,8 @@ function* render(target, pt, camera, scene, progress = { current: 0, total: 0 })
                             ray_direction.x, ray_direction.y, ray_direction.z
                         );
 
-                        pt.path_trace(pixel_color, ray, Infinity, 1, 7, random, scene);
+                        ray.tMax = Infinity;
+                        pt.path_trace(pixel_color, ray, 1, 7, random, scene);
 
                         pixel_accummulation[0] += pixel_color[0];
                         pixel_accummulation[1] += pixel_color[1];
@@ -558,7 +458,7 @@ function* render(target, pt, camera, scene, progress = { current: 0, total: 0 })
                     pixel_accummulation[1] /= pixel_sample_count
                     pixel_accummulation[2] /= pixel_sample_count
 
-                    // linear_to_sRGB(pixel_accummulation, 0, pixel_accummulation, 0);
+                    linear_to_sRGB(pixel_accummulation, 0, pixel_accummulation, 0);
 
                     output_data[pixel_address] = float_to_uint8(pixel_accummulation[0]);
                     output_data[pixel_address + 1] = float_to_uint8(pixel_accummulation[1]);
@@ -605,21 +505,19 @@ async function start_renderer(camera) {
     // await prepare_scene_lucy(scene, camera);
     // await prepare_scene_rtiow(pt, camera);
     // await prepare_scene_sphere_01(pt, camera);
-    // await prepare_gi_box_scene(scene, camera);
-    await prepare_sponza(scene, camera);
+    await prepare_gi_box_scene(scene, camera);
+    // await prepare_sponza(scene, camera);
     // await prepare_scene_gltf({scene, camera, path, url: path});
 
 
-    await scene.build();
     // pt.optimize();
 
-    const pixelRatio = 0.5;
 
-    const rt = Sampler2D.uint8(4, vCanvas.size.x, vCanvas.size.y);
+    const rt = Sampler2D.uint8clamped(4, vCanvas.size.x, vCanvas.size.y);
 
     let scaled_rt = rt;
-    if (pixelRatio !== 1) {
-        scaled_rt = Sampler2D.uint8clamped(4, Math.ceil(rt.width * pixelRatio), Math.ceil(rt.height * pixelRatio));
+    if (PIXEL_RENDER_RATIO !== 1) {
+        scaled_rt = Sampler2D.uint8clamped(4, Math.ceil(rt.width * PIXEL_RENDER_RATIO), Math.ceil(rt.height * PIXEL_RENDER_RATIO));
     }
 
     function make_render_task() {
@@ -685,7 +583,7 @@ async function start_renderer(camera) {
 start_renderer(camera);
 
 vCanvas.el.addEventListener(MouseEvents.Click, (evt) => {
-    const ray = [];
+    const ray = new Ray3();
 
     const ray_origin = new Vector3();
     const ray_direction = new Vector3();
@@ -706,10 +604,12 @@ vCanvas.el.addEventListener(MouseEvents.Click, (evt) => {
         ray_origin.x, ray_origin.y, ray_origin.z,
         ray_direction.x, ray_direction.y, ray_direction.z
     );
+    ray.tMin = 0;
+    ray.tMax = Infinity;
 
     const out = [];
 
-    scene.trace(out, ray, 0, Infinity);
+    scene.trace(out, ray);
 
     console.log(pointer, out, ray, pt);
 

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

@@ -1,12 +1,3 @@
-/**
- *
- * @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: number[], output_offset: number, normal: number[], normal_offset: number, m: number[]): void;
 /**
  *
  * @param {number[]} output

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

@@ -1 +1 @@
-{"version":3,"file":"ray_hit_apply_transform.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/ray_hit_apply_transform.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,4CANW,MAAM,EAAE,iBACR,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,KACN,MAAM,EAAE,QAmBlB;AAED;;;;;GAKG;AACH,gDAJW,MAAM,EAAE,OACR,MAAM,EAAE,KACR,MAAM,EAAE,GAAC,YAAY,QAuB/B"}
+{"version":3,"file":"ray_hit_apply_transform.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/ray_hit_apply_transform.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,gDAJW,MAAM,EAAE,OACR,MAAM,EAAE,KACR,MAAM,EAAE,GAAC,YAAY,QAuB/B"}

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

@@ -1,31 +1,5 @@
-import { v3_length } from "../../../../core/geom/vec3/v3_length.js";
+import { v3_matrix4_rotate } from "../../../../core/geom/vec3/v3_matrix4_rotate.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;
-}
 
 /**
  *
@@ -52,6 +26,6 @@ export function ray_hit_apply_transform(output, hit, m) {
     output[2] = result_p_z;
 
     // transform normal
-    transform_normal_m4(output, 3, hit, 3, m);
+    v3_matrix4_rotate(output, 3, hit, 3, m);
 
 }

package/src/engine/graphics/sh3/path_tracer/sampling/getBiasedNormalSample.d.ts

@@ -9,13 +9,4 @@
  * @param {function():number} random
  */
 export function getBiasedNormalSample(out: number[], out_offset: number, normal: number[], normal_offset: number, power: number, random: () => number): void;
-/**
- * @see https://www.shadertoy.com/view/stVfWc
- * @param {number[]} out
- * @param {number} out_offset
- * @param {number[]} normal
- * @param {number} normal_offset
- * @param {function():number} random
- */
-export function getCosineDirection(out: number[], out_offset: number, normal: number[], normal_offset: number, random: () => number): void;
 //# sourceMappingURL=getBiasedNormalSample.d.ts.map

package/src/engine/graphics/sh3/path_tracer/sampling/getBiasedNormalSample.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getBiasedNormalSample.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/sampling/getBiasedNormalSample.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,2CAPW,MAAM,EAAE,cACR,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,SACN,MAAM,gBACK,MAAM,QAsD3B;AAED;;;;;;;GAOG;AACH,wCANW,MAAM,EAAE,cACR,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,gBACK,MAAM,QAgC3B"}
+{"version":3,"file":"getBiasedNormalSample.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/sampling/getBiasedNormalSample.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,2CAPW,MAAM,EAAE,cACR,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,SACN,MAAM,gBACK,MAAM,QAsD3B"}

package/src/engine/graphics/sh3/path_tracer/sampling/getBiasedNormalSample.js

@@ -64,42 +64,3 @@ export function getBiasedNormalSample(
     out[out_offset + 2] = k0 * o1_z + k1 * o2_z + r_y * dir_z;
 }
 
-/**
- * @see https://www.shadertoy.com/view/stVfWc
- * @param {number[]} out
- * @param {number} out_offset
- * @param {number[]} normal
- * @param {number} normal_offset
- * @param {function():number} random
- */
-export function getCosineDirection(
-    out,
-    out_offset,
-    normal,
-    normal_offset,
-    random
-) {
-
-    const dir_x = normal[normal_offset];
-    const dir_y = normal[normal_offset + 1];
-    const dir_z = normal[normal_offset + 2];
-
-    const r_x = random() * PI2;
-    const r_y = 2 * random() - 1;
-
-    const oneminus = Math.sqrt(1.0 - r_y * r_y);
-
-    const k0 = Math.cos(r_x) * oneminus;
-    const k1 = Math.sin(r_x) * oneminus;
-
-
-    let out_dir_x = dir_x + k0;
-    let out_dir_y = dir_y + k1;
-    let out_dir_z = dir_z + r_y;
-
-    const len2 = 1 / Math.hypot(out_dir_x, out_dir_y, out_dir_z);
-
-    out[out_offset] = out_dir_x * len2;
-    out[out_offset + 1] = out_dir_y * len2;
-    out[out_offset + 2] = out_dir_z * len2;
-}

package/src/engine/graphics/sh3/path_tracer/sampling/getCosineDirection.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @see https://www.shadertoy.com/view/stVfWc
+ * @param {number[]} out
+ * @param {number} out_offset
+ * @param {number[]} normal
+ * @param {number} normal_offset
+ * @param {function():number} random
+ */
+export function getCosineDirection(out: number[], out_offset: number, normal: number[], normal_offset: number, random: () => number): void;
+//# sourceMappingURL=getCosineDirection.d.ts.map

package/src/engine/graphics/sh3/path_tracer/sampling/getCosineDirection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getCosineDirection.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/sampling/getCosineDirection.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wCANW,MAAM,EAAE,cACR,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,gBACK,MAAM,QAgC3B"}

package/src/engine/graphics/sh3/path_tracer/sampling/getCosineDirection.js

@@ -0,0 +1,41 @@
+import { PI2 } from "../../../../../core/math/PI2.js";
+
+/**
+ * @see https://www.shadertoy.com/view/stVfWc
+ * @param {number[]} out
+ * @param {number} out_offset
+ * @param {number[]} normal
+ * @param {number} normal_offset
+ * @param {function():number} random
+ */
+export function getCosineDirection(
+    out,
+    out_offset,
+    normal,
+    normal_offset,
+    random
+) {
+
+    const dir_x = normal[normal_offset];
+    const dir_y = normal[normal_offset + 1];
+    const dir_z = normal[normal_offset + 2];
+
+    const r_x = random() * PI2;
+    const r_y = 2 * random() - 1;
+
+    const oneminus = Math.sqrt(1.0 - r_y * r_y);
+
+    const k0 = Math.cos(r_x) * oneminus;
+    const k1 = Math.sin(r_x) * oneminus;
+
+
+    let out_dir_x = dir_x + k0;
+    let out_dir_y = dir_y + k1;
+    let out_dir_z = dir_z + r_y;
+
+    const len2 = 1 / Math.hypot(out_dir_x, out_dir_y, out_dir_z);
+
+    out[out_offset] = out_dir_x * len2;
+    out[out_offset + 1] = out_dir_y * len2;
+    out[out_offset + 2] = out_dir_z * len2;
+}

package/src/engine/graphics/sh3/path_tracer/sampling/v3_orthonormal_matrix_from_normal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Build orthonormal matrix from direction vector
+ * @param {number[]} out
+ * @param {number} out_offset
+ * @param {number} dir_x
+ * @param {number} dir_y
+ * @param {number} dir_z
+ */
+export function v3_orthonormal_matrix_from_normal(out: number[], out_offset: number, dir_x: number, dir_y: number, dir_z: number): void;
+//# sourceMappingURL=v3_orthonormal_matrix_from_normal.d.ts.map

package/src/engine/graphics/sh3/path_tracer/sampling/v3_orthonormal_matrix_from_normal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_orthonormal_matrix_from_normal.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/sampling/v3_orthonormal_matrix_from_normal.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,uDANW,MAAM,EAAE,cACR,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QAsChB"}

package/src/engine/graphics/sh3/path_tracer/sampling/v3_orthonormal_matrix_from_normal.js

@@ -0,0 +1,45 @@
+/**
+ * Build orthonormal matrix from direction vector
+ * @param {number[]} out
+ * @param {number} out_offset
+ * @param {number} dir_x
+ * @param {number} dir_y
+ * @param {number} dir_z
+ */
+export function v3_orthonormal_matrix_from_normal(out, out_offset, dir_x, dir_y, dir_z) {
+    // we build orthonormal vectors with respect to the direction vector
+    let o1_x, o1_y, o1_z;
+
+    if (Math.abs(dir_x) > Math.abs(dir_z)) {
+        o1_x = -dir_y;
+        o1_y = dir_x;
+        o1_z = 0;
+    } else {
+        o1_x = 0;
+        o1_y = -dir_z;
+        o1_z = dir_y;
+    }
+
+    // normalize orthonormal vector
+    const o1_norm = 1 / Math.hypot(o1_x, o1_y, o1_z);
+
+    o1_x *= o1_norm;
+    o1_y *= o1_norm;
+    o1_z *= o1_norm;
+
+    const o2_x = dir_y * o1_z - dir_z * o1_y;
+    const o2_y = dir_z * o1_x - dir_x * o1_z;
+    const o2_z = dir_x * o1_y - dir_y * o1_x;
+
+    out[out_offset] = o1_x;
+    out[out_offset + 1] = o1_y;
+    out[out_offset + 2] = o1_z;
+
+    out[out_offset + 3] = o2_x;
+    out[out_offset + 4] = o2_y;
+    out[out_offset + 5] = o2_z;
+
+    out[out_offset + 6] = dir_x;
+    out[out_offset + 7] = dir_y;
+    out[out_offset + 8] = dir_z;
+}

package/src/engine/graphics/sh3/path_tracer/texture/sample_material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sample_material.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/texture/sample_material.js"],"names":[],"mappings":"AAuCA;;;;;;;GAOG;AACH,qCANW,MAAM,EAAE,sCAER,MAAM,KACN,MAAM,KACN,MAAM,QAmEhB"}
+{"version":3,"file":"sample_material.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/texture/sample_material.js"],"names":[],"mappings":"AA4CA;;;;;;;GAOG;AACH,qCANW,MAAM,EAAE,sCAER,MAAM,KACN,MAAM,KACN,MAAM,QAkFhB"}

package/src/engine/graphics/sh3/path_tracer/texture/sample_material.js

@@ -1,12 +1,17 @@
 import { vec3 } from "gl-matrix";
 import { dataTypeFromTypedArray } from "../../../../../core/binary/type/dataTypeFromTypedArray.js";
+import { v3_distance_sqr } from "../../../../../core/geom/vec3/v3_distance_sqr.js";
+import { v3_matrix4_rotate } from "../../../../../core/geom/vec3/v3_matrix4_rotate.js";
 import { decode_attribute_value } from "../../../geometry/decode_attribute_value.js";
 import { geometry_construct_triangle_normal } from "../../../geometry/geometry_construct_triangle_normal.js";
 import { sample_triangle_attribute } from "../geometry/sample_triangle_attribute.js";
-import { transform_normal_m4 } from "../ray_hit_apply_transform.js";
+
+import { v3_orthonormal_matrix_from_normal } from "../sampling/v3_orthonormal_matrix_from_normal.js";
 
 const texture_uv = [0, 0];
-const color = new Float64Array([1, 1, 1]);
+const color = new Float64Array(3);
+const normal = new Float32Array(3);
+const scratch_m3 = new Float32Array(9);
 
 /**
  *
@@ -52,6 +57,7 @@ export function sample_material(
     u, v
 ) {
 
+    const material = mesh.material;
     const geometry = mesh.geometry;
     const index_attribute = geometry.getIndex();
     const index_array = index_attribute.array;
@@ -80,8 +86,25 @@ export function sample_material(
     }
 
     // apply transform
-    transform_normal_m4(out, 3, out, 3, mesh.transform);
+    v3_matrix4_rotate(out, 3, out, 3, mesh.transform);
+
+    material.normal.sample(normal, texture_uv[0], texture_uv[1]);
 
+    if (v3_distance_sqr(normal[0], normal[1], normal[2], 0.5, 0.5, 1) > 0.01) {
+        //
+        normal[0] = normal[0] * 2 - 1;
+        normal[1] = normal[1] * 2 - 1;
+        normal[2] = normal[2] * 2 - 1;
+
+        vec3.normalize(normal, normal);
+
+        // needs transform
+        v3_orthonormal_matrix_from_normal(scratch_m3, 0, out[3], out[4], out[5]);
+
+        out[3] = scratch_m3[0] * normal[0] + scratch_m3[3] * normal[1] + scratch_m3[6] * normal[2];
+        out[4] = scratch_m3[1] * normal[0] + scratch_m3[4] * normal[1] + scratch_m3[7] * normal[2];
+        out[5] = scratch_m3[2] * normal[0] + scratch_m3[5] * normal[1] + scratch_m3[8] * normal[2];
+    }
 
     const uv_attribute = geometry.getAttribute('uv');
 
@@ -102,12 +125,9 @@ export function sample_material(
         vec3.multiply(out, out, color);
     }
 
-    const material = mesh.material;
-
 
-    const tex_diffuse = material.diffuse;
-
-    tex_diffuse.sample(color, texture_uv[0], texture_uv[1]);
+    material.diffuse.sample(color, texture_uv[0], texture_uv[1]);
 
     vec3.multiply(out, out, color);
+
 }