@woosh/meep-engine 2.169.1 → 2.169.2

package/src/engine/graphics/geometry/buffered/query/nearest_point_on_triangle_record.js

@@ -0,0 +1,87 @@
+import { tri3_closest_point_barycentric } from "../../../../../core/geom/3d/triangle/tri3_closest_point_barycentric.js";
+import { tri3_compute_normal } from "../../../../../core/geom/3d/triangle/tri3_compute_normal.js";
+import { v3_distance_sqr } from "../../../../../core/geom/vec3/v3_distance_sqr.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const v3_scratch_0 = [];
+
+/**
+ * Leaf step of a "nearest point on mesh" BVH query: find the closest point on one triangle to the
+ * reference point and, if it beats the incumbent, record it into {@link result}.
+ *
+ * This is the entire payload of the leaf case, shared by the two nearest-point traversals we have -
+ * {@link bvh32_geometry_nearest} (over the implicitly-indexed {@link BinaryUint32BVH}) and
+ * {@link query_bvh_geometry_nearest} (over the pointer-node {@link BVH}). The traversals genuinely
+ * differ because the tree layouts differ; the leaf work does not, and used to be a token-identical
+ * copy in both files.
+ *
+ * @param {SurfacePoint3} result written to only when this triangle is closer than {@link best_distance_sqr}
+ * @param {number} triangle_index recorded into `result.index` on improvement
+ * @param {number} best_distance_sqr squared distance of the incumbent nearest point
+ * @param {number} x reference point X
+ * @param {number} y reference point Y
+ * @param {number} z reference point Z
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @returns {number} squared distance to the new nearest point, or {@link best_distance_sqr}
+ * unchanged when this triangle is not an improvement
+ */
+export function nearest_point_on_triangle_record(
+    result,
+    triangle_index,
+    best_distance_sqr,
+    x, y, z,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+
+    tri3_closest_point_barycentric(
+        v3_scratch_0, 0,
+        x, y, z,
+        ax, ay, az,
+        bx, by, bz,
+        cx, cy, cz
+    );
+
+    const u = v3_scratch_0[0];
+    const v = v3_scratch_0[1];
+    const w = 1 - u - v;
+
+    // construct edge
+
+    const contact_x = ax * u + bx * v + cx * w;
+    const contact_y = ay * u + by * v + cy * w;
+    const contact_z = az * u + bz * v + cz * w;
+
+    const distance_to_triangle_sqr = v3_distance_sqr(
+        contact_x, contact_y, contact_z,
+        x, y, z
+    );
+
+    if (distance_to_triangle_sqr >= best_distance_sqr) {
+        return best_distance_sqr;
+    }
+
+    result.position.set(contact_x, contact_y, contact_z);
+
+    tri3_compute_normal(result.normal, 0,
+        ax, ay, az,
+        bx, by, bz,
+        cx, cy, cz
+    );
+
+    result.index = triangle_index;
+
+    return distance_to_triangle_sqr;
+}

package/src/engine/graphics/geometry/buffered/query/query_bvh_geometry_nearest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query_bvh_geometry_nearest.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/query_bvh_geometry_nearest.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;GAWG;AACH,uFARW,MAAM,EAAE,GAAC,YAAY,WACrB,MAAM,EAAE,GAAC,WAAW,GAAC,WAAW,KAChC,MAAM,KACN,MAAM,KACN,MAAM,gBACN,MAAM,GACL,OAAO,CA+KlB"}
+{"version":3,"file":"query_bvh_geometry_nearest.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/query_bvh_geometry_nearest.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;GAWG;AACH,uFARW,MAAM,EAAE,GAAC,YAAY,WACrB,MAAM,EAAE,GAAC,WAAW,GAAC,WAAW,KAChC,MAAM,KACN,MAAM,KACN,MAAM,gBACN,MAAM,GACL,OAAO,CA0IlB"}

package/src/engine/graphics/geometry/buffered/query/query_bvh_geometry_nearest.js

@@ -9,15 +9,8 @@ import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../../../core/collection/S
 import {
     aabb3_unsigned_distance_sqr_to_point
 } from "../../../../../core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
-import { tri3_closest_point_barycentric } from "../../../../../core/geom/3d/triangle/tri3_closest_point_barycentric.js";
-import { tri3_compute_normal } from "../../../../../core/geom/3d/triangle/tri3_compute_normal.js";
-import { v3_distance_sqr } from "../../../../../core/geom/vec3/v3_distance_sqr.js";
+import { nearest_point_on_triangle_record } from "./nearest_point_on_triangle_record.js";
 
-/**
- *
- * @type {number[]}
- */
-const v3_scratch_0 = [];
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
@@ -149,58 +142,21 @@ export function query_bvh_geometry_nearest(
             const b_address = b * 3;
             const c_address = c * 3;
 
-            const ax = positions[a_address];
-            const ay = positions[a_address + 1];
-            const az = positions[a_address + 2];
-
-            const bx = positions[b_address];
-            const by = positions[b_address + 1];
-            const bz = positions[b_address + 2];
-
-            const cx = positions[c_address];
-            const cy = positions[c_address + 1];
-            const cz = positions[c_address + 2];
-
-            tri3_closest_point_barycentric(
-                v3_scratch_0, 0,
+            const distance_to_triangle_sqr = nearest_point_on_triangle_record(
+                result,
+                triangle_index,
+                nearest_distance_sqr,
                 x, y, z,
-                ax, ay, az,
-                bx, by, bz,
-                cx, cy, cz
+                positions[a_address], positions[a_address + 1], positions[a_address + 2],
+                positions[b_address], positions[b_address + 1], positions[b_address + 2],
+                positions[c_address], positions[c_address + 1], positions[c_address + 2]
             );
 
-            const u = v3_scratch_0[0];
-            const v = v3_scratch_0[1];
-            const w = 1 - u - v;
-
-            // construct edge
+            if (distance_to_triangle_sqr < nearest_distance_sqr) {
+                nearest_distance_sqr = distance_to_triangle_sqr;
 
-            const contact_x = ax * u + bx * v + cx * w;
-            const contact_y = ay * u + by * v + cy * w;
-            const contact_z = az * u + bz * v + cz * w;
-
-            const distance_to_triangle_sqr = v3_distance_sqr(
-                contact_x, contact_y, contact_z,
-                x, y, z
-            );
-
-            if (distance_to_triangle_sqr >= nearest_distance_sqr) {
-                continue;
+                got_a_hit = true;
             }
-
-            nearest_distance_sqr = distance_to_triangle_sqr;
-
-            result.position.set(contact_x, contact_y, contact_z);
-
-            tri3_compute_normal(result.normal, 0,
-                ax, ay, az,
-                bx, by, bz,
-                cx, cy, cz
-            );
-
-            result.index = triangle_index;
-
-            got_a_hit = true;
         }
     } while (pointer > stack_top);
 

package/src/engine/graphics/geometry/buffered/read_triangle_vertices.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Read the 3 corner positions of a triangle out of a buffered geometry vertex buffer.
+ *
+ * This encodes the entire vertex-buffer contract of buffered geometry in one place:
+ * <ul>
+ *     <li>index resolution, including implicit (non-indexed) geometry</li>
+ *     <li>interleaved buffer addressing via {@link vertex_offset} / {@link vertex_stride}</li>
+ *     <li>de-quantization of normalized (integer-backed) position data</li>
+ * </ul>
+ *
+ * It exists because that contract was previously spelled out character-for-character in every
+ * BVH leaf handler over buffered geometry - {@link bvh32_geometry_nearest},
+ * {@link bvh32_geometry_raycast} and {@link bvh32_geometry_overlap_clipping_volume} each carried
+ * their own copy, so any change to the interleaving or normalization convention had to be made
+ * in three places.
+ *
+ * Output layout, starting at {@link result_offset}: `ax, ay, az, bx, by, bz, cx, cy, cz`
+ *
+ * @param {number[]|Float64Array|Float32Array} result
+ * @param {number} result_offset
+ * @param {number[]|ArrayLike<number>} vertices
+ * @param {number} vertex_offset Unless you're using an interleaved buffer of some kind, this will be 0
+ * @param {number} vertex_stride Unless you're using an interleaved buffer, this should be 3
+ * @param {boolean} vertex_data_normalized do we need to denormalize vertex data?
+ * @param {number[]|ArrayLike<number>|undefined} indices if this is set to undefined - implicit indexing will be used
+ * @param {number} triangle_index
+ */
+export function read_triangle_vertices(result: number[] | Float64Array | Float32Array, result_offset: number, vertices: number[] | ArrayLike<number>, vertex_offset: number, vertex_stride: number, vertex_data_normalized: boolean, indices: number[] | ArrayLike<number> | undefined, triangle_index: number): void;
+//# sourceMappingURL=read_triangle_vertices.d.ts.map

package/src/engine/graphics/geometry/buffered/read_triangle_vertices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read_triangle_vertices.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/read_triangle_vertices.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+CATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,YACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,kBACpC,MAAM,QAyEhB"}

package/src/engine/graphics/geometry/buffered/read_triangle_vertices.js

@@ -0,0 +1,102 @@
+import { assert } from "../../../../core/assert.js";
+import { typed_array_value_denormalize } from "../../../../core/collection/array/typed/typed_array_value_denormalize.js";
+
+/**
+ * Read the 3 corner positions of a triangle out of a buffered geometry vertex buffer.
+ *
+ * This encodes the entire vertex-buffer contract of buffered geometry in one place:
+ * <ul>
+ *     <li>index resolution, including implicit (non-indexed) geometry</li>
+ *     <li>interleaved buffer addressing via {@link vertex_offset} / {@link vertex_stride}</li>
+ *     <li>de-quantization of normalized (integer-backed) position data</li>
+ * </ul>
+ *
+ * It exists because that contract was previously spelled out character-for-character in every
+ * BVH leaf handler over buffered geometry - {@link bvh32_geometry_nearest},
+ * {@link bvh32_geometry_raycast} and {@link bvh32_geometry_overlap_clipping_volume} each carried
+ * their own copy, so any change to the interleaving or normalization convention had to be made
+ * in three places.
+ *
+ * Output layout, starting at {@link result_offset}: `ax, ay, az, bx, by, bz, cx, cy, cz`
+ *
+ * @param {number[]|Float64Array|Float32Array} result
+ * @param {number} result_offset
+ * @param {number[]|ArrayLike<number>} vertices
+ * @param {number} vertex_offset Unless you're using an interleaved buffer of some kind, this will be 0
+ * @param {number} vertex_stride Unless you're using an interleaved buffer, this should be 3
+ * @param {boolean} vertex_data_normalized do we need to denormalize vertex data?
+ * @param {number[]|ArrayLike<number>|undefined} indices if this is set to undefined - implicit indexing will be used
+ * @param {number} triangle_index
+ */
+export function read_triangle_vertices(
+    result, result_offset,
+    vertices, vertex_offset, vertex_stride,
+    vertex_data_normalized,
+    indices,
+    triangle_index
+) {
+
+    const index3 = triangle_index * 3;
+
+    let a, b, c;
+
+    if (indices !== undefined) {
+        assert.lessThan(index3 + 2, indices.length, 'triangle index overflow, possibly geometry changed but tree was not rebuilt?');
+
+        a = indices[index3];
+        b = indices[index3 + 1];
+        c = indices[index3 + 2];
+    } else {
+        // implicit indices
+        a = index3;
+        b = index3 + 1;
+        c = index3 + 2;
+    }
+
+    const a_address = a * vertex_stride + vertex_offset;
+    const b_address = b * vertex_stride + vertex_offset;
+    const c_address = c * vertex_stride + vertex_offset;
+
+    assert.lessThan(a_address + 2, vertices.length, 'a-vertex overflow');
+    assert.lessThan(b_address + 2, vertices.length, 'b-vertex overflow');
+    assert.lessThan(c_address + 2, vertices.length, 'c-vertex overflow');
+
+    let ax = vertices[a_address];
+    let ay = vertices[a_address + 1];
+    let az = vertices[a_address + 2];
+
+    let bx = vertices[b_address];
+    let by = vertices[b_address + 1];
+    let bz = vertices[b_address + 2];
+
+    let cx = vertices[c_address];
+    let cy = vertices[c_address + 1];
+    let cz = vertices[c_address + 2];
+
+    // denormalize if necessary
+    if (vertex_data_normalized) {
+        ax = typed_array_value_denormalize(ax, vertices);
+        ay = typed_array_value_denormalize(ay, vertices);
+        az = typed_array_value_denormalize(az, vertices);
+
+        bx = typed_array_value_denormalize(bx, vertices);
+        by = typed_array_value_denormalize(by, vertices);
+        bz = typed_array_value_denormalize(bz, vertices);
+
+        cx = typed_array_value_denormalize(cx, vertices);
+        cy = typed_array_value_denormalize(cy, vertices);
+        cz = typed_array_value_denormalize(cz, vertices);
+    }
+
+    result[result_offset] = ax;
+    result[result_offset + 1] = ay;
+    result[result_offset + 2] = az;
+
+    result[result_offset + 3] = bx;
+    result[result_offset + 4] = by;
+    result[result_offset + 5] = bz;
+
+    result[result_offset + 6] = cx;
+    result[result_offset + 7] = cy;
+    result[result_offset + 8] = cz;
+}

package/src/engine/graphics/impostors/octahedral/shader/ImpostorShaderDepthV0.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImpostorShaderDepthV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderDepthV0.js"],"names":[],"mappings":"AA0WA;;;;GAIG;AACH;IACI,cAoCC;CACJ;kCArZ6D,OAAO"}
+{"version":3,"file":"ImpostorShaderDepthV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderDepthV0.js"],"names":[],"mappings":"AAiQA;;;;GAIG;AACH;IACI,cAoCC;CACJ;kCA5S6D,OAAO"}

package/src/engine/graphics/impostors/octahedral/shader/ImpostorShaderDepthV0.js

@@ -1,4 +1,12 @@
 import { GLSL3, NoBlending, RawShaderMaterial, Vector3 } from "three";
+import {
+    GLSL_IMPOSTOR_APPLY_FRAME_XFORM,
+    GLSL_IMPOSTOR_BILINEAR_WEIGHTS,
+    GLSL_IMPOSTOR_BLEND_4_FRAMES,
+    GLSL_IMPOSTOR_COMPUTE_FRAME_XFORM,
+    GLSL_OCTAHEDRAL_GRID
+} from "../../../shaders/chunks/glsl_octahedral_impostor.js";
+import { GLSL_PACKING } from "../../../shaders/chunks/glsl_packing.js";
 
 // Shadow-pass depth material that matches ImpostorShaderV0's surface so the
 // shadow caster silhouette agrees with what the colour pass draws. We need
@@ -56,92 +64,9 @@ const shader_vx = `
     uniform float uFrames;
     uniform bool uIsFullSphere;
 
-    vec2 VecToSphereOct(vec3 pivotToCamera)
-    {
-        vec3 octant = sign(pivotToCamera);
-        float sum = dot(pivotToCamera, octant);
-        vec3 octahedron = pivotToCamera / sum;
-        if (octahedron.y < 0.0) {
-            vec3 absolute = abs(octahedron);
-            octahedron.xz = octant.xz * vec2(1.0 - absolute.z, 1.0 - absolute.x);
-        }
-        return octahedron.xz;
-    }
-
-    vec2 VecToHemiSphereOct(vec3 v)
-    {
-        v.y = max(v.y, 0.001);
-        v = normalize(v);
-        vec3 octant = sign(v);
-        float sum = dot(v, octant);
-        vec3 octahedron = v / sum;
-        return vec2(
-            octahedron.x + octahedron.z,
-            octahedron.z - octahedron.x
-        );
-    }
-
-    vec2 VectorToGrid(vec3 v)
-    {
-        return uIsFullSphere ? VecToSphereOct(v) : VecToHemiSphereOct(v);
-    }
-
-    vec3 OctaSphereDec(vec2 coord)
-    {
-        coord = (coord - 0.5) * 2.0;
-        vec3 p = vec3(coord.x, 0.0, coord.y);
-        vec2 a = abs(p.xz);
-        p.y = 1.0 - a.x - a.y;
-        if (p.y < 0.0) {
-            p.xz = sign(p.xz) * vec2(1.0 - a.y, 1.0 - a.x);
-        }
-        return p;
-    }
-
-    vec3 OctaHemiSphereDec(vec2 coord)
-    {
-        vec3 p = vec3(coord.x - coord.y, 0.0, -1.0 + coord.x + coord.y);
-        vec2 a = abs(p.xz);
-        p.y = 1.0 - a.x - a.y;
-        return p;
-    }
-
-    vec3 GridToVector(vec2 coord)
-    {
-        return uIsFullSphere ? OctaSphereDec(coord) : OctaHemiSphereDec(coord);
-    }
-
-    vec3 FrameToRay(vec2 frame, vec2 framesMinusOne)
-    {
-        vec2 f = clamp(frame / framesMinusOne, 0.0, 1.0);
-        return normalize(GridToVector(f));
-    }
-
-    vec4 ComputeFrameXform(vec3 D_frame, vec3 tangent_OS, vec3 binormal_OS)
-    {
-        vec3 D = abs(D_frame.y) > 0.99999
-                 ? normalize(D_frame + vec3(0.0, 0.0, 0.0001))
-                 : D_frame;
-        vec3 bake_right = normalize(cross(vec3(0.0, 1.0, 0.0), D));
-        vec3 bake_up    = cross(D, bake_right);
-        return vec4(
-            dot(tangent_OS,  bake_right),
-            dot(binormal_OS, bake_right),
-            dot(tangent_OS,  bake_up),
-            dot(binormal_OS, bake_up)
-        );
-    }
-
-    vec4 BilinearWeights(vec2 frac_uv)
-    {
-        vec2 omuv = vec2(1.0) - frac_uv;
-        return vec4(
-            omuv.x * omuv.y,
-            frac_uv.x * omuv.y,
-            omuv.x * frac_uv.y,
-            frac_uv.x * frac_uv.y
-        );
-    }
+${GLSL_OCTAHEDRAL_GRID}
+${GLSL_IMPOSTOR_COMPUTE_FRAME_XFORM}
+${GLSL_IMPOSTOR_BILINEAR_WEIGHTS}
 
     void main() {
         vUv = uv;
@@ -259,43 +184,13 @@ const shader_fg = `
     uniform float uRadius;
     uniform float uDepthScale;
 
-    // Mirrors three.js's packing.glsl chunk so the shadow map reader (PCF
-    // sampler in shadowmap_pars_fragment) can unpack our output.
-    const float PackUpscale = 256.0 / 255.0;
-    const vec3 PackFactors = vec3(256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0);
-    const float ShiftRight8 = 1.0 / 256.0;
-
-    vec4 packDepthToRGBA(const in float v) {
-        vec4 r = vec4(fract(v * PackFactors), v);
-        r.yzw -= r.xyz * ShiftRight8;
-        return r * PackUpscale;
-    }
-
-    vec2 apply_frame_xform(vec2 card_uv, vec4 xform)
-    {
-        vec2 c = card_uv - 0.5;
-        return vec2(
-            xform.x * c.x + xform.y * c.y,
-            xform.z * c.x + xform.w * c.y
-        ) + 0.5;
-    }
+    // three.js's own packing chunk, so the shadow map reader (PCF sampler in
+    // shadowmap_pars_fragment) is guaranteed to unpack exactly what we packed.
+    // RawShaderMaterial does not resolve #include, hence the interpolation.
+${GLSL_PACKING}
 
-    vec4 blend_4_frames(
-        sampler2D tex, vec2 card_uv,
-        vec2 gridFloor, vec4 w,
-        vec4 x00, vec4 x10, vec4 x01, vec4 x11
-    ) {
-        vec2 frame_size = vec2(1.0 / uFrames);
-        vec2 uv00 = clamp(apply_frame_xform(card_uv, x00), 0.0, 1.0);
-        vec2 uv10 = clamp(apply_frame_xform(card_uv, x10), 0.0, 1.0);
-        vec2 uv01 = clamp(apply_frame_xform(card_uv, x01), 0.0, 1.0);
-        vec2 uv11 = clamp(apply_frame_xform(card_uv, x11), 0.0, 1.0);
-        vec4 s00 = texture(tex, (gridFloor + vec2(0.0, 0.0) + uv00) * frame_size);
-        vec4 s10 = texture(tex, (gridFloor + vec2(1.0, 0.0) + uv10) * frame_size);
-        vec4 s01 = texture(tex, (gridFloor + vec2(0.0, 1.0) + uv01) * frame_size);
-        vec4 s11 = texture(tex, (gridFloor + vec2(1.0, 1.0) + uv11) * frame_size);
-        return s00 * w.x + s10 * w.y + s01 * w.z + s11 * w.w;
-    }
+${GLSL_IMPOSTOR_APPLY_FRAME_XFORM}
+${GLSL_IMPOSTOR_BLEND_4_FRAMES}
 
     void main() {
         // Same parallax shift as V0 so the silhouette we test matches the

package/src/engine/graphics/impostors/octahedral/shader/ImpostorShaderLitV0.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImpostorShaderLitV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderLitV0.js"],"names":[],"mappings":"AAssBA;;;;;;;;GAQG;AACH;IACI,cA6BC;CACJ;+BA9uB0E,OAAO"}
+{"version":3,"file":"ImpostorShaderLitV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderLitV0.js"],"names":[],"mappings":"AAmhBA;;;;;;;;GAQG;AACH;IACI,cA6BC;CACJ;+BA3jB0E,OAAO"}