@woosh/meep-engine 2.109.16 → 2.109.19

package/src/engine/graphics/sh3/lpv/LightProbeVolume.d.ts

@@ -12,6 +12,11 @@ export class LightProbeVolume {
     get mesh(): TetrahedralMesh;
     get points(): number[];
     get harmonics(): number[];
+    /**
+     *
+     * @param {number} v
+     */
+    set depth_map_resolution(arg: number);
     get depth_map_resolution(): number;
     get depth(): number[];
     set count(arg: number);

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

@@ -1 +1 @@
-{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH;IAiCI,sBAEC;IAED,cAkBC;IAED;;;OAGG;IACH,4BAEC;IAED,uBAEC;IAED,0BAEC;IAED,mCAEC;IAED,sBAEC;IAMD,uBAEC;IAND,oBAEC;IAMD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAgBhB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAIhB;IAED;;OAEG;IACH,mBAaC;IAGD;;;;;OAKG;IACH,mCAJW,MAAM,GAEJ,UAAU,CAsBtB;IAGD,yBAEC;;CAEJ;gCAvL+B,wDAAwD;2BAC7D,mCAAmC"}
+{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH;IAiCI,sBAEC;IAED,cAkBC;IAED;;;OAGG;IACH,4BAEC;IAED,uBAEC;IAED,0BAEC;IAMD;;;OAGG;IACH,sCAIC;IAZD,mCAEC;IAYD,sBAEC;IAMD,uBAEC;IAND,oBAEC;IAMD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAgBhB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAIhB;IAED;;OAEG;IACH,mBAaC;IAGD;;;;;OAKG;IACH,mCAJW,MAAM,GAEJ,UAAU,CAsBtB;IAGD,yBAEC;;CAEJ;gCAjM+B,wDAAwD;2BAC7D,mCAAmC"}

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

@@ -1,3 +1,4 @@
+import { assert } from "../../../../core/assert.js";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import {
     compute_delaunay_tetrahedral_mesh
@@ -89,6 +90,16 @@ export class LightProbeVolume {
         return this.#probe_depth_resolution;
     }
 
+    /**
+     *
+     * @param {number} v
+     */
+    set depth_map_resolution(v) {
+        assert.isNonNegativeInteger(v, 'v');
+
+        this.#probe_depth_resolution = v;
+    }
+
     get depth() {
         return this.#probe_depth;
     }

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

@@ -46,7 +46,7 @@ export class LightProbeVolumeBaker {
 
             const depth_resolution = lpv.depth_map_resolution;
 
-            const probe_element_count = depth_resolution * depth_resolution * 2;
+            const probe_element_count = depth_resolution * depth_resolution;
 
             renderer.bake_depth_octahedral(
                 depth_resolution,

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":"AA2BA;;;;;;;;;GASG;AACH,kDARW,MAAM,EAAE,iBACR,MAAM,oCAEN,MAAM,EAAE,UAAQ,mBAChB,MAAM,cACN,MAAM,aACN,MAAM,QA+GhB"}
+{"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":"AA6BA;;;;;;;;;GASG;AACH,kDARW,MAAM,EAAE,iBACR,MAAM,oCAEN,MAAM,EAAE,UAAQ,mBAChB,MAAM,cACN,MAAM,aACN,MAAM,QA4HhB"}

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

@@ -6,7 +6,9 @@ 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 { v3_dot_array_array } from "../../../../../../core/geom/vec3/v3_dot_array_array.js";
+import { clamp01 } from "../../../../../../core/math/clamp01.js";
 import { max2 } from "../../../../../../core/math/max2.js";
+import { PI_HALF } from "../../../../../../core/math/PI_HALF.js";
 import { generate_halton_jitter } from "../../../../../../core/math/random/generate_halton_jitter.js";
 
 const scratch_ray = new Ray3();
@@ -21,9 +23,9 @@ const ray_hit = [];
  *
  * @type {number}
  */
-const SUB_SAMPLE_COUNT = 7;
+const SUB_SAMPLE_COUNT = 1;
 
-const DEPTH_SHARPNESS = 1;
+const DEPTH_SHARPNESS = 7;
 
 /**
  *
@@ -46,13 +48,25 @@ 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 NORMAL_BIAS = max_depth * 0.01 + 1e-6;
 
     const ray_direction = scratch_ray.direction;
 
     const probe_direction = new Float32Array(3);
 
-    const texel_uv_scale = 0.5 / (resolution - 1);
+    const texel_uv_scale = 0.5 / (resolution);
 
     const jittered_sub_samples = generate_halton_jitter(SUB_SAMPLE_COUNT);
 
@@ -61,11 +75,14 @@ export function bake_octahedral_depth_map(
         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);
+            // offset position by half a pixel, as we are storing values for pixel centers
+            const u = (oct_x ) / (resolution);
+            const v = (oct_y ) / (resolution);
+
+            // const u = (oct_x + 0.5) / (resolution - 1);
+            // const v = (oct_y + 0.5) / (resolution - 1);
 
             decode_octahedron_to_unit(
                 probe_direction, 0,
@@ -104,14 +121,14 @@ export function bake_octahedral_depth_map(
                         ray_direction[0], ray_direction[1], ray_direction[2]
                     );
 
-                    const resolution_bias_offset = max_depth * texel_uv_scale;
+                    const resolution_bias_offset = max_depth * RESOLUTION_BIAS;
 
-                    const hit_normal_bias = CONSTANT_NORMAL_BIAS;
+                    const hit_normal_bias = clamp01( 1-hit_angle_cos) * (resolution_bias_offset) + 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;
+                    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],
@@ -131,16 +148,14 @@ export function bake_octahedral_depth_map(
                 );
 
                 distance_sum += distance * weight;
-                distance2_sum += distance * distance * weight;
                 weight_sum += weight;
             }
 
             const pixel_index = oct_y * resolution + oct_x;
 
-            const address = result_offset + pixel_index * 2;
+            const address = result_offset + pixel_index;
 
             result[address] = distance_sum / weight_sum;
-            result[address + 1] = distance2_sum / weight_sum;
         }
     }
 

package/src/engine/graphics/sh3/lpv/depth/octahedral/stitching/frag.glsl

@@ -0,0 +1,88 @@
+uniform sampler2D t_texture;
+
+varying vec2 vUv;
+
+float lpv_bilinear_lerp(float v00, float v01, float v10, float v11, vec2 fraction) {
+
+    float x0 = mix(v00, v01, fraction.x);
+    float x1 = mix(v10, v11, fraction.x);
+
+    return mix(x0, x1, fraction.y);
+}
+
+vec3 lpv_bilinear_lerp(vec3 v00, vec3 v01, vec3 v10, vec3 v11, vec2 fraction) {
+
+    vec3 x0 = mix(v00, v01, fraction.x);
+    vec3 x1 = mix(v10, v11, fraction.x);
+
+    return mix(x0, x1, fraction.y);
+}
+
+ivec2 wrapOctahedralTexelCoordinates(const in ivec2 texel, const in int texture_size) {
+    ivec2 wrapped = ((texel % texture_size) + texture_size) % texture_size;
+
+    int fx = (abs(texel.x / texture_size) + int(texel.x < 0));
+    int fy = (abs(texel.y / texture_size) + int(texel.y < 0));
+
+    //    return texel;
+
+    if (((fx ^ fy) & 1) != 0) {
+        return (texture_size - (wrapped + ivec2(1)));
+        //        return ivec2(
+        //            texSize.x - (wrapped.x + 1),
+        //            (wrapped.y - texSize.y + 1)
+        //        );
+        return wrapped;
+    } else {
+        return wrapped;
+    }
+}
+
+
+void main() {
+    int depth_tile_resolution = 4;
+    vec2 depth_tile_resolution_v2 = vec2(depth_tile_resolution);
+
+    vec2 octahedral_uv = vUv;
+
+    vec2 grid = octahedral_uv * depth_tile_resolution_v2 - 0.5;
+
+
+    vec2 gridFrac = fract(grid);
+//    vec2 gridFrac = vec2(0.0);
+
+    ivec2 texel_position = ivec2(floor(grid));
+
+    ivec2 tile_p_00;
+    ivec2 tile_p_01;
+    ivec2 tile_p_10;
+    ivec2 tile_p_11;
+
+        tile_p_00 = texel_position;
+
+
+    //
+    //         tile_p_00 = wrapOctahedralTexelCoordinates(ivec2(floor(grid + vec2(-0.5, -0.5))), depth_tile_resolution);
+    //         tile_p_01 = wrapOctahedralTexelCoordinates(ivec2(floor(grid + vec2(0.5, -0.5))), depth_tile_resolution);
+    //         tile_p_10 = wrapOctahedralTexelCoordinates(ivec2(floor(grid + vec2(-0.5, 0.5))), depth_tile_resolution);
+    //         tile_p_11 = wrapOctahedralTexelCoordinates(ivec2(floor(grid + vec2(0.5, 0.5))), depth_tile_resolution);
+
+    tile_p_00 = wrapOctahedralTexelCoordinates(texel_position , depth_tile_resolution);
+    tile_p_01 = wrapOctahedralTexelCoordinates(texel_position + ivec2(1, 0), depth_tile_resolution);
+    tile_p_10 = wrapOctahedralTexelCoordinates(texel_position + ivec2(0, 1), depth_tile_resolution);
+    tile_p_11 = wrapOctahedralTexelCoordinates(texel_position + ivec2(1, 1), depth_tile_resolution);
+
+
+    vec3 texel_00 = texelFetch(t_texture, tile_p_00, 0).rgb;
+    vec3 texel_01 = texelFetch(t_texture, tile_p_01, 0).rgb;
+    vec3 texel_10 = texelFetch(t_texture, tile_p_10, 0).rgb;
+    vec3 texel_11 = texelFetch(t_texture, tile_p_11, 0).rgb;
+
+    vec3 texel = lpv_bilinear_lerp(
+        texel_00, texel_01,
+        texel_10, texel_11,
+        gridFrac
+    );
+
+    gl_FragColor = vec4(texel, 1.0);
+}

package/src/engine/graphics/sh3/lpv/depth/octahedral/stitching/prototype.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prototype.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prototype.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/engine/graphics/sh3/lpv/depth/octahedral/stitching/prototype.js"],"names":[],"mappings":""}

package/src/engine/graphics/sh3/lpv/depth/octahedral/stitching/prototype.js

@@ -0,0 +1,96 @@
+import { GUI } from "dat.gui";
+import {
+    ClampToEdgeWrapping,
+    DataTexture,
+    DoubleSide,
+    Mesh,
+    NearestFilter,
+    PerspectiveCamera,
+    PlaneBufferGeometry,
+    RGBFormat,
+    Scene,
+    ShaderMaterial,
+    WebGLRenderer
+} from "three";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
+import { float_to_uint8 } from "../../../../../../../core/binary/float_to_uint8.js";
+import { Color } from "../../../../../../../core/color/Color.js";
+import { FrameRunner } from "../../../../../FrameRunner.js";
+import fragment from "./frag.glsl";
+import vertex from "./vert.glsl";
+
+const renderer = new WebGLRenderer();
+
+const camera = new PerspectiveCamera(70, window.innerWidth / window.innerHeight, 0.01, 100);
+camera.position.set(0, 0, -5);
+camera.lookAt(0, 0, 0);
+
+const scene = new Scene();
+
+const geometry = new PlaneBufferGeometry(1, 1,16,16);
+
+const texture = new DataTexture(new Uint8Array([
+    '#000000', '#ff0000', '#00FF00', '#00FFFF',
+    '#f8f8f8', '#FFAAFF', '#ffbc00', '#dd00ff',
+    '#0071ff', '#FFFF00', '#a62c2c', '#ff7c2d',
+    '#c5ff34', '#ffb7b7', '#833d1a', '#7b00ff',
+].map(c => Color.parse(c).toArray().slice(0,3).map(float_to_uint8)).flat()), 4, 4, RGBFormat);
+texture.needsUpdate = true;
+texture.magFilter = NearestFilter;
+texture.minFilter = NearestFilter;
+
+texture.wrapS = ClampToEdgeWrapping;
+texture.wrapT = ClampToEdgeWrapping;
+
+texture.flipY = false;
+
+console.log(texture);
+
+const uniforms = {
+    t_texture: {
+        value: texture
+    },
+    scale: {
+        value: 1
+    },
+    fold: {
+        value: 1
+    }
+};
+scene.add(new Mesh(geometry, new ShaderMaterial({
+    fragmentShader: [fragment].join('\n'),
+    vertexShader: vertex,
+    lights: false,
+    side: DoubleSide,
+    uniforms: uniforms
+})));
+
+new OrbitControls(camera, document.body);
+
+new FrameRunner(() => {
+
+    renderer.render(scene, camera);
+
+}).startup();
+
+document.body.appendChild(renderer.domElement);
+
+window.addEventListener('resize', onWindowResize, false);
+
+function onWindowResize() {
+
+    camera.aspect = window.innerWidth / window.innerHeight;
+    camera.updateProjectionMatrix();
+
+    renderer.pixelRatio = window.devicePixelRatio;
+    renderer.setSize(window.innerWidth, window.innerHeight);
+
+}
+
+onWindowResize();
+
+
+const gui = new GUI();
+
+gui.add(uniforms.scale, 'value').min(0.1).max(3).name('scale');
+gui.add(uniforms.fold, 'value').min(0).max(1).name('fold');

package/src/engine/graphics/sh3/lpv/depth/octahedral/stitching/vert.glsl

@@ -0,0 +1,65 @@
+varying vec3 vNormal;
+varying vec2 vUv;
+
+uniform float scale;
+uniform float fold;
+
+float sign_not_zero(float x) {
+    return x >= 0.0 ? 1.0 : -1.0;
+}
+
+vec2 sign_not_zero(vec2 x) {
+    return vec2(
+        sign_not_zero(x.x),
+        sign_not_zero(x.y)
+    );
+}
+
+vec3 sign_not_zero(vec3 x) {
+    return vec3(
+        sign_not_zero(x.x),
+        sign_not_zero(x.y),
+        sign_not_zero(x.z)
+    );
+}
+vec3 OctaSphereEnc(vec2 coord)
+{
+    coord = (coord - 0.5) * 2.0;
+    vec3 position = vec3(coord.x, 0.0, coord.y);
+    vec2 absolute = abs(position.xz);
+    position.y = 1.0 - absolute.x - absolute.y;
+
+    if (position.y < 0.0)
+    {
+        position.xz = sign(position.xz) * vec2(1.0 - absolute.y, 1.0 - absolute.x);
+    }
+
+    return position;
+}
+
+vec2 VecToSphereOct(vec3 v)
+{
+    float l1norm = abs(v.x) + abs(v.y) + abs(v.z);
+
+    vec2 result = v.xz / l1norm;
+
+    if (v.y < 0.0) {
+        result = (1.0 - abs(result.yx)) * sign_not_zero(result.xy);
+    }
+
+    return result;
+}
+
+void main() {
+
+    vNormal = normalize(normalMatrix * normal);
+    vUv = uv;
+
+    vec3 position_grid = vec3(uv.x, 0.0, uv.y);
+    vec3 position_octa = normalize(OctaSphereEnc(uv));
+
+    vec3 position_morphed = mix(position_grid, position_octa, fold) * scale;
+
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position_morphed, 1.0);
+
+}

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

@@ -1 +1 @@
-{"version":3,"file":"VLPDepthMapVisualisation.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/engine/graphics/sh3/lpv/depth/octahedral/v2/VLPDepthMapVisualisation.js"],"names":[],"mappings":"AA6EA;IAYI;;;;OAIG;IACH,oCAFa,wBAAwB,CAQpC;IAfD,qBAEC;IAeD,gBA4CC;;CAEJ;mBAzIkB,iCAAiC"}
+{"version":3,"file":"VLPDepthMapVisualisation.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/engine/graphics/sh3/lpv/depth/octahedral/v2/VLPDepthMapVisualisation.js"],"names":[],"mappings":"AA8EA;IAYI;;;;OAIG;IACH,oCAFa,wBAAwB,CAQpC;IAfD,qBAEC;IAeD,gBA4CC;;CAEJ;mBAzIkB,iCAAiC"}

package/src/engine/graphics/sh3/lpv/depth/octahedral/v2/VLPDepthMapVisualisation.js

@@ -9,6 +9,7 @@ import {
 import { BinaryDataType } from "../../../../../../../core/binary/type/BinaryDataType.js";
 import { AABB3 } from "../../../../../../../core/geom/3d/aabb/AABB3.js";
 import { aabb3_from_v3_array } from "../../../../../../../core/geom/3d/aabb/aabb3_from_v3_array.js";
+import { v3_length } from "../../../../../../../core/geom/vec3/v3_length.js";
 import Entity from "../../../../../../ecs/Entity.js";
 import { Transform } from "../../../../../../ecs/transform/Transform.js";
 import { ShadedGeometry } from "../../../../../ecs/mesh-v2/ShadedGeometry.js";
@@ -72,7 +73,7 @@ function buffer_geometry_set_bounds_by_aabb3(geometry, bounds) {
     geometry.boundingBox.max.set(bounds.x1, bounds.y1, bounds.z1);
 
     bounds.getCenter(geometry.boundingSphere.center);
-    geometry.boundingSphere.radius = Math.hypot(bounds.getHalfExtentsX(), bounds.getHalfExtentsY(), bounds.getHalfExtentsZ());
+    geometry.boundingSphere.radius = v3_length(bounds.getHalfExtentsX(), bounds.getHalfExtentsY(), bounds.getHalfExtentsZ());
 }
 
 export class VLPDepthMapVisualisation {