@woosh/meep-engine 3.64.0 → 3.65.0

package/src/engine/graphics/texture/sampler/sampler2d_to_exr.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Encode a sampler as an OpenEXR file.
+ *
+ * Channels are named the way OpenEXR names them: one channel is a luminance image, Y; two are Y and A;
+ * three are R, G and B; four are R, G, B and A. {@link exr_to_sampler2d} reads each of those back as RGBA.
+ *
+ * The sampler's storage is the pixel type: a `Float16Array` is written as HALF, a `Float32Array` as FLOAT,
+ * a `Uint32Array` as UINT. Other storage is refused rather than converted, because what its numbers mean
+ * — normalised, sRGB-encoded — is not this function's to guess; convert first, for instance with
+ * `sampler2d_srgb_u8_to_linear_f16` or `sampler2d_to_f16`. Samples are copied as numbers, so every value
+ * is written unchanged but a NaN may be written with another payload.
+ *
+ * @param {Sampler2D} sampler 1 to 4 channels
+ * @param {ExrCompression} compression see {@link exr_write}
+ * @returns {Promise<ArrayBuffer>} the whole file
+ * @throws {Error} for any other channel count, and wherever {@link exr_write} throws
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sampler2d_to_exr(sampler: Sampler2D, compression: ExrCompression): Promise<ArrayBuffer>;
+import { Sampler2D } from "./Sampler2D.js";
+//# sourceMappingURL=sampler2d_to_exr.d.ts.map

package/src/engine/graphics/texture/sampler/sampler2d_to_exr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampler2d_to_exr.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/sampler2d_to_exr.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,0CARW,SAAS,gCAEP,QAAQ,WAAW,CAAC,CA8BhC;0BA9DyB,gBAAgB"}

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

@@ -0,0 +1,64 @@
+import { exr_write } from "../../../../format/image/exr/exr_write.js";
+import { Sampler2D } from "./Sampler2D.js";
+import { sampler2d_copy_channel_data } from "./sampler2d_copy_channel_data.js";
+
+/**
+ * Channel names by item size, the way OpenEXR names them: luminance, luminance and alpha, colour, colour
+ * and alpha.
+ *
+ * @readonly
+ * @type {(string[]|undefined)[]}
+ */
+const CHANNEL_NAMES = [
+    undefined,
+    ["Y"],
+    ["Y", "A"],
+    ["R", "G", "B"],
+    ["R", "G", "B", "A"],
+];
+
+/**
+ * Encode a sampler as an OpenEXR file.
+ *
+ * Channels are named the way OpenEXR names them: one channel is a luminance image, Y; two are Y and A;
+ * three are R, G and B; four are R, G, B and A. {@link exr_to_sampler2d} reads each of those back as RGBA.
+ *
+ * The sampler's storage is the pixel type: a `Float16Array` is written as HALF, a `Float32Array` as FLOAT,
+ * a `Uint32Array` as UINT. Other storage is refused rather than converted, because what its numbers mean
+ * — normalised, sRGB-encoded — is not this function's to guess; convert first, for instance with
+ * `sampler2d_srgb_u8_to_linear_f16` or `sampler2d_to_f16`. Samples are copied as numbers, so every value
+ * is written unchanged but a NaN may be written with another payload.
+ *
+ * @param {Sampler2D} sampler 1 to 4 channels
+ * @param {ExrCompression} compression see {@link exr_write}
+ * @returns {Promise<ArrayBuffer>} the whole file
+ * @throws {Error} for any other channel count, and wherever {@link exr_write} throws
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export async function sampler2d_to_exr(sampler, compression) {
+    const width = sampler.width;
+    const height = sampler.height;
+    const item_size = sampler.itemSize;
+
+    const names = CHANNEL_NAMES[item_size];
+
+    if (names === undefined) {
+        throw new Error(`EXR: a sampler of ${item_size} channels has no OpenEXR naming; 1 to 4 channels do`);
+    }
+
+    const storage = sampler.data.constructor;
+
+    const channels = new Array(item_size);
+
+    for (let c = 0; c < item_size; c++) {
+        const plane = new Sampler2D(new storage(width * height), 1, width, height);
+
+        sampler2d_copy_channel_data(sampler, c, plane, 0);
+
+        channels[c] = { name: names[c], data: plane.data };
+    }
+
+    return exr_write({ width, height, channels }, compression);
+}

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

@@ -0,0 +1,153 @@
+/**
+ * How far a corner of a member's box may be from where it was, in its surface's frame, before the member
+ * counts as moved and the ground under it is baked again: a micron. A surface that moves as one moves its
+ * members by the arithmetic's noise and no more, which for a world kilometres across is a ten-thousandth
+ * of this; nothing a surfel holds can show a move this small.
+ *
+ * @type {number}
+ */
+export const GRASS_MEMBER_MOVE_TOLERANCE: number;
+/**
+ * Keeps the scene's grass surfaces on the device: which entities are surfaces, which mesh rows are ground
+ * of which, and a box and a tallest blade for each surface, so that views can ask for its tiles.
+ *
+ * A surface is an entity with [{@link GrassSurface}, {@link Transform64}]; this system links those. Its
+ * members are the mesh entities whose {@link GroundCover} names it, which {@link GroundCoverSystem} links
+ * and hands over through {@link add_member}. A member may arrive before its surface, and waits.
+ *
+ * **What is written, and when.** Nothing per frame: a link, an unlink, an edit announced by a component's
+ * `onChanged`, and a move announced by the dataset queue the surface or member they touch, and
+ * {@link update} writes what is queued.
+ *
+ * - A member's `mesh_ground_covers` row, at the entity's own row: its surface's `transforms` row, the
+ *   geometry a column traces for it, its species and density. Written once the mesh row itself exists.
+ * - A surface's record in {@link GPUGrassSurfaces}: a box, in the surface's frame, that holds every member
+ *   whose row is written, as placed, and the tallest blade of any of their species. A surface with no such
+ *   member has no record.
+ * - The ground that changed ({@link GPUGrassSurfaces#invalidate}): the rectangle of a member that has come,
+ *   gone, changed geometry, or moved in its surface's frame by more than
+ *   {@link GRASS_MEMBER_MOVE_TOLERANCE}. A surface that moves as one marks nothing.
+ * - A surface's `transforms` row is held, so that a surface entity with no mesh of its own has a frame on
+ *   the device.
+ *
+ * **Rows need a device.** While the scene has no GPU context nothing is written, and when one arrives or
+ * is replaced everything is queued again.
+ */
+export class GrassSurfaceSystem extends System<any> {
+    /**
+     * @param {GraphicsEngine} graphics
+     * @param {Scene} scene
+     */
+    constructor(graphics: GraphicsEngine, scene: Scene);
+    dependencies: (typeof Transform64 | typeof GrassSurface)[];
+    /**
+     * @returns {Scene}
+     */
+    get scene(): import("../../shade/renderer/scene/Scene.js").Scene;
+    /**
+     * The surfaces on the device, or null while the scene has no GPU context.
+     *
+     * @returns {GPUGrassSurfaces|null}
+     */
+    get surfaces(): GPUGrassSurfaces;
+    /**
+     * The blades on the device, or null while the scene has no GPU context.
+     *
+     * @returns {GPUGrassBlades|null}
+     */
+    get blades(): GPUGrassBlades;
+    startup(entityManager: any): Promise<void>;
+    shutdown(entityManager: any): Promise<void>;
+    /** The scene's rows are this dataset's entities; the first system to place one says so. */
+    handleDatasetAttached(dataset: any): void;
+    handleDatasetDetached(dataset: any): void;
+    /**
+     * @param {GrassSurface} surface
+     * @param {Transform64} transform
+     * @param {number} entity
+     */
+    link(surface: GrassSurface, transform: Transform64, entity: number): void;
+    /**
+     * @param {GrassSurface} surface
+     * @param {Transform64} transform
+     * @param {number} entity
+     */
+    unlink(surface: GrassSurface, transform: Transform64, entity: number): void;
+    /**
+     * A mesh entity becomes ground of the surface its cover names.
+     *
+     * @param {number} entity
+     * @param {GroundCover} cover
+     * @param {ShadedGeometry} shaded
+     * @param {Transform64} transform
+     */
+    add_member(entity: number, cover: GroundCover, shaded: ShadedGeometry, transform: Transform64): void;
+    /**
+     * A mesh entity stops being ground.
+     *
+     * @param {number} entity one that is no member is left alone
+     */
+    remove_member(entity: number): void;
+    /**
+     * The index a species in use is known by on the device.
+     *
+     * @param {GrassSpecies} species
+     * @returns {number} -1 for a species no member grows
+     */
+    species_index(species: GrassSpecies): number;
+    update(time_delta_seconds: any): void;
+    /**
+     * Record the frame's asks and bakes for one view.
+     *
+     * @param {import("../../shade/renderer/extension/FrameContext.js").FrameContext} frame
+     */
+    record(frame: import("../../shade/renderer/extension/FrameContext.js").FrameContext): void;
+    /**
+     * Record a view's blades, made and drawn into the frame's G-buffer. The blades are made here and not
+     * at the frame's start because they are bent by the scene's wind, which its producer publishes at the
+     * frame's start.
+     *
+     * The blades are pressed by the obstacles of the entity manager's {@link GPUFluidSystem}, when it has
+     * one for this scene.
+     *
+     * @param {FrameContext} frame
+     */
+    draw(frame: FrameContext): void;
+    #private;
+}
+/**
+ * The blades' seat in the frame: where the G-buffer is written into, ahead of what is laid over surfaces.
+ */
+export class GrassBladeExtension extends RenderExtension {
+    /**
+     * @param {GrassSurfaceSystem} system
+     */
+    constructor(system: GrassSurfaceSystem);
+    record(frame: any): void;
+    #private;
+}
+/**
+ * The grass surfaces' seat in the frame: at its start, where the compute that later phases read belongs.
+ */
+export class GrassSurfaceExtension extends RenderExtension {
+    /**
+     * @param {GrassSurfaceSystem} system
+     */
+    constructor(system: GrassSurfaceSystem);
+    record(frame: any): void;
+    enquirePipelines(enquiry: any): void;
+    #private;
+}
+export type GPUSceneContext = import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext;
+export type Scene = import("../../shade/renderer/scene/Scene.js").Scene;
+export type GrassSpecies = import("../graphics/ecs/grass/GrassSpecies.js").GrassSpecies;
+export type GroundCover = import("../graphics/ecs/grass/GroundCover.js").GroundCover;
+export type ShadedGeometry = import("../graphics/ecs/mesh-v2/ShadedGeometry.js").ShadedGeometry;
+export type GraphicsEngine = import("./GraphicsEngine.js").GraphicsEngine;
+import { System } from "../ecs/System.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
+import { GrassSurface } from "../graphics/ecs/grass/GrassSurface.js";
+import { GPUGrassSurfaces } from "../../shade/renderer/grass/surface/GPUGrassSurfaces.js";
+import { GPUGrassBlades } from "../../shade/renderer/grass/blade/GPUGrassBlades.js";
+import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
+//# sourceMappingURL=GrassSurfaceSystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GrassSurfaceSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GrassSurfaceSystem.js"],"names":[],"mappings":"AA0HA;;;;;;;GAOG;AACH,0CAFU,MAAM,CAEgC;AA+ChD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAkEI;;;OAGG;IACH,sBAHW,cAAc,SACd,KAAK,EAUf;IA7ED,2DAA2C;IA+E3C;;OAEG;IACH,iEAEC;IAED;;;;OAIG;IACH,iCAEC;IAED;;;;OAIG;IACH,6BAEC;IAED,2CAKC;IAED,4CAgBC;IAED,2FAA2F;IAC3F,0CAIC;IAED,0CAIC;IAED;;;;OAIG;IACH,cAJW,YAAY,aACZ,WAAW,UACX,MAAM,QAyChB;IAED;;;;OAIG;IACH,gBAJW,YAAY,aACZ,WAAW,UACX,MAAM,QAkChB;IAED;;;;;;;OAOG;IACH,mBALW,MAAM,SACN,WAAW,UACX,cAAc,aACd,WAAW,QA4CrB;IAED;;;;OAIG;IACH,sBAFW,MAAM,QAyChB;IA6GD;;;;;OAKG;IACH,uBAHW,YAAY,GACV,MAAM,CAMlB;IA4CD,sCAqEC;IAmOD;;;;OAIG;IACH,cAFW,OAAO,gDAAgD,EAAE,YAAY,QAQ/E;IAED;;;;;;;;;OASG;IACH,gCAUC;;CACJ;AAED;;GAEG;AACH;IAQI;;OAEG;IACH,oBAFW,kBAAkB,EAM5B;IAED,yBAEC;;CACJ;AAED;;GAEG;AACH;IAQI;;OAEG;IACH,oBAFW,kBAAkB,EAM5B;IAED,yBAEC;IAED,qCAGC;;CACJ;8BAvhCY,OAAO,+CAA+C,EAAE,eAAe;oBACvE,OAAO,qCAAqC,EAAE,KAAK;2BACnD,OAAO,uCAAuC,EAAE,YAAY;0BAC5D,OAAO,sCAAsC,EAAE,WAAW;6BAC1D,OAAO,2CAA2C,EAAE,cAAc;6BAClE,OAAO,qBAAqB,EAAE,cAAc;uBApBlC,kBAAkB;4BASlC,iCAAiC;6BACX,uCAAuC;iCAlBnC,wDAAwD;+BAD1D,oDAAoD;gCADnD,mDAAmD"}