@woosh/meep-engine 3.57.0 → 3.58.0

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometryFlags.d.ts

@@ -7,5 +7,6 @@ export namespace ShadedGeometryFlags {
     let Visible: number;
     let DeferredBoundsUpdate: number;
     let Skinned: number;
+    let SDFWorld: number;
 }
 //# sourceMappingURL=ShadedGeometryFlags.d.ts.map

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometryFlags.js

@@ -49,4 +49,14 @@ export const ShadedGeometryFlags = {
      * Set by the prefab that spawned the primitive; a primitive built by hand is rigid.
      */
     Skinned: 64,
+
+    /**
+     * The primitive is in the SDF world: the rays that trace the scene's distance field — the probe
+     * clipmap's GI — see it, unless its material is transparent. Without it the primitive is drawn
+     * by the camera and invisible to those rays: it occludes nothing, emits nothing and bounces
+     * nothing into GI, which is what it is for — a primitive too small or too busy to be worth its
+     * place there. On by default, as {@link CastShadow} is. Unreal's
+     * `bAffectDistanceFieldLighting` is the same switch.
+     */
+    SDFWorld: 128,
 };

package/src/engine/graphics/ecs/particles/ParticleEffect.js

@@ -3,7 +3,7 @@ import { float32_array_hash } from "../../../../core/collection/array/typed/floa
 import { is_typed_array_equals } from "../../../../core/collection/array/typed/is_typed_array_equals.js";
 import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
 import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
-import { optional_equality } from "../../../../core/model/object/optional_equality.js";
+import { objectsEqual } from "../../../../core/function/objectsEqual.js";
 import { optional_hash } from "../../../../core/model/object/optional_hash.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
@@ -280,8 +280,8 @@ export class ParticleEffect {
             && this.render_frame === other.render_frame
             && this.render_velocity === other.render_velocity
             && is_typed_array_equals(this.flipbook, other.flipbook)
-            && optional_equality(this.layout, other.layout)
-            && optional_equality(this.program, other.program);
+            && objectsEqual(this.layout, other.layout)
+            && objectsEqual(this.program, other.program);
     }
 
     /**

package/src/engine/graphics/ecs/path/tube/build/makeTubeStream.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../../../core/assert.js";
-import { v3_angle_cos_between } from "../../../../../../core/geom/vec3/v3_angle_cos_between.js";
+import { v3_cos_angle } from "../../../../../../core/geom/vec3/v3_cos_angle.js";
 import { v3_length } from "../../../../../../core/geom/vec3/v3_length.js";
 import { CapType } from "../CapType.js";
 import { append_compute_cap_geometry_size, make_cap } from "./make_cap.js";
@@ -188,7 +188,7 @@ function compute_bend_normal(
     const cross_y = d0_z * d1_x - d0_x * d1_z;
     const cross_z = d0_x * d1_y - d0_y * d1_x;
 
-    const angle = v3_angle_cos_between(d0_x, d0_y, d0_z, d1_x, d1_y, d1_z);
+    const angle = v3_cos_angle(d0_x, d0_y, d0_z, d1_x, d1_y, d1_z);
 
     const cross_length = v3_length(cross_x, cross_y, cross_z);
 

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

@@ -1,3 +1,15 @@
+/**
+ * Number of vertices along one axis of a height-field tile.
+ *
+ * A non-empty span needs at least two vertices (one segment) to bound its interval: a 1-cell
+ * partial edge tile at resolution 1 would otherwise have `1 * 1 - 1 = 0` segments, dividing the UV
+ * step by zero (`0 * Infinity = NaN`) and emitting zero triangles.
+ *
+ * @param {number} span tile extent along the axis, in grid cells
+ * @param {number} resolution vertices per grid cell along the axis
+ * @returns {number}
+ */
+export function height_field_axis_vertex_count(span: number, resolution: number): number;
 /**
  *
  * @param {Sampler2D} samplerHeight

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

@@ -1 +1 @@
-{"version":3,"file":"build_height_field_geometry.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/build_height_field_geometry.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,wJAHW,MAAM,GACJ;IAAC,OAAO,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,YAAY,CAAC;IAAC,GAAG,EAAE,YAAY,CAAA;CAAC,CA0GvF"}
+{"version":3,"file":"build_height_field_geometry.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/build_height_field_geometry.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,qDAJW,MAAM,cACN,MAAM,GACJ,MAAM,CAOlB;AAED;;;;;;;;;GASG;AACH,wJAHW,MAAM,GACJ;IAAC,OAAO,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,YAAY,CAAC;IAAC,GAAG,EAAE,YAAY,CAAA;CAAC,CAiHvF"}

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

@@ -1,6 +1,26 @@
+import { assert } from "../../../../core/assert.js";
 import { UintArrayForCount } from "../../../../core/collection/array/typed/uint_array_for_count.js";
+import { max2 } from "../../../../core/math/max2.js";
 import { geometry_compute_vertex_normals_indexed } from "./geometry_compute_vertex_normals_indexed.js";
 
+/**
+ * Number of vertices along one axis of a height-field tile.
+ *
+ * A non-empty span needs at least two vertices (one segment) to bound its interval: a 1-cell
+ * partial edge tile at resolution 1 would otherwise have `1 * 1 - 1 = 0` segments, dividing the UV
+ * step by zero (`0 * Infinity = NaN`) and emitting zero triangles.
+ *
+ * @param {number} span tile extent along the axis, in grid cells
+ * @param {number} resolution vertices per grid cell along the axis
+ * @returns {number}
+ */
+export function height_field_axis_vertex_count(span, resolution) {
+    assert.greaterThan(span, 0, 'span');
+    assert.greaterThan(resolution, 0, 'resolution');
+
+    return max2(2, span * resolution);
+}
+
 /**
  *
  * @param {Sampler2D} samplerHeight
@@ -12,13 +32,20 @@ import { geometry_compute_vertex_normals_indexed } from "./geometry_compute_vert
  * @returns {{indices, vertices: Float32Array, normals: Float32Array, uvs: Float32Array}}
  */
 export function build_height_field_geometry(samplerHeight, position, size, scale, totalSize, resolution) {
+    assert.defined(samplerHeight, 'samplerHeight');
+    assert.defined(position, 'position');
+    assert.defined(size, 'size');
+    assert.defined(scale, 'scale');
+    assert.defined(totalSize, 'totalSize');
+    assert.greaterThan(totalSize.x, 0, 'totalSize.x');
+    assert.greaterThan(totalSize.y, 0, 'totalSize.y');
 
     const width = size.x;
     const height = size.y;
 
 
-    const gridX1 = width * resolution;
-    const gridY1 = height * resolution;
+    const gridX1 = height_field_axis_vertex_count(width, resolution);
+    const gridY1 = height_field_axis_vertex_count(height, resolution);
 
     const gridX2 = gridX1 - 1;
     const gridY2 = gridY1 - 1;

package/src/engine/graphics/texture/sprite/prototypeSpriteCutoutGeometry.js

@@ -105,7 +105,7 @@ async function main(engine) {
     console.time('optimal poly');
     const optimal_poly_points = 8;
     const optimal_poly = new Float32Array(optimal_poly_points * 2);
-    // fixed_convex_hull_relaxation(optimal_poly, 0, optimal_poly_points, convex_hull_vertices, convex_hull_point_count);
+    // convex_hull_fixed_count_2d_relaxation(optimal_poly, 0, optimal_poly_points, convex_hull_vertices, convex_hull_point_count);
     convex_hull_fixed_count_2d_bruteforce(optimal_poly, 0, optimal_poly_points, convex_hull_vertices, convex_hull_point_count);
     console.timeEnd('optimal poly');
 

package/src/engine/graphics3/ShadedGeometrySystem.d.ts

@@ -14,7 +14,8 @@
  * entities (a prefab); this system never sees the file, only the primitives that came out of it,
  * and cannot tell them from primitives some tool built by hand. A primitive a skin deforms says so
  * on its component ({@link ShadedGeometryFlags.Skinned}) and draws a per-instance clone the
- * skinning pass writes; the skin itself is the model's business.
+ * skinning pass writes; the skin itself is the model's business. Whether the scene's distance field
+ * sees it says so there too ({@link ShadedGeometryFlags.SDFWorld}), and goes to its row the same way.
  *
  * **A primitive holds the rows of everything it hangs from** ({@link RowChains}). Under a parent
  * with no row it would carry its CPU world under the scene root, which stops moving the moment a

package/src/engine/graphics3/ShadedGeometrySystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadedGeometrySystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ShadedGeometrySystem.js"],"names":[],"mappings":"AAgDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAwCI;;;OAGG;IACH,sBAHW,cAAc,SACd,KAAK,EAYf;IADG,6DAAiD;IAGrD;;OAEG;IACH,iEAEC;IAED,2CAeC;IAED,4CAUC;IA4CD;;;;OAIG;IACH,eAJW,cAAc,aACd,WAAW,UACX,MAAM,QAgDhB;IAED;;;;OAIG;IACH,iBAJW,cAAc,aACd,WAAW,UACX,MAAM,QAOhB;;CAsDJ;8BA9TY,OAAO,+CAA+C,EAAE,eAAe;6BACvE,OAAO,qBAAqB,EAAE,cAAc;oBAC5C,OAAO,qCAAqC,EAAE,KAAK;uBAXzC,kBAAkB;4BACb,iCAAiC;+BAG9B,2CAA2C"}
+{"version":3,"file":"ShadedGeometrySystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ShadedGeometrySystem.js"],"names":[],"mappings":"AAgDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAwCI;;;OAGG;IACH,sBAHW,cAAc,SACd,KAAK,EAYf;IADG,6DAAiD;IAGrD;;OAEG;IACH,iEAEC;IAED,2CAeC;IAED,4CAUC;IA4CD;;;;OAIG;IACH,eAJW,cAAc,aACd,WAAW,UACX,MAAM,QAgDhB;IAED;;;;OAIG;IACH,iBAJW,cAAc,aACd,WAAW,UACX,MAAM,QAOhB;;CAuDJ;8BAhUY,OAAO,+CAA+C,EAAE,eAAe;6BACvE,OAAO,qBAAqB,EAAE,cAAc;oBAC5C,OAAO,qCAAqC,EAAE,KAAK;uBAXzC,kBAAkB;4BACb,iCAAiC;+BAG9B,2CAA2C"}

package/src/engine/graphics3/ShadedGeometrySystem.js

@@ -62,7 +62,8 @@ class Entry {
  * entities (a prefab); this system never sees the file, only the primitives that came out of it,
  * and cannot tell them from primitives some tool built by hand. A primitive a skin deforms says so
  * on its component ({@link ShadedGeometryFlags.Skinned}) and draws a per-instance clone the
- * skinning pass writes; the skin itself is the model's business.
+ * skinning pass writes; the skin itself is the model's business. Whether the scene's distance field
+ * sees it says so there too ({@link ShadedGeometryFlags.SDFWorld}), and goes to its row the same way.
  *
  * **A primitive holds the rows of everything it hangs from** ({@link RowChains}). Under a parent
  * with no row it would carry its CPU world under the scene root, which stops moving the moment a
@@ -235,9 +236,9 @@ export class ShadedGeometrySystem extends System {
             }
         };
 
-        // The component changed in place — a material swapped, most often — and the row is
-        // rewritten from it. Same geometry, same clone: a skinned primitive fading out keeps the
-        // vertex region the skinning pass is deforming.
+        // The component changed in place — a material swapped, most often, or a flag the row carries
+        // flipped — and the row is rewritten from it. Same geometry, same clone: a skinned primitive
+        // fading out keeps the vertex region the skinning pass is deforming.
         entry.on_changed = () => {
             if (entry.context !== null) {
                 this.#attach(entry, entry.context);
@@ -287,7 +288,8 @@ export class ShadedGeometrySystem extends System {
             entry.entity,
             geometry.geometry,
             geometry.material,
-            geometry.getFlag(ShadedGeometryFlags.Skinned)
+            geometry.getFlag(ShadedGeometryFlags.Skinned),
+            geometry.getFlag(ShadedGeometryFlags.SDFWorld)
         );
 
         entry.context = context;

package/src/engine/graphics3/Trail3DSystem.d.ts

@@ -67,7 +67,7 @@ export class Trail3DSystem extends System<any> {
  * it — see the class's own doc. This is the extension the system used to register at
  * `AfterTransparency`; it records nothing now, and registering it draws nothing.
  *
- * Kept rather than removed for the reason `Trail3DSystem3` is: this is a library, and an import that
+ * Kept rather than removed: this is a library, and an import that
  * stops linking stops the whole application loading, not just its trails. It warns once, when first
  * constructed, and is the removal candidate for the next major.
  */

package/src/engine/graphics3/Trail3DSystem.js

@@ -187,7 +187,7 @@ let trail_extension_deprecation_warned = false;
  * it — see the class's own doc. This is the extension the system used to register at
  * `AfterTransparency`; it records nothing now, and registering it draws nothing.
  *
- * Kept rather than removed for the reason `Trail3DSystem3` is: this is a library, and an import that
+ * Kept rather than removed: this is a library, and an import that
  * stops linking stops the whole application loading, not just its trails. It warns once, when first
  * constructed, and is the removal candidate for the next major.
  */

package/src/engine/graphics3/WaterSystem.d.ts

@@ -15,6 +15,12 @@
  * ({@link GPUFluidSystem#far_field}) is not still. Asked every update, allocating nothing.
  */
 export class WaterSystem extends System<any> {
+    /**
+     * Offer the compute pipelines the water surface query API dispatches.
+     *
+     * @param {import("../../shade/device/pipeline/PipelineEnquiry.js").PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: import("../../shade/device/pipeline/PipelineEnquiry.js").PipelineEnquiry): void;
     constructor(graphics: any, scene: any);
     dependencies: (typeof Transform64 | typeof MeshletGeometry | typeof Water)[];
     components_used: (ResourceAccessSpecification<typeof WaterWaves> | ResourceAccessSpecification<typeof GPUFluidComponent>)[];
@@ -36,6 +42,25 @@ export class WaterSystem extends System<any> {
     request_probe(uv: any): Promise<any>;
     set time(seconds: number);
     get time(): number;
+    /**
+     * What became of each surface query request, by handle: a `GPUReadbackStatus`. `Pending` from
+     * {@link request_local} / {@link request_world} until the apply point ({@link update}) that
+     * answers it, `Delivered` (the samples are unpacked in `target`) or `Dropped` (the target is as
+     * it was) from there until the next apply point, then `None`, the handle recycled.
+     *
+     * Read it fresh each time rather than keeping a reference: the array is replaced when the
+     * handle space grows.
+     *
+     * @returns {Uint8Array}
+     */
+    get status(): Uint8Array;
+    /**
+     * The surface read API's device half, or null before the first frame with a request on a
+     * device. For inspection.
+     *
+     * @returns {GPUWaterQueries|null}
+     */
+    get queries(): GPUWaterQueries;
     startup(entityManager: any): Promise<void>;
     shutdown(): Promise<void>;
     link(water: any, geometry: any, transform: any, entity: any): void;
@@ -47,6 +72,40 @@ export class WaterSystem extends System<any> {
      * position is interpreted in the CPU-owned pose; queued on the CPU and spent on the GPU, sixteen a body a frame.
      */
     splash(entity: any, position: any, radius: any, strength: any): void;
+    /**
+     * Ask for the water surface height and world-space unit normal at `count` points in the water
+     * body's local `(x, z)` plane: `local_xz` holds `[x0, z0, x1, z1, ...]`, and each sample lands
+     * in `target` from `target_offset` as {@link WATER_QUERY_SAMPLE_FLOATS} (4) floats,
+     * `[world_height, nx, ny, nz]`, unpacked on the CPU when the request settles `Delivered` at a
+     * later apply point ({@link update}); see {@link status}.
+     *
+     * Points outside the body's authored outline or inside island holes are clamped continuously to
+     * the nearest point on the mesh's triangles so no `NaN`s are ever produced.
+     *
+     * @param {number} entity water entity
+     * @param {ArrayLike<number>} local_xz interleaved `[x0, z0, x1, z1, ...]` in local body coordinates
+     * @param {number} count number of `(x, z)` points, at least 1
+     * @param {number} footprint spatial filter footprint in metres, at least 0 (0 resolves all wavelengths)
+     * @param {Float32Array} target memory the caller owns and keeps until the request settles
+     * @param {number} target_offset in floats
+     * @returns {number} a handle into {@link status}
+     */
+    request_local(entity: number, local_xz: ArrayLike<number>, count: number, footprint: number, target: Float32Array, target_offset: number): number;
+    /**
+     * Ask for the water surface height and world-space unit normal at `count` points in world
+     * space: `world_xyz` holds `[x0, y0, z0, x1, y1, z1, ...]`. Internally transforms each world
+     * point into the water body's local `(x, z)` plane via the inverse of its CPU-owned
+     * `Transform64` and delegates to {@link request_local}.
+     *
+     * @param {number} entity water entity
+     * @param {ArrayLike<number>} world_xyz interleaved `[x0, y0, z0, ...]` in world metres
+     * @param {number} count number of `(x, y, z)` points, at least 1
+     * @param {number} footprint spatial filter footprint in metres, at least 0 (0 resolves all wavelengths)
+     * @param {Float32Array} target memory the caller owns and keeps until the request settles
+     * @param {number} target_offset in floats
+     * @returns {number} a handle into {@link status}
+     */
+    request_world(entity: number, world_xyz: ArrayLike<number>, count: number, footprint: number, target: Float32Array, target_offset: number): number;
     record_surface(frame: any): void;
     record(frame: any): void;
     #private;
@@ -70,5 +129,6 @@ import { ResourceAccessSpecification } from "../../core/model/ResourceAccessSpec
 import { GPUFluidComponent } from "../physics/fluid/ecs/GPUFluidComponent.js";
 import { GPUWaterSurface } from "../../shade/renderer/water/surface/GPUWaterSurface.js";
 import { GPUWaterRenderer } from "../../shade/renderer/water/GPUWaterRenderer.js";
+import { GPUWaterQueries } from "../../shade/renderer/water/query/GPUWaterQueries.js";
 import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
 //# sourceMappingURL=WaterSystem.d.ts.map

package/src/engine/graphics3/WaterSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/WaterSystem.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;GAeG;AACH;IAoCI,uCAaC;IAhDD,6EAAqD;IACrD,4HAEkF;IAqBlF;;;;;;;;;;;MAAkD;IAClD,6BAAmC;IACnC,6CAAqD;IACrD,iBAAmC;IACnC,qCAA8D;IAE9D,0BAGC;IAJD,mBAAiC;IAqBjC,2CAOC;IAED,0BAMC;IAED,mEAsBC;IAQD,qEAiBC;IAED,sBAqBC;IA0ED;;;;OAIG;IACH,qEAUC;IAED,iCAMC;IACD,yBAGC;;CACJ;AAED;IAEI,yBAAsD;IAAvB,YAAoB;IACnD,yBAA4C;CAC/C;AACD;IAEI,yBAAsD;IAAvB,YAAoB;IACnD,yBAAoD;CACvD;uBAzSsB,kBAAkB;4BAEb,iCAAiC;gCAI7B,kDAAkD;kBARhE,gCAAgC;uBACe,qCAAqC;4CAS1D,iDAAiD;kCAW3D,2CAA2C;gCAR7C,uDAAuD;iCAFtD,gDAAgD;gCAIjD,mDAAmD"}
+{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/WaterSystem.js"],"names":[],"mappings":"AAsDA;;;;;;;;;;;;;;;GAeG;AACH;IAEI;;;;OAIG;IACH,iCAFW,OAAO,gDAAgD,EAAE,eAAe,QAIlF;IAsGD,uCAaC;IAjHD,6EAAqD;IACrD,4HAEkF;IA6DlF;;;;;;;;;;;MAAkD;IAClD,6BAAmC;IACnC,6CAAqD;IACrD,iBAAmC;IACnC,qCAA8D;IAE9D,0BAGC;IAJD,mBAAiC;IAMjC;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,+BAEC;IAiBD,2CAOC;IAED,0BAOC;IAED,mEAsBC;IAQD,qEAiBC;IAED,sBA+BC;IA0ED;;;;OAIG;IACH,qEAUC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,sBARW,MAAM,YACN,UAAU,MAAM,CAAC,SACjB,MAAM,aACN,MAAM,UACN,YAAY,iBACZ,MAAM,GACJ,MAAM,CA+ClB;IAED;;;;;;;;;;;;;OAaG;IACH,sBARW,MAAM,aACN,UAAU,MAAM,CAAC,SACjB,MAAM,aACN,MAAM,UACN,YAAY,iBACZ,MAAM,GACJ,MAAM,CAgClB;IAuND,iCAQC;IACD,yBAGC;;CACJ;AAED;IAEI,yBAAsD;IAAvB,YAAoB;IACnD,yBAA4C;CAC/C;AACD;IAEI,yBAAsD;IAAvB,YAAoB;IACnD,yBAAoD;CACvD;uBA1tBsB,kBAAkB;4BAEb,iCAAiC;gCAI7B,kDAAkD;kBARhE,gCAAgC;uBACe,qCAAqC;4CAS1D,iDAAiD;kCAa3D,2CAA2C;gCAT7C,uDAAuD;iCAHtD,gDAAgD;gCAEtB,qDAAqD;gCAGhF,mDAAmD"}