@woosh/meep-engine 2.109.13 → 2.109.15

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.109.13",
+  "version": "2.109.15",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/geom/3d/Ray3.d.ts

@@ -1,23 +1,21 @@
 /**
  * 3D ray
+ * Oprimized representation for faster memory access
  */
 export class Ray3 extends Float32Array {
     constructor();
     set tMax(arg: any);
     get tMax(): any;
     6: any;
-    /**
-     *
-     * @param {number[]|Float32Array} v
-     */
-    set direction(arg: number[] | Float32Array);
-    get direction(): number[] | Float32Array;
     /**
      *
      * @param {number[]|Float32Array} v
      */
     set origin(arg: number[] | Float32Array);
     get origin(): number[] | Float32Array;
+    get origin_x(): number;
+    get origin_y(): number;
+    get origin_z(): number;
     /**
      *
      * @param {number} x
@@ -28,6 +26,15 @@ export class Ray3 extends Float32Array {
     0: number;
     1: number;
     2: number;
+    /**
+     *
+     * @param {number[]|Float32Array} v
+     */
+    set direction(arg: number[] | Float32Array);
+    get direction(): number[] | Float32Array;
+    get direction_x(): number;
+    get direction_y(): number;
+    get direction_z(): number;
     /**
      *
      * @param {number} x
@@ -38,6 +45,16 @@ export class Ray3 extends Float32Array {
     3: number;
     4: number;
     5: number;
+    normalizeDirection(): void;
+    /**
+     *
+     * @param {number} x normalized coordinates in -1,1 range
+     * @param {number} y normalized coordinates in -1,1 range
+     * @param {number} z normalized coordinates in -1,1 range, typically 0.5
+     * @param {number[]|Float32Array|mat4} transform
+     * @param {number[]|Float32Array|mat4} projection_inverse
+     */
+    projectFromCamera(x: number, y: number, z: number, transform: number[] | Float32Array | mat4, projection_inverse: number[] | Float32Array | mat4): void;
     /**
      *
      * @param {number} distance

package/src/core/geom/3d/Ray3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Ray3.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/3d/Ray3.js"],"names":[],"mappings":"AAOA;;GAEG;AACH;IACI,cAKC;IAMD,mBAEC;IAND,gBAEC;IAGG,OAAW;IAOf;;;OAGG;IACH,4CAEC;IAVD,yCAEC;IAcD;;;OAGG;IACH,yCAEC;IAVD,sCAEC;IAUD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAMhB;IAHG,UAAW;IACX,UAAW;IACX,UAAW;IAGf;;;;;OAKG;IACH,gBAJW,MAAM,KACN,MAAM,KACN,MAAM,QAMhB;IAHG,UAAW;IACX,UAAW;IACX,UAAW;IAGf;;;OAGG;IACH,uBAFW,MAAM,QAMhB;IAED;;;OAGG;IACH,iBAFW,MAAM,EAAE,UAAM,YAAY,QAepC;IAED;;;OAGG;IACH,SAFa,IAAI,CAQhB;IAED;;;OAGG;IACH,YAFW,IAAI,QAId;IAED,eAEC;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAInB;CACJ"}
+{"version":3,"file":"Ray3.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/3d/Ray3.js"],"names":[],"mappings":"AASA;;;GAGG;AACH;IACI,cAKC;IAMD,mBAEC;IAND,gBAEC;IAGG,OAAW;IAOf;;;OAGG;IACH,yCAEC;IAVD,sCAEC;IAUD,uBAEC;IAED,uBAEC;IAED,uBAEC;IAGD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAUhB;IAHG,UAAW;IACX,UAAW;IACX,UAAW;IAQf;;;OAGG;IACH,4CAEC;IAVD,yCAEC;IAWD,0BAEC;IAED,0BAEC;IAED,0BAEC;IAED;;;;;OAKG;IACH,gBAJW,MAAM,KACN,MAAM,KACN,MAAM,QAUhB;IAHG,UAAW;IACX,UAAW;IACX,UAAW;IAGf,2BAEC;IAED;;;;;;;OAOG;IACH,qBANW,MAAM,KACN,MAAM,KACN,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,OAAK,sBAC1B,MAAM,EAAE,GAAC,YAAY,OAAK,QA6BpC;IAED;;;OAGG;IACH,uBAFW,MAAM,QAMhB;IAED;;;OAGG;IACH,iBAFW,MAAM,EAAE,UAAM,YAAY,QAepC;IAED;;;OAGG;IACH,SAFa,IAAI,CAQhB;IAED;;;OAGG;IACH,YAFW,IAAI,QAId;IAED,eAEC;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAInB;CACJ"}

package/src/core/geom/3d/Ray3.js

@@ -1,12 +1,15 @@
+import { assert } from "../../assert.js";
 import { array_copy } from "../../collection/array/array_copy.js";
 import { array_range_equal_strict } from "../../collection/array/array_range_equal_strict.js";
 import { computeHashFloatArray } from "../../math/hash/computeHashFloatArray.js";
 import { v3_matrix4_multiply } from "../vec3/v3_matrix4_multiply.js";
 import { v3_matrix4_rotate } from "../vec3/v3_matrix4_rotate.js";
+import { v3_normalize_array } from "../vec3/v3_normalize_array.js";
 import { ray3_interval_array_apply_matrix4 } from "./ray/ray3_interval_array_apply_matrix4.js";
 
 /**
  * 3D ray
+ * Oprimized representation for faster memory access
  */
 export class Ray3 extends Float32Array {
     constructor() {
@@ -24,18 +27,6 @@ export class Ray3 extends Float32Array {
         this[6] = v;
     }
 
-    get direction() {
-        return new Float32Array(this.buffer, this.byteOffset + 3 * 4, 3);
-    }
-
-    /**
-     *
-     * @param {number[]|Float32Array} v
-     */
-    set direction(v) {
-        array_copy(v, 0, this, 3, 3);
-    }
-
     get origin() {
         return new Float32Array(this.buffer, this.byteOffset, 3);
     }
@@ -48,6 +39,19 @@ export class Ray3 extends Float32Array {
         array_copy(v, 0, this, 0, 3);
     }
 
+    get origin_x() {
+        return this[0];
+    }
+
+    get origin_y() {
+        return this[1];
+    }
+
+    get origin_z() {
+        return this[2];
+    }
+
+
     /**
      *
      * @param {number} x
@@ -55,11 +59,41 @@ export class Ray3 extends Float32Array {
      * @param {number} z
      */
     setOrigin(x, y, z) {
+        assert.isNumber(x, 'x');
+        assert.isNumber(y, 'y');
+        assert.isNumber(z, 'z');
+
         this[0] = x;
         this[1] = y;
         this[2] = z;
     }
 
+
+    get direction() {
+        return new Float32Array(this.buffer, this.byteOffset + 3 * 4, 3);
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array} v
+     */
+    set direction(v) {
+        array_copy(v, 0, this, 3, 3);
+    }
+
+
+    get direction_x() {
+        return this[3];
+    }
+
+    get direction_y() {
+        return this[4];
+    }
+
+    get direction_z() {
+        return this[5];
+    }
+
     /**
      *
      * @param {number} x
@@ -67,11 +101,56 @@ export class Ray3 extends Float32Array {
      * @param {number} z
      */
     setDirection(x, y, z) {
+        assert.isNumber(x, 'x');
+        assert.isNumber(y, 'y');
+        assert.isNumber(z, 'z');
+
         this[3] = x;
         this[4] = y;
         this[5] = z;
     }
 
+    normalizeDirection() {
+        v3_normalize_array(this, 3, this, 3);
+    }
+
+    /**
+     *
+     * @param {number} x normalized coordinates in -1,1 range
+     * @param {number} y normalized coordinates in -1,1 range
+     * @param {number} z normalized coordinates in -1,1 range, typically 0.5
+     * @param {number[]|Float32Array|mat4} transform
+     * @param {number[]|Float32Array|mat4} projection_inverse
+     */
+    projectFromCamera(
+        x, y, z,
+        transform,
+        projection_inverse
+    ) {
+        assert.isNumber(x, 'x');
+        assert.isNumber(y, 'y');
+        assert.isNumber(z, 'z');
+
+        // extract position from transform matrix
+        const origin_x = transform[12];
+        const origin_y = transform[13];
+        const origin_z = transform[14];
+
+        this.setOrigin(origin_x, origin_y, origin_z);
+
+        this.setDirection(x, y, z);
+        v3_matrix4_multiply(this, 3, this, 3, projection_inverse);
+        v3_matrix4_multiply(this, 3, this, 3, transform);
+
+        // subtract origin
+        this[3] -= origin_x;
+        this[4] -= origin_y;
+        this[5] -= origin_z;
+
+        // normalize
+        this.normalizeDirection();
+    }
+
     /**
      *
      * @param {number} distance

package/src/core/geom/vec3/v3_normalize_array.d.ts

@@ -1,9 +1,9 @@
 /**
  *
- * @param {number[]} input
+ * @param {number[]|Float32Array} input
  * @param {number} input_offset
- * @param {number[]} output
+ * @param {number[]|Float32Array} output
  * @param {number} output_offset
  */
-export function v3_normalize_array(input: number[], input_offset: number, output: number[], output_offset: number): void;
+export function v3_normalize_array(input: number[] | Float32Array, input_offset: number, output: number[] | Float32Array, output_offset: number): void;
 //# sourceMappingURL=v3_normalize_array.d.ts.map

package/src/core/geom/vec3/v3_normalize_array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_normalize_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_normalize_array.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,0CALW,MAAM,EAAE,gBACR,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAqBhB"}
+{"version":3,"file":"v3_normalize_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_normalize_array.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,0CALW,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,QAqBhB"}

package/src/core/geom/vec3/v3_normalize_array.js

@@ -1,8 +1,8 @@
 /**
  *
- * @param {number[]} input
+ * @param {number[]|Float32Array} input
  * @param {number} input_offset
- * @param {number[]} output
+ * @param {number[]|Float32Array} output
  * @param {number} output_offset
  */
 export function v3_normalize_array(

package/src/core/math/random/generate_halton_jitter.js

@@ -13,8 +13,8 @@ export function generate_halton_jitter(point_count) {
 
     for (let i = 0; i < point_count; i++) {
         const i2 = i * 2;
-        result[i2] = halton_sequence(2, i) * 2 - 1;
-        result[i2 + 1] = halton_sequence(3, i) * 2 - 1;
+        result[i2] = 1 - halton_sequence(2, i) * 2;
+        result[i2 + 1] = 1 - halton_sequence(3, i) * 2;
     }
 
     return result;

package/src/engine/graphics/sh3/gi/material/makeOctahedralDepthAtlas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"makeOctahedralDepthAtlas.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/gi/material/makeOctahedralDepthAtlas.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,sDAHW,MAAM,GACJ,WAAW,CAsBvB;4BA3BqF,OAAO"}
+{"version":3,"file":"makeOctahedralDepthAtlas.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/gi/material/makeOctahedralDepthAtlas.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,sDAHW,MAAM,GACJ,WAAW,CAsBvB;4BA3BoF,OAAO"}

package/src/engine/graphics/sh3/gi/material/makeOctahedralDepthAtlas.js

@@ -1,4 +1,4 @@
-import { ClampToEdgeWrapping, DataTexture, FloatType, NearestFilter, RedFormat } from "three";
+import { ClampToEdgeWrapping, DataTexture, FloatType, NearestFilter, RGFormat } from "three";
 
 /**
  *
@@ -7,10 +7,10 @@ import { ClampToEdgeWrapping, DataTexture, FloatType, NearestFilter, RedFormat }
  */
 export function makeOctahedralDepthAtlas(resolution = 4096) {
     const texture = new DataTexture(
-        new Float32Array(resolution * resolution),
+        new Float32Array(resolution * resolution * 2),
         resolution,
         resolution,
-        RedFormat,
+        RGFormat, // 2 channels
         FloatType
     );
 

package/src/engine/graphics/sh3/lpv/LightProbeVolumeBaker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightProbeVolumeBaker.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolumeBaker.js"],"names":[],"mappings":"AAOA;IAEI,8BAAqC;IAGrC;;;;;OAKG;IACH,0DAJa,SAAS,CAgErB;CACJ;wCA1EuC,8BAA8B;sBALhD,4CAA4C"}
+{"version":3,"file":"LightProbeVolumeBaker.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolumeBaker.js"],"names":[],"mappings":"AAOA;IAEI,8BAAqC;IAGrC;;;;;OAKG;IACH,0DAJa,SAAS,CAkErB;CACJ;wCA5EuC,8BAA8B;sBALhD,4CAA4C"}

package/src/engine/graphics/sh3/lpv/LightProbeVolumeBaker.js

@@ -42,15 +42,17 @@ export class LightProbeVolumeBaker {
             const max_distance = find_max_depth_radius_for_point(i, lpv.mesh, lpv.points);
 
             // bias a little to ensure we capture everything
-            const max_depth = max_distance * 1.01 + 0.00001;
+            const max_depth = max_distance * 1.01 + 1e-6;
 
             const depth_resolution = lpv.depth_map_resolution;
 
+            const probe_element_count = depth_resolution * depth_resolution * 2;
+
             renderer.bake_depth_octahedral(
                 depth_resolution,
                 max_depth,
                 lpv.points, i * 3,
-                lpv.depth, i * depth_resolution * depth_resolution
+                lpv.depth, i * probe_element_count
             );
 
         });

package/src/engine/graphics/sh3/lpv/depth/octahedral/bake_octahedral_depth_map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bake_octahedral_depth_map.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/lpv/depth/octahedral/bake_octahedral_depth_map.js"],"names":[],"mappings":"AAkBA;;;;;;;;;GASG;AACH,kDARW,MAAM,EAAE,iBACR,MAAM,oCAEN,MAAM,EAAE,UAAQ,mBAChB,MAAM,cACN,MAAM,aACN,MAAM,QAmFhB"}
+{"version":3,"file":"bake_octahedral_depth_map.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/lpv/depth/octahedral/bake_octahedral_depth_map.js"],"names":[],"mappings":"AA2BA;;;;;;;;;GASG;AACH,kDARW,MAAM,EAAE,iBACR,MAAM,oCAEN,MAAM,EAAE,UAAQ,mBAChB,MAAM,cACN,MAAM,aACN,MAAM,QA+GhB"}

package/src/engine/graphics/sh3/lpv/depth/octahedral/bake_octahedral_depth_map.js

@@ -5,8 +5,9 @@ import {
 import { Ray3 } from "../../../../../../core/geom/3d/Ray3.js";
 import { v3_distance } from "../../../../../../core/geom/vec3/v3_distance.js";
 import { v3_dot } from "../../../../../../core/geom/vec3/v3_dot.js";
-import { clamp01 } from "../../../../../../core/math/clamp01.js";
-import { PI_HALF } from "../../../../../../core/math/PI_HALF.js";
+import { v3_dot_array_array } from "../../../../../../core/geom/vec3/v3_dot_array_array.js";
+import { max2 } from "../../../../../../core/math/max2.js";
+import { generate_halton_jitter } from "../../../../../../core/math/random/generate_halton_jitter.js";
 
 const scratch_ray = new Ray3();
 
@@ -16,6 +17,14 @@ const scratch_ray = new Ray3();
  */
 const ray_hit = [];
 
+/**
+ *
+ * @type {number}
+ */
+const SUB_SAMPLE_COUNT = 7;
+
+const DEPTH_SHARPNESS = 1;
+
 /**
  *
  * @param {number[]} result
@@ -37,73 +46,101 @@ export function bake_octahedral_depth_map(
     scratch_ray.tMax = max_depth;
     array_copy(position, position_offset, scratch_ray, 0, 3);
 
+    const CONSTANT_NORMAL_BIAS = max_depth * 0.01 + 1e-6;
 
-    /**
-     * Resolution bias is to compensate for discontinuities between samples
-     * The lower the resolution - the higher the discontinuities
-     * This is heights of an arch on a unit sphere, where arch spans 1/resolution angle
-     * Half-PI is to get the height at midpoint of the arch
-     * x2 is to get error over the entire circle, as the previous term only gets us to semicircle (we can skip this to get half the max rise, or mean)
-     * xMath.SQRT2 is to allow for diagonals between pixels
-     * @type {number}
-     */
-    const RESOLUTION_BIAS = Math.sin(PI_HALF / resolution) * Math.SQRT2;
+    const ray_direction = scratch_ray.direction;
 
-    const NORMAL_BIAS = max_depth * 0.01 + 1e-6;
+    const probe_direction = new Float32Array(3);
+
+    const texel_uv_scale = 0.5 / (resolution - 1);
+
+    const jittered_sub_samples = generate_halton_jitter(SUB_SAMPLE_COUNT);
 
-    const ray_direction = scratch_ray.direction;
 
     for (let oct_x = 0; oct_x < resolution; oct_x++) {
         for (let oct_y = 0; oct_y < resolution; oct_y++) {
 
+            let distance_sum = 0;
+            let distance2_sum = 0;
+            let weight_sum = 0;
+
             const u = (oct_x) / (resolution - 1);
             const v = (oct_y) / (resolution - 1);
 
             decode_octahedron_to_unit(
-                ray_direction, 0,
+                probe_direction, 0,
                 u * 2 - 1, v * 2 - 1
             );
 
-            let distance = scene.trace(ray_hit, scratch_ray);
+            for (let sub_sample_index = 0; sub_sample_index < SUB_SAMPLE_COUNT; sub_sample_index++) {
 
-            if (distance < 0) {
-                // no hit
-                distance = max_depth;
-            } else {
-                const surface_normal_x = ray_hit[3];
-                const surface_normal_y = ray_hit[4];
-                const surface_normal_z = ray_hit[5];
+                const sample_index2 = sub_sample_index * 2;
 
-                const surface_position_x = ray_hit[0];
-                const surface_position_y = ray_hit[1];
-                const surface_position_z = ray_hit[2];
+                const ray_u = u + jittered_sub_samples[sample_index2] * texel_uv_scale;
+                const ray_v = v + jittered_sub_samples[sample_index2 + 1] * texel_uv_scale;
 
-                // check for possible miss
-                const hit_angle_cos = -v3_dot(
-                    surface_normal_x, surface_normal_y, surface_normal_z,
-                    ray_direction[0], ray_direction[1], ray_direction[2]
+                decode_octahedron_to_unit(
+                    ray_direction, 0,
+                    ray_u * 2 - 1, ray_v * 2 - 1
                 );
 
-                const resolution_bias_offset = max_depth * RESOLUTION_BIAS;
+                let distance = scene.trace(ray_hit, scratch_ray);
+
+                if (distance < 0) {
+                    // no hit
+                    distance = max_depth;
+                } else {
+                    const surface_normal_x = ray_hit[3];
+                    const surface_normal_y = ray_hit[4];
+                    const surface_normal_z = ray_hit[5];
+
+                    const surface_position_x = ray_hit[0];
+                    const surface_position_y = ray_hit[1];
+                    const surface_position_z = ray_hit[2];
+
+                    // check for possible miss
+                    const hit_angle_cos = -v3_dot(
+                        surface_normal_x, surface_normal_y, surface_normal_z,
+                        ray_direction[0], ray_direction[1], ray_direction[2]
+                    );
+
+                    const resolution_bias_offset = max_depth * texel_uv_scale;
 
-                const hit_normal_bias = clamp01(1 - hit_angle_cos) * (resolution_bias_offset) + NORMAL_BIAS;
+                    const hit_normal_bias = CONSTANT_NORMAL_BIAS;
 
-                // sink the contact into the surface along the hit normal
-                const biased_hit_x = surface_position_x - surface_normal_x * hit_normal_bias;
-                const biased_hit_y = surface_position_y - surface_normal_y * hit_normal_bias;
-                const biased_hit_z = surface_position_z - surface_normal_z * hit_normal_bias;
+                    // sink the contact into the surface along the hit normal
+                    const biased_hit_x = surface_position_x + surface_normal_x * hit_normal_bias;
+                    const biased_hit_y = surface_position_y + surface_normal_y * hit_normal_bias;
+                    const biased_hit_z = surface_position_z + surface_normal_z * hit_normal_bias;
 
-                distance = v3_distance(
-                    scratch_ray[0], scratch_ray[1], scratch_ray[2],
-                    biased_hit_x, biased_hit_y, biased_hit_z
+                    distance = v3_distance(
+                        scratch_ray[0], scratch_ray[1], scratch_ray[2],
+                        biased_hit_x, biased_hit_y, biased_hit_z
+                    );
+
+                    // distance += resolution_bias_offset;
+                }
+
+                const direction_dot_product = v3_dot_array_array(ray_direction, 0, probe_direction, 0);
+
+                const weight = Math.pow(
+                    max2(0,
+                        direction_dot_product
+                    ),
+                    DEPTH_SHARPNESS
                 );
 
-                // distance += resolution_bias_offset;
+                distance_sum += distance * weight;
+                distance2_sum += distance * distance * weight;
+                weight_sum += weight;
             }
 
             const pixel_index = oct_y * resolution + oct_x;
 
-            result[result_offset + pixel_index] = distance;
+            const address = result_offset + pixel_index * 2;
+
+            result[address] = distance_sum / weight_sum;
+            result[address + 1] = distance2_sum / weight_sum;
         }
     }
 

package/src/engine/graphics/sh3/lpv/probe_volume_to_textures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probe_volume_to_textures.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/probe_volume_to_textures.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,6EAHW,MAAM,EAAE,eACR,MAAM,QAiChB;AAGD;;;;;;GAMG;AACH,2DALW,oBAAoB,UACpB,MAAM,EAAE,eACR,MAAM,eACN,MAAM,QAiBhB;qCAhEoC,uCAAuC"}
+{"version":3,"file":"probe_volume_to_textures.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/probe_volume_to_textures.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,6EAHW,MAAM,EAAE,eACR,MAAM,QAqChB;AAGD;;;;;;GAMG;AACH,2DALW,oBAAoB,UACpB,MAAM,EAAE,eACR,MAAM,eACN,MAAM,QAiBhB;qCApEoC,uCAAuC"}

package/src/engine/graphics/sh3/lpv/probe_volume_to_textures.js

@@ -27,14 +27,18 @@ export function octahedral_depth_to_atlas(lpv, atlas_data, atlas_width) {
 
                 const tile_pixel_index = pixel_y * tile_resolution + pixel_x;
 
-                const source_value = probe_depth[source_offset + tile_pixel_index];
+                const source_pixel_index = source_offset + tile_pixel_index;
+                const source_pixel_address = source_pixel_index * 2;
 
                 const target_pixel_x = tile_x * tile_resolution + pixel_x;
                 const target_pixel_y = tile_y * tile_resolution + pixel_y;
 
                 const target_pixel_index = target_pixel_y * atlas_width + target_pixel_x;
 
-                atlas_data[target_pixel_index] = source_value;
+                const target_pixel_address = target_pixel_index * 2;
+
+                atlas_data[target_pixel_address] = probe_depth[source_pixel_address];
+                atlas_data[target_pixel_address + 1] = probe_depth[source_pixel_address + 1];
             }
         }
     }

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

@@ -411,9 +411,6 @@ function* render(target, pt, camera, scene, progress = { current: 0, total: 0 })
     const pixel_accummulation = [];
     const ray = new Ray3();
 
-    const ray_origin = new Vector3();
-    const ray_direction = new Vector3();
-
     const width = target.width;
     const height = target.height;
 
@@ -467,16 +464,12 @@ function* render(target, pt, camera, scene, progress = { current: 0, total: 0 })
 
                     for (let i = 0; i < pixel_sample_count; i++) {
 
-                        Camera.projectRay(camera,
+                        ray.projectFromCamera(
                             _x + random() * pixel_scale_x * 2,
                             _y + random() * pixel_scale_y * 2,
-                            ray_origin, ray_direction
-                        );
-
-                        ray3_array_compose(
-                            ray,
-                            ray_origin.x, ray_origin.y, ray_origin.z,
-                            ray_direction.x, ray_direction.y, ray_direction.z
+                            0.5,
+                            camera.matrixWorld.elements,
+                            camera.projectionMatrixInverse.elements
                         );
 
                         ray.tMax = Infinity;
@@ -542,8 +535,8 @@ async function start_renderer(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_attic_scene(scene, camera);
+    await prepare_sponza(scene, camera);
+    // await prepare_attic_scene(scene, camera);
     // await prepare_scene_gltf({scene, camera, path, url: path});
 
 

package/src/engine/graphics/sh3/prototypeSH3Probe.js

@@ -245,7 +245,7 @@ async function getVolume({
         engine,
         ecd,
         bounds: mesh_bounds,
-        density: 5000
+        density: 500
     });
 
     const buffer = new BinaryBuffer();
@@ -385,10 +385,10 @@ async function main(engine) {
     // const path = 'data/models/sibenik/3-window-less/model.gltf';
     // const path = 'data/models/samples/gi_box_01/model.glb';
     // const path = 'data/models/sponza-pbr/gltf/sponza.glb';
-    // const path = 'data/models/pica_pica/pica_pica.gltf';
+    const path = 'data/models/pica_pica/pica_pica.gltf';
     // const path = 'data/models/samples/susanne.glb';
     // const path = 'data/models/samples/teapot.gltf';
-    const path = 'data/models/samples/salle_de_bain/model.glb';
+    // const path = 'data/models/samples/salle_de_bain/model.glb';
     // const path = 'data/models/samples/conference/model-no-curtains.glb';
 
     const mesh_asset = await engine.assetManager.promise(path, 'model/gltf+json');
@@ -449,7 +449,7 @@ async function main(engine) {
 
 
     const camera = ecd.getAnyComponent(Camera);
-    camera.component.clip_far = max2(100, model_footprint);
+    camera.component.clip_far = max2(100, model_footprint * 3);
     const camera_controller = ecd.getComponent(camera.entity, TopDownCameraController);
     camera_controller.distanceMax = model_footprint * 2;
     camera_controller.distanceMin = min2(camera_controller.distanceMin, model_footprint * 0.01);