@woosh/meep-engine 3.39.0 → 3.40.0

package/src/engine/graphics/texture/sampler/sampler2d_to_avif.js

@@ -1,7 +1,6 @@
 import { MC_BT_709, TC_SMPTE_2084 } from "../../../../format/image/avif/av1/tables/av1_symbols.js";
 import { SDR_WHITE_NITS } from "../../../../core/color/PQ/PQ_constants.js";
 import { SUBSAMPLING_420, SUBSAMPLING_422, encode_avif } from "../../../../format/image/avif/api/encode_avif.js";
-import { half_to_float_uint16 } from "../../../../core/binary/half_to_float_uint16.js";
 
 /**
  * Encode a sampler as an AVIF file.
@@ -31,7 +30,7 @@ export function sampler2d_to_avif(sampler, quality = 0.75, options = {}, encoder
 
     const data = sampler.data;
 
-    const hdr = data instanceof Uint16Array;
+    const hdr = data instanceof Float16Array || data instanceof Uint16Array;
 
     const rgba = to_rgba(data, item_size, width, height, hdr);
 
@@ -58,7 +57,7 @@ export function sampler2d_to_avif(sampler, quality = 0.75, options = {}, encoder
 /**
  * Expand a sampler's samples to interleaved RGBA of the kind the encoder takes.
  *
- * @param {Uint8Array|Uint8ClampedArray|Uint16Array|Float32Array|Float64Array} data
+ * @param {Uint8Array|Uint8ClampedArray|Uint16Array|Float16Array|Float32Array|Float64Array} data
  * @param {number} item_size
  * @param {number} width
  * @param {number} height
@@ -69,6 +68,10 @@ function to_rgba(data, item_size, width, height, hdr) {
     const count = width * height;
 
     if (hdr) {
+        // Keep accepting packed binary16 samplers while reading native halves as numbers.
+        const values = data instanceof Uint16Array
+            ? new Float16Array(data.buffer, data.byteOffset, data.length)
+            : data;
         const out = new Float32Array(count * 4);
 
         for (let i = 0; i < count; i++) {
@@ -76,12 +79,12 @@ function to_rgba(data, item_size, width, height, hdr) {
             const destination = i * 4;
 
             for (let c = 0; c < 3; c++) {
-                const value = c < item_size ? half_to_float_uint16(data[source + c]) : 0;
+                const value = c < item_size ? values[source + c] : 0;
 
                 out[destination + c] = Math.max(value, 0);
             }
 
-            out[destination + 3] = item_size > 3 ? Math.min(Math.max(half_to_float_uint16(data[source + 3]), 0), 1) : 1;
+            out[destination + 3] = item_size > 3 ? Math.min(Math.max(values[source + 3], 0), 1) : 1;
         }
 
         return out;

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

@@ -1,18 +1,11 @@
 /**
- * Draws the level's water under Shade.
- *
- * Water is a shared AVBOIT side channel. The extension is debug presentation only; normal frames
- * composite water exactly once alongside particles, meshlets and trails in AVBOIT's resolve.
- *
- * Registration does not wait for a device. `GraphicsEngine` holds extensions and applies them
- * to the renderer when one exists and again after a restart (E9, §4.8).
+ * Registers [Water, MeshletGeometry, Transform64] in the scene's existing GPU database. Authored
+ * edits queue writes; idle frames never walk bodies. Transform rows follow the same change events
+ * and GPU hierarchy as shaded geometry. Water does not enter the opaque mesh table or its TLAS.
  */
 export class WaterSystem extends System<any> {
-    /**
-     * @param {GraphicsEngine} graphics
-     */
-    constructor(graphics: GraphicsEngine);
-    dependencies: (typeof Water)[];
+    constructor(graphics: any, scene: any);
+    dependencies: (typeof Transform64 | typeof MeshletGeometry | typeof Water)[];
     components_used: ResourceAccessSpecification<typeof WaterWaves>[];
     get settings(): {
         enabled: boolean;
@@ -24,84 +17,38 @@ export class WaterSystem extends System<any> {
         reflections: number;
         debug_view: number;
         inscatter_segments: number;
+        tessellation_pixels: number;
     };
-    /** The surface producer, for settings such as its grid resolution. */
     get waves(): GPUWaterWaveSimulation;
-    /** The registered channel, for diagnostics such as testing registration order. */
     get transparency_channel(): GPUWaterRenderer;
+    get scene(): any;
     request_probe(uv: any): Promise<any>;
     set time(seconds: number);
     get time(): number;
-    /**
-     * What the pass draws. Read-only — the surfaces follow the entities, and a harness that wants
-     * one gone takes its component off.
-     *
-     * @returns {WaterSurface[]}
-     */
-    get surfaces(): WaterSurface[];
     startup(entityManager: any): Promise<void>;
-    shutdown(entityManager: any): Promise<void>;
-    /**
-     * @param {FrameContext} frame
-     */
-    record(frame: FrameContext): void;
-    /**
-     * Record the surface producer: this frame's wave steps and the surface interface every water
-     * pass reads. At the head of the frame, so everything that reads it is recorded after.
-     *
-     * @param {FrameContext} frame
-     */
-    record_surface(frame: FrameContext): void;
-    /**
-     * Kick the surface of an entity's water, as a boat or a splash would: a vertical velocity
-     * `strength` m/s at `position`, falling off over `radius` m. Applied on the next frame that
-     * steps; at most {@link WATER_WAVE_IMPULSE_LIMIT} a frame per body, the rest wait for the
-     * following frames.
-     *
-     * @param {number} entity the entity carrying the {@link Water}
-     * @param {number[]} position world x, y, z; y is ignored
-     * @param {number} radius m
-     * @param {number} strength m/s, positive upwards
-     */
-    splash(entity: number, position: number[], radius: number, strength: number): void;
-    /**
-     * @param {Water} water
-     * @param {number} entity
-     */
-    link(water: Water, entity: number): void;
-    /**
-     * @param {Water} water
-     * @param {number} entity
-     */
-    unlink(water: Water, entity: number): void;
-    update(timeDelta: any): void;
+    shutdown(): Promise<void>;
+    link(water: any, geometry: any, transform: any, entity: any): void;
+    unlink(water: any, geometry: any, transform: any, entity: any): void;
+    update(dt: any): void;
+    /** World-space radius and velocity kick; position is interpreted in the CPU-owned pose. */
+    splash(entity: any, position: any, radius: any, strength: any): void;
+    record_surface(frame: any): void;
+    record(frame: any): void;
     #private;
 }
-/**
- * Opt-in water inspection after temporal processing. Kept under the exported name
- * for compatibility; this never records a water color overlay in normal rendering.
- */
 export class WaterExtension extends RenderExtension {
-    /**
-     * @param {WaterSystem} system
-     */
-    constructor(system: WaterSystem);
+    constructor(system: any);
+    system: any;
     record(frame: any): void;
-    #private;
 }
-/**
- * Records the water surface producer at {@link FramePhase.FrameStart}, so the surface exists before
- * anything in the frame reads it.
- */
 export class WaterSurfaceExtension extends RenderExtension {
-    /**
-     * @param {WaterSystem} system
-     */
-    constructor(system: WaterSystem);
+    constructor(system: any);
+    system: any;
     record(frame: any): void;
-    #private;
 }
 import { System } from "../ecs/System.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
+import { MeshletGeometry } from "../../shade/renderer/geometry/MeshletGeometry.js";
 import Water from "../graphics/ecs/water/Water.js";
 import WaterWaves from "../graphics/ecs/water/WaterWaves.js";
 import { ResourceAccessSpecification } from "../../core/model/ResourceAccessSpecification.js";

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":"AAiBA;;;;;;;;GAQG;AACH;IA4FI;;OAEG;IACH,sCAMC;IApGD,+BAAuB;IAEvB,kEAGE;IAoDF;;;;;;;;;;MAAkD;IAElD,sEAAsE;IACtE,oCAAmC;IAEnC,kFAAkF;IAClF,6CAAqD;IAErD,qCAA8D;IAG9D,0BAIC;IALD,mBAAiC;IAcjC;;;;;OAKG;IACH,+BAEC;IAaD,2CAQC;IAED,4CAkBC;IAED;;OAEG;IACH,kCAGC;IAED;;;;;OAKG;IACH,0CAWC;IAED;;;;;;;;;;OAUG;IACH,eALW,MAAM,YACN,MAAM,EAAE,UACR,MAAM,YACN,MAAM,QAgBhB;IAED;;;OAGG;IACH,YAHW,KAAK,UACL,MAAM,QA+BhB;IAED;;;OAGG;IACH,cAHW,KAAK,UACL,MAAM,QAgBhB;IAED,6BAiBC;;CAgFJ;AAED;;;GAGG;AACH;IAWI;;OAEG;IACH,oBAFW,WAAW,EAMrB;IAED,yBAEC;;CACJ;AAED;;;GAGG;AACH;IAUI;;OAEG;IACH,oBAFW,WAAW,EAMrB;IAED,yBAEC;;CACJ;uBAjasB,kBAAkB;kBAJvB,gCAAgC;uBAC3B,qCAAqC;4CAKhB,iDAAiD;uCAGtD,8DAA8D;iCAFpE,gDAAgD;gCAMjD,mDAAmD"}
+{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/WaterSystem.js"],"names":[],"mappings":"AAyBA;;;;GAIG;AACH;IAyBI,uCAcC;IAtCD,6EAAqD;IACrD,kEAA0F;IAY1F;;;;;;;;;;;MAAkD;IAClD,oCAAmC;IACnC,6CAAqD;IACrD,iBAAmC;IACnC,qCAA8D;IAE9D,0BAGC;IAJD,mBAAiC;IAsBjC,2CAOC;IAED,0BAMC;IAED,mEAoBC;IAUD,qEAkBC;IAED,sBAgBC;IA0CD,2FAA2F;IAC3F,qEASC;IAED,iCAKC;IACD,yBAGC;;CACJ;AAED;IAEI,yBAAsD;IAAvB,YAAoB;IACnD,yBAA4C;CAC/C;AACD;IAEI,yBAAsD;IAAvB,YAAoB;IACnD,yBAAoD;CACvD;uBAlOsB,kBAAkB;4BAEb,iCAAiC;gCAI7B,kDAAkD;kBARhE,gCAAgC;uBAC3B,qCAAqC;4CAShB,iDAAiD;uCAGtD,8DAA8D;iCAFpE,gDAAgD;gCAIjD,mDAAmD"}