@pibbl/core 0.0.1

package/dist/features/textures/lib/water-surface.js

@@ -0,0 +1,378 @@
+import {
+  defineTexture
+} from "@pibbl/core";
+import { validateSeed } from "./palette.js";
+import { bytes } from "./wasm/water-surface-bytes.js";
+const FIXED_STEP = 1 / 120;
+const MAX_STEPS = 6;
+const IDLE_ENERGY = 6e-4;
+let compiled;
+function kernel() {
+  return compiled ??= new WebAssembly.Module(
+    Uint8Array.from(atob(bytes), (character) => character.charCodeAt(0))
+  );
+}
+function gridSize(width, height) {
+  const scale = Math.min(
+    1,
+    128 / Math.min(width, height),
+    256 / Math.max(width, height)
+  );
+  return [
+    Math.max(2, Math.round(width * scale)),
+    Math.max(2, Math.round(height * scale))
+  ];
+}
+class WaterSimulation {
+  constructor(width, rows, obstacles, outputWidth, outputHeight, config) {
+    this.width = width;
+    this.rows = rows;
+    this.outputWidth = outputWidth;
+    this.outputHeight = outputHeight;
+    const count = width * rows;
+    const scalarBytes = count * Float32Array.BYTES_PER_ELEMENT;
+    const solidOffset = 65536 + scalarBytes * 4;
+    this.modeOffset = Math.ceil((solidOffset + count) / 8) * 8;
+    const pixelOffset = this.modeOffset + 96;
+    const pages = Math.ceil(
+      (pixelOffset + outputWidth * outputHeight * 4) / 65536
+    );
+    this.memory = new WebAssembly.Memory({ initial: pages, maximum: pages });
+    this.kernel = new WebAssembly.Instance(kernel(), {
+      env: {
+        memory: this.memory,
+        abort() {
+          throw new Error("Water surface WASM aborted.");
+        }
+      }
+    }).exports;
+    this.height = new Float32Array(this.memory.buffer, 65536, count);
+    this.velocity = new Float32Array(
+      this.memory.buffer,
+      65536 + scalarBytes,
+      count
+    );
+    this.nextHeight = new Float32Array(
+      this.memory.buffer,
+      65536 + scalarBytes * 2,
+      count
+    );
+    this.nextVelocity = new Float32Array(
+      this.memory.buffer,
+      65536 + scalarBytes * 3,
+      count
+    );
+    this.solid = new Uint8Array(this.memory.buffer, solidOffset, count);
+    this.image = new ImageData(
+      new Uint8ClampedArray(
+        this.memory.buffer,
+        pixelOffset,
+        outputWidth * outputHeight * 4
+      ),
+      outputWidth,
+      outputHeight
+    );
+    this.configure(config);
+    this.setObstacles(obstacles);
+  }
+  width;
+  rows;
+  outputWidth;
+  outputHeight;
+  memory;
+  image;
+  modeOffset;
+  height;
+  velocity;
+  nextHeight;
+  nextVelocity;
+  solid;
+  kernel;
+  previousObstacles = [];
+  reset() {
+    this.kernel.clear(
+      this.height.byteOffset,
+      this.velocity.byteOffset,
+      this.nextHeight.byteOffset,
+      this.nextVelocity.byteOffset,
+      this.height.length
+    );
+  }
+  setObstacles(obstacles) {
+    if (sameObstacles(this.previousObstacles, obstacles)) return 0;
+    const previous = this.previousObstacles;
+    this.kernel.clearMask(this.solid.byteOffset, this.solid.length);
+    for (const o of obstacles)
+      this.kernel.maskRectangle(
+        this.solid.byteOffset,
+        this.width,
+        this.rows,
+        o.x,
+        o.y,
+        o.width,
+        o.height
+      );
+    this.kernel.maskFields(
+      this.height.byteOffset,
+      this.velocity.byteOffset,
+      this.nextHeight.byteOffset,
+      this.nextVelocity.byteOffset,
+      this.solid.byteOffset,
+      this.solid.length
+    );
+    this.previousObstacles = obstacles;
+    let wakeEnergy = 0;
+    for (let index = 0; index < Math.min(previous.length, obstacles.length); index++) {
+      const before = previous[index], after = obstacles[index];
+      wakeEnergy += this.kernel.wake(
+        this.velocity.byteOffset,
+        this.solid.byteOffset,
+        this.width,
+        this.rows,
+        before.x,
+        before.y,
+        before.width,
+        before.height,
+        after.x,
+        after.y,
+        after.width,
+        after.height
+      );
+    }
+    return wakeEnergy;
+  }
+  ripple(u, v, strength) {
+    this.kernel.impulse(
+      this.velocity.byteOffset,
+      this.solid.byteOffset,
+      this.width,
+      this.rows,
+      u,
+      v,
+      Math.max(2, Math.min(this.width, this.rows) * 0.075),
+      strength * 1.8
+    );
+  }
+  step(count, viscosity) {
+    return this.kernel.steps(
+      this.height.byteOffset,
+      this.velocity.byteOffset,
+      this.nextHeight.byteOffset,
+      this.nextVelocity.byteOffset,
+      this.solid.byteOffset,
+      this.width,
+      this.rows,
+      count,
+      viscosity
+    );
+  }
+  configure(config) {
+    this.kernel.initializeModes(this.modeOffset, config.seed, config.scale);
+  }
+  raster(time, strength) {
+    this.kernel.raster(
+      this.height.byteOffset,
+      this.solid.byteOffset,
+      this.width,
+      this.rows,
+      this.image.data.byteOffset,
+      this.outputWidth,
+      this.outputHeight,
+      this.modeOffset,
+      time,
+      strength
+    );
+  }
+  dispose() {
+    this.height.fill(0);
+    this.velocity.fill(0);
+    this.solid.fill(0);
+  }
+}
+function sameObstacles(left, right) {
+  return left.length === right.length && left.every((value, index) => {
+    const other = right[index];
+    return value.x === other.x && value.y === other.y && value.width === other.width && value.height === other.height;
+  });
+}
+function options(input) {
+  const seed = validateSeed(input.seed ?? 0), speed = input.speed ?? 1, scale = input.scale ?? 4, rippleStrength = input.rippleStrength ?? 1, viscosity = input.viscosity ?? 0;
+  if (!Number.isFinite(viscosity) || viscosity < 0 || viscosity > 1)
+    throw new RangeError(
+      "Water surface viscosity must be finite and within [0, 1]."
+    );
+  if (!Number.isFinite(speed) || speed < 0)
+    throw new RangeError("Water surface speed must be finite and nonnegative.");
+  if (!Number.isInteger(scale) || scale < 1 || scale > 32)
+    throw new RangeError(
+      "Water surface scale must be an integer from 1 to 32."
+    );
+  if (!Number.isFinite(rippleStrength) || rippleStrength < 0)
+    throw new RangeError(
+      "Water surface ripple strength must be finite and nonnegative."
+    );
+  const obstacles = Object.freeze(
+    (input.obstacles ?? []).map((obstacle) => {
+      if (![obstacle.x, obstacle.y, obstacle.width, obstacle.height].every(
+        Number.isFinite
+      ) || obstacle.x < 0 || obstacle.y < 0 || obstacle.width < 0 || obstacle.height < 0 || obstacle.x + obstacle.width > 1 || obstacle.y + obstacle.height > 1)
+        throw new RangeError(
+          "Water surface obstacles must be finite normalized rectangles within [0, 1]."
+        );
+      return Object.freeze({ ...obstacle });
+    })
+  );
+  return {
+    seed,
+    speed,
+    scale,
+    rippleStrength,
+    viscosity,
+    paused: input.paused ?? false,
+    obstacles
+  };
+}
+function assertDataTexture(context) {
+  if (context.palette !== void 0)
+    throw new TypeError(
+      "waterSurface is a numeric displacement map and does not accept a palette."
+    );
+}
+function assertCoordinate(value, name) {
+  if (!Number.isFinite(value) || value < 0 || value > 1)
+    throw new RangeError(
+      `Water ripple ${name} must be finite and within [0, 1].`
+    );
+}
+function active(state) {
+  return state.config.speed > 0 || state.energy > IDLE_ENERGY;
+}
+function replaceSimulation(state, context, config) {
+  const [width, rows] = gridSize(context.canvas.width, context.canvas.height);
+  if (state.simulation.width !== width || state.simulation.rows !== rows || state.simulation.outputWidth !== context.canvas.width || state.simulation.outputHeight !== context.canvas.height) {
+    state.simulation.dispose();
+    state.simulation = new WaterSimulation(
+      width,
+      rows,
+      config.obstacles,
+      context.canvas.width,
+      context.canvas.height,
+      config
+    );
+    return 0;
+  }
+  return state.simulation.setObstacles(config.obstacles);
+}
+const recipe = /* @__PURE__ */ defineTexture({
+  defaultPlacement: { mode: "stretch" },
+  create(context, input) {
+    assertDataTexture(context);
+    const config = options(input), [width, rows] = gridSize(context.canvas.width, context.canvas.height);
+    if (!config.paused && config.speed > 0) context.requestFrame();
+    return {
+      config,
+      simulation: new WaterSimulation(
+        width,
+        rows,
+        config.obstacles,
+        context.canvas.width,
+        context.canvas.height,
+        config
+      ),
+      phase: 0,
+      paused: config.paused,
+      fresh: true,
+      elapsed: 0,
+      energy: 0
+    };
+  },
+  update(state, input, context) {
+    assertDataTexture(context);
+    const next = options(input), previous = state.config;
+    const wasActive = active(state);
+    const wakeEnergy = replaceSimulation(state, context, next);
+    if (next.seed !== previous.seed || next.scale !== previous.scale) {
+      state.phase = 0;
+      state.simulation.configure(next);
+      state.simulation.reset();
+      state.energy = 0;
+    }
+    if (next.paused !== previous.paused) state.paused = next.paused;
+    if (next.paused !== previous.paused || next.speed !== previous.speed) {
+      state.fresh = true;
+      state.elapsed = 0;
+    }
+    state.config = next;
+    if (wakeEnergy > 0) {
+      state.energy = Math.max(state.energy, wakeEnergy);
+      if (!wasActive) {
+        state.fresh = true;
+        state.elapsed = 0;
+      }
+    }
+    context.invalidate();
+    if (!state.paused && active(state)) context.requestFrame();
+  },
+  receive(state, message, context) {
+    if (message.type === "pause") {
+      state.paused = message.paused;
+      state.fresh = true;
+      state.elapsed = 0;
+      if (!state.paused && active(state)) context.requestFrame();
+      return;
+    }
+    if (message.type === "reset") {
+      state.simulation.reset();
+      state.phase = 0;
+      state.energy = 0;
+      state.elapsed = 0;
+      state.fresh = true;
+      context.invalidate();
+      return;
+    }
+    if (message.type === "ripple") {
+      assertCoordinate(message.x, "x");
+      assertCoordinate(message.y, "y");
+      const wasActive = active(state);
+      state.simulation.ripple(message.x, message.y, 1);
+      state.energy = Math.max(state.energy, 1);
+      if (!wasActive) {
+        state.fresh = true;
+        state.elapsed = 0;
+      }
+      context.invalidate();
+      if (!state.paused) context.requestFrame();
+      return;
+    }
+    throw new TypeError("Unknown water surface message.");
+  },
+  advance(state, frame, context) {
+    if (state.paused || !active(state)) return;
+    if (!state.fresh) {
+      state.elapsed += Math.min(0.05, frame.delta / 1e3);
+      const steps = Math.min(MAX_STEPS, Math.floor(state.elapsed / FIXED_STEP));
+      if (steps) {
+        state.elapsed -= steps * FIXED_STEP;
+        state.energy = state.simulation.step(steps, state.config.viscosity);
+        state.phase += frame.delta / 1e3 * state.config.speed / (1 + 4 * state.config.viscosity);
+        context.invalidate();
+      }
+    }
+    state.fresh = false;
+    if (active(state)) context.requestFrame();
+  },
+  rasterize(state, context) {
+    state.simulation.raster(state.phase, state.config.rippleStrength);
+    context.canvas.getContext("2d").putImageData(state.simulation.image, 0, 0);
+  },
+  dispose(state) {
+    state.simulation.dispose();
+  }
+});
+function waterSurface(options2 = {}) {
+  return recipe(options2);
+}
+export {
+  waterSurface
+};
+//# sourceMappingURL=water-surface.js.map

package/dist/features/textures/lib/water-surface.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/textures/lib/water-surface.ts"],
+  "sourcesContent": ["import {\n  defineTexture,\n  type TextureContext,\n  type TextureRecipe,\n} from \"@pibbl/core\";\nimport { validateSeed } from \"./palette.js\";\nimport { bytes } from \"./wasm/water-surface-bytes.js\";\n\n/**\n * An axis-aligned obstacle rectangle in a water-surface simulation.\n *\n * @see {@link WaterSurfaceOptions}\n */\nexport interface WaterSurfaceObstacle {\n  /**\n   * Horizontal coordinate or displacement in the containing coordinate system. See\n   * {@link WaterSurfaceObstacle}.\n   */\n  readonly x: number;\n  /**\n   * Vertical coordinate or displacement in the containing coordinate system. See\n   * {@link WaterSurfaceObstacle}.\n   */\n  readonly y: number;\n  /**\n   * Horizontal extent in the units of the containing geometry or surface. See\n   * {@link WaterSurfaceObstacle}.\n   */\n  readonly width: number;\n  /**\n   * Vertical extent in the units of the containing geometry or surface. See\n   * {@link WaterSurfaceObstacle}.\n   */\n  readonly height: number;\n}\n\n/**\n * Water simulation controls including wave motion, viscosity, pause state, and obstacles.\n *\n * @see {@link WaterSurfaceObstacle}\n * @see {@link waterSurface}\n */\nexport interface WaterSurfaceOptions {\n  /**\n   * Seed used for deterministic sampling or simulation initialization. See\n   * {@link WaterSurfaceOptions}.\n   */\n  readonly seed?: number;\n  /** Multiplier controlling the simulation's animation rate. See {@link WaterSurfaceOptions}. */\n  readonly speed?: number;\n  /** Spatial scale of the generated water pattern. See {@link WaterSurfaceOptions}. */\n  readonly scale?: number;\n  /** Strength of injected wave disturbances. See {@link WaterSurfaceOptions}. */\n  readonly rippleStrength?: number;\n  /** Artistic thickness from 0 (water) to 1 (slow, strongly damped). */\n  readonly viscosity?: number;\n  /** Whether simulation or playback advancement is suspended. See {@link WaterSurfaceOptions}. */\n  readonly paused?: boolean;\n  /** Obstacle geometry used by the flow or water simulation. See {@link WaterSurfaceObstacle}. */\n  readonly obstacles?: readonly WaterSurfaceObstacle[];\n}\n\n/**\n * Ripple, pause, and reset commands for a water-surface simulation.\n *\n * @see {@link waterSurface}\n */\nexport type WaterSurfaceMessage =\n  | {\n      /** The literal \"pause\" identifying this variant. See {@link WaterSurfaceMessage}. */\n      readonly type: \"pause\";\n      /** Whether simulation or playback advancement is suspended. See {@link WaterSurfaceMessage}. */\n      readonly paused: boolean;\n    }\n  | {\n      /** The literal \"reset\" identifying this variant. See {@link WaterSurfaceMessage}. */\n      readonly type: \"reset\";\n    }\n  | {\n      /** The literal \"ripple\" identifying this variant. See {@link WaterSurfaceMessage}. */\n      readonly type: \"ripple\";\n      /**\n       * Horizontal coordinate or displacement in the containing coordinate system. See\n       * {@link WaterSurfaceMessage}.\n       */\n      readonly x: number;\n      /**\n       * Vertical coordinate or displacement in the containing coordinate system. See\n       * {@link WaterSurfaceMessage}.\n       */\n      readonly y: number;\n    };\n\ninterface Config {\n  readonly seed: number;\n  readonly speed: number;\n  readonly scale: number;\n  readonly rippleStrength: number;\n  readonly viscosity: number;\n  readonly paused: boolean;\n  readonly obstacles: readonly WaterSurfaceObstacle[];\n}\ninterface State {\n  config: Config;\n  simulation: WaterSimulation;\n  phase: number;\n  paused: boolean;\n  fresh: boolean;\n  elapsed: number;\n  energy: number;\n}\ninterface WaterKernel {\n  clear(\n    height: number,\n    velocity: number,\n    nextHeight: number,\n    nextVelocity: number,\n    count: number,\n  ): void;\n  impulse(\n    velocity: number,\n    solid: number,\n    width: number,\n    rows: number,\n    u: number,\n    v: number,\n    radius: number,\n    strength: number,\n  ): void;\n  steps(\n    height: number,\n    velocity: number,\n    nextHeight: number,\n    nextVelocity: number,\n    solid: number,\n    width: number,\n    rows: number,\n    count: number,\n    viscosity: number,\n  ): number;\n  clearMask(solid: number, count: number): void;\n  maskRectangle(\n    solid: number,\n    width: number,\n    rows: number,\n    x: number,\n    y: number,\n    w: number,\n    h: number,\n  ): void;\n  maskFields(\n    height: number,\n    velocity: number,\n    nextHeight: number,\n    nextVelocity: number,\n    solid: number,\n    count: number,\n  ): void;\n  wake(\n    velocity: number,\n    solid: number,\n    width: number,\n    rows: number,\n    bx: number,\n    by: number,\n    bw: number,\n    bh: number,\n    ax: number,\n    ay: number,\n    aw: number,\n    ah: number,\n  ): number;\n  initializeModes(ptr: number, seed: number, scale: number): void;\n  raster(\n    height: number,\n    solid: number,\n    width: number,\n    rows: number,\n    pixels: number,\n    outWidth: number,\n    outHeight: number,\n    modes: number,\n    time: number,\n    strength: number,\n  ): void;\n}\n\nconst FIXED_STEP = 1 / 120;\nconst MAX_STEPS = 6;\nconst IDLE_ENERGY = 0.0006;\nlet compiled: WebAssembly.Module | undefined;\n\nfunction kernel(): WebAssembly.Module {\n  return (compiled ??= new WebAssembly.Module(\n    Uint8Array.from(atob(bytes), (character) => character.charCodeAt(0)),\n  ));\n}\n\nfunction gridSize(width: number, height: number): readonly [number, number] {\n  const scale = Math.min(\n    1,\n    128 / Math.min(width, height),\n    256 / Math.max(width, height),\n  );\n  return [\n    Math.max(2, Math.round(width * scale)),\n    Math.max(2, Math.round(height * scale)),\n  ];\n}\n\nclass WaterSimulation {\n  readonly memory: WebAssembly.Memory;\n  readonly image: ImageData;\n  private readonly modeOffset: number;\n  readonly height: Float32Array;\n  readonly velocity: Float32Array;\n  private readonly nextHeight: Float32Array;\n  private readonly nextVelocity: Float32Array;\n  readonly solid: Uint8Array;\n  private readonly kernel: WaterKernel;\n  private previousObstacles: readonly WaterSurfaceObstacle[] = [];\n  constructor(\n    readonly width: number,\n    readonly rows: number,\n    obstacles: readonly WaterSurfaceObstacle[],\n    readonly outputWidth: number,\n    readonly outputHeight: number,\n    config: Config,\n  ) {\n    const count = width * rows;\n    const scalarBytes = count * Float32Array.BYTES_PER_ELEMENT;\n    const solidOffset = 65536 + scalarBytes * 4;\n    this.modeOffset = Math.ceil((solidOffset + count) / 8) * 8;\n    const pixelOffset = this.modeOffset + 96;\n    const pages = Math.ceil(\n      (pixelOffset + outputWidth * outputHeight * 4) / 65536,\n    );\n    this.memory = new WebAssembly.Memory({ initial: pages, maximum: pages });\n    this.kernel = new WebAssembly.Instance(kernel(), {\n      env: {\n        memory: this.memory,\n        abort() {\n          throw new Error(\"Water surface WASM aborted.\");\n        },\n      },\n    }).exports as unknown as WaterKernel;\n    this.height = new Float32Array(this.memory.buffer, 65536, count);\n    this.velocity = new Float32Array(\n      this.memory.buffer,\n      65536 + scalarBytes,\n      count,\n    );\n    this.nextHeight = new Float32Array(\n      this.memory.buffer,\n      65536 + scalarBytes * 2,\n      count,\n    );\n    this.nextVelocity = new Float32Array(\n      this.memory.buffer,\n      65536 + scalarBytes * 3,\n      count,\n    );\n    this.solid = new Uint8Array(this.memory.buffer, solidOffset, count);\n    this.image = new ImageData(\n      new Uint8ClampedArray(\n        this.memory.buffer,\n        pixelOffset,\n        outputWidth * outputHeight * 4,\n      ),\n      outputWidth,\n      outputHeight,\n    );\n    this.configure(config);\n    this.setObstacles(obstacles);\n  }\n  reset() {\n    this.kernel.clear(\n      this.height.byteOffset,\n      this.velocity.byteOffset,\n      this.nextHeight.byteOffset,\n      this.nextVelocity.byteOffset,\n      this.height.length,\n    );\n  }\n  setObstacles(obstacles: readonly WaterSurfaceObstacle[]): number {\n    if (sameObstacles(this.previousObstacles, obstacles)) return 0;\n    const previous = this.previousObstacles;\n    this.kernel.clearMask(this.solid.byteOffset, this.solid.length);\n    for (const o of obstacles)\n      this.kernel.maskRectangle(\n        this.solid.byteOffset,\n        this.width,\n        this.rows,\n        o.x,\n        o.y,\n        o.width,\n        o.height,\n      );\n    this.kernel.maskFields(\n      this.height.byteOffset,\n      this.velocity.byteOffset,\n      this.nextHeight.byteOffset,\n      this.nextVelocity.byteOffset,\n      this.solid.byteOffset,\n      this.solid.length,\n    );\n    this.previousObstacles = obstacles;\n    // A moving solid leaves one bounded impulse at its trailing edge. The\n    // height-field remains an appearance-only texture; this is not a force or\n    // collider update in Pibbl physics.\n    let wakeEnergy = 0;\n    for (\n      let index = 0;\n      index < Math.min(previous.length, obstacles.length);\n      index++\n    ) {\n      const before = previous[index],\n        after = obstacles[index];\n      wakeEnergy += this.kernel.wake(\n        this.velocity.byteOffset,\n        this.solid.byteOffset,\n        this.width,\n        this.rows,\n        before.x,\n        before.y,\n        before.width,\n        before.height,\n        after.x,\n        after.y,\n        after.width,\n        after.height,\n      );\n    }\n    return wakeEnergy;\n  }\n  ripple(u: number, v: number, strength: number) {\n    this.kernel.impulse(\n      this.velocity.byteOffset,\n      this.solid.byteOffset,\n      this.width,\n      this.rows,\n      u,\n      v,\n      Math.max(2, Math.min(this.width, this.rows) * 0.075),\n      strength * 1.8,\n    );\n  }\n  step(count: number, viscosity: number): number {\n    return this.kernel.steps(\n      this.height.byteOffset,\n      this.velocity.byteOffset,\n      this.nextHeight.byteOffset,\n      this.nextVelocity.byteOffset,\n      this.solid.byteOffset,\n      this.width,\n      this.rows,\n      count,\n      viscosity,\n    );\n  }\n  configure(config: Config) {\n    this.kernel.initializeModes(this.modeOffset, config.seed, config.scale);\n  }\n  raster(time: number, strength: number) {\n    this.kernel.raster(\n      this.height.byteOffset,\n      this.solid.byteOffset,\n      this.width,\n      this.rows,\n      this.image.data.byteOffset,\n      this.outputWidth,\n      this.outputHeight,\n      this.modeOffset,\n      time,\n      strength,\n    );\n  }\n  dispose() {\n    this.height.fill(0);\n    this.velocity.fill(0);\n    this.solid.fill(0);\n  }\n}\n\nfunction sameObstacles(\n  left: readonly WaterSurfaceObstacle[],\n  right: readonly WaterSurfaceObstacle[],\n) {\n  return (\n    left.length === right.length &&\n    left.every((value, index) => {\n      const other = right[index];\n      return (\n        value.x === other.x &&\n        value.y === other.y &&\n        value.width === other.width &&\n        value.height === other.height\n      );\n    })\n  );\n}\nfunction options(input: WaterSurfaceOptions): Config {\n  const seed = validateSeed(input.seed ?? 0),\n    speed = input.speed ?? 1,\n    scale = input.scale ?? 4,\n    rippleStrength = input.rippleStrength ?? 1,\n    viscosity = input.viscosity ?? 0;\n  if (!Number.isFinite(viscosity) || viscosity < 0 || viscosity > 1)\n    throw new RangeError(\n      \"Water surface viscosity must be finite and within [0, 1].\",\n    );\n  if (!Number.isFinite(speed) || speed < 0)\n    throw new RangeError(\"Water surface speed must be finite and nonnegative.\");\n  if (!Number.isInteger(scale) || scale < 1 || scale > 32)\n    throw new RangeError(\n      \"Water surface scale must be an integer from 1 to 32.\",\n    );\n  if (!Number.isFinite(rippleStrength) || rippleStrength < 0)\n    throw new RangeError(\n      \"Water surface ripple strength must be finite and nonnegative.\",\n    );\n  const obstacles = Object.freeze(\n    (input.obstacles ?? []).map((obstacle) => {\n      if (\n        ![obstacle.x, obstacle.y, obstacle.width, obstacle.height].every(\n          Number.isFinite,\n        ) ||\n        obstacle.x < 0 ||\n        obstacle.y < 0 ||\n        obstacle.width < 0 ||\n        obstacle.height < 0 ||\n        obstacle.x + obstacle.width > 1 ||\n        obstacle.y + obstacle.height > 1\n      )\n        throw new RangeError(\n          \"Water surface obstacles must be finite normalized rectangles within [0, 1].\",\n        );\n      return Object.freeze({ ...obstacle });\n    }),\n  );\n  return {\n    seed,\n    speed,\n    scale,\n    rippleStrength,\n    viscosity,\n    paused: input.paused ?? false,\n    obstacles,\n  };\n}\nfunction assertDataTexture(context: TextureContext) {\n  if (context.palette !== undefined)\n    throw new TypeError(\n      \"waterSurface is a numeric displacement map and does not accept a palette.\",\n    );\n}\nfunction assertCoordinate(value: number, name: \"x\" | \"y\") {\n  if (!Number.isFinite(value) || value < 0 || value > 1)\n    throw new RangeError(\n      `Water ripple ${name} must be finite and within [0, 1].`,\n    );\n}\nfunction active(state: State) {\n  return state.config.speed > 0 || state.energy > IDLE_ENERGY;\n}\nfunction replaceSimulation(\n  state: State,\n  context: TextureContext,\n  config: Config,\n): number {\n  const [width, rows] = gridSize(context.canvas.width, context.canvas.height);\n  if (\n    state.simulation.width !== width ||\n    state.simulation.rows !== rows ||\n    state.simulation.outputWidth !== context.canvas.width ||\n    state.simulation.outputHeight !== context.canvas.height\n  ) {\n    state.simulation.dispose();\n    state.simulation = new WaterSimulation(\n      width,\n      rows,\n      config.obstacles,\n      context.canvas.width,\n      context.canvas.height,\n      config,\n    );\n    return 0;\n  }\n  return state.simulation.setObstacles(config.obstacles);\n}\nconst recipe = /* @__PURE__ */ defineTexture<\n  WaterSurfaceOptions,\n  State,\n  WaterSurfaceMessage\n>({\n  defaultPlacement: { mode: \"stretch\" },\n  create(context, input) {\n    assertDataTexture(context);\n    const config = options(input),\n      [width, rows] = gridSize(context.canvas.width, context.canvas.height);\n    if (!config.paused && config.speed > 0) context.requestFrame();\n    return {\n      config,\n      simulation: new WaterSimulation(\n        width,\n        rows,\n        config.obstacles,\n        context.canvas.width,\n        context.canvas.height,\n        config,\n      ),\n      phase: 0,\n      paused: config.paused,\n      fresh: true,\n      elapsed: 0,\n      energy: 0,\n    };\n  },\n  update(state, input, context) {\n    assertDataTexture(context);\n    const next = options(input),\n      previous = state.config;\n    const wasActive = active(state);\n    const wakeEnergy = replaceSimulation(state, context, next);\n    if (next.seed !== previous.seed || next.scale !== previous.scale) {\n      state.phase = 0;\n      state.simulation.configure(next);\n      state.simulation.reset();\n      state.energy = 0;\n    }\n    if (next.paused !== previous.paused) state.paused = next.paused;\n    if (next.paused !== previous.paused || next.speed !== previous.speed) {\n      state.fresh = true;\n      state.elapsed = 0;\n    }\n    state.config = next;\n    if (wakeEnergy > 0) {\n      state.energy = Math.max(state.energy, wakeEnergy);\n      if (!wasActive) {\n        state.fresh = true;\n        state.elapsed = 0;\n      }\n    }\n    context.invalidate();\n    if (!state.paused && active(state)) context.requestFrame();\n  },\n  receive(state, message, context) {\n    if (message.type === \"pause\") {\n      state.paused = message.paused;\n      state.fresh = true;\n      state.elapsed = 0;\n      if (!state.paused && active(state)) context.requestFrame();\n      return;\n    }\n    if (message.type === \"reset\") {\n      state.simulation.reset();\n      state.phase = 0;\n      state.energy = 0;\n      state.elapsed = 0;\n      state.fresh = true;\n      context.invalidate();\n      return;\n    }\n    if (message.type === \"ripple\") {\n      assertCoordinate(message.x, \"x\");\n      assertCoordinate(message.y, \"y\");\n      const wasActive = active(state);\n      state.simulation.ripple(message.x, message.y, 1);\n      state.energy = Math.max(state.energy, 1);\n      if (!wasActive) {\n        state.fresh = true;\n        state.elapsed = 0;\n      }\n      context.invalidate();\n      if (!state.paused) context.requestFrame();\n      return;\n    }\n    throw new TypeError(\"Unknown water surface message.\");\n  },\n  advance(state, frame, context) {\n    if (state.paused || !active(state)) return;\n    if (!state.fresh) {\n      state.elapsed += Math.min(0.05, frame.delta / 1000);\n      const steps = Math.min(MAX_STEPS, Math.floor(state.elapsed / FIXED_STEP));\n      if (steps) {\n        state.elapsed -= steps * FIXED_STEP;\n        state.energy = state.simulation.step(steps, state.config.viscosity);\n        state.phase +=\n          ((frame.delta / 1000) * state.config.speed) /\n          (1 + 4 * state.config.viscosity);\n        context.invalidate();\n      }\n    }\n    state.fresh = false;\n    if (active(state)) context.requestFrame();\n  },\n  rasterize(state, context) {\n    state.simulation.raster(state.phase, state.config.rippleStrength);\n    context.canvas.getContext(\"2d\")!.putImageData(state.simulation.image, 0, 0);\n  },\n  dispose(state) {\n    state.simulation.dispose();\n  },\n});\n\n/**\n * A WASM-only, bounded reflective height-field displacement map.\n *\n * @param options - Water appearance and simulation settings. See {@link WaterSurfaceOptions}.\n * @returns A water-surface texture recipe accepting surface messages. See {@link TextureRecipe} ,\n * {@link WaterSurfaceMessage} .\n *\n * @see {@link WaterSurfaceOptions}\n * @see {@link TextureRecipe}\n * @see {@link WaterSurfaceMessage}\n */\nexport function waterSurface(\n  options: WaterSurfaceOptions = {},\n): TextureRecipe<WaterSurfaceMessage> {\n  return recipe(options);\n}\n"],
+  "mappings": "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",
+  "names": ["options"]
+}

package/dist/features/textures/lib/water-waves.d.ts

@@ -0,0 +1,60 @@
+import { type TextureRecipe } from "@pibbl/core";
+/**
+ * Seed, animation speed, feature scale, ripple strength, and initial pause state of water waves.
+ *
+ * @see {@link waterWaves}
+ */
+export interface WaterWavesOptions {
+    /**
+     * Seed used for deterministic sampling or simulation initialization. See
+     * {@link WaterWavesOptions}.
+     */
+    readonly seed?: number;
+    /** Multiplier controlling the simulation's animation rate. See {@link WaterWavesOptions}. */
+    readonly speed?: number;
+    /** Spatial scale of the generated wave pattern. See {@link WaterWavesOptions}. */
+    readonly scale?: number;
+    /** Strength of injected wave disturbances. See {@link WaterWavesOptions}. */
+    readonly rippleStrength?: number;
+    /** Whether simulation or playback advancement is suspended. See {@link WaterWavesOptions}. */
+    readonly paused?: boolean;
+}
+/**
+ * Ripple, pause, and reset commands for a water-wave texture.
+ *
+ * @see {@link waterWaves}
+ */
+export type WaterWavesMessage = {
+    /** The literal "pause" identifying this variant. See {@link WaterWavesMessage}. */
+    readonly type: "pause";
+    /** Whether simulation or playback advancement is suspended. See {@link WaterWavesMessage}. */
+    readonly paused: boolean;
+} | {
+    /** The literal "reset" identifying this variant. See {@link WaterWavesMessage}. */
+    readonly type: "reset";
+} | {
+    /** The literal "ripple" identifying this variant. See {@link WaterWavesMessage}. */
+    readonly type: "ripple";
+    /**
+     * Horizontal coordinate or displacement in the containing coordinate system. See
+     * {@link WaterWavesMessage}.
+     */
+    readonly x: number;
+    /**
+     * Vertical coordinate or displacement in the containing coordinate system. See
+     * {@link WaterWavesMessage}.
+     */
+    readonly y: number;
+};
+/**
+ * Creates an animated water-wave texture recipe that accepts ripple, pause, and reset commands.
+ *
+ * @param options - Wave simulation and rendering settings. See {@link WaterWavesOptions}.
+ * @returns A water-wave texture recipe accepting wave messages. See {@link TextureRecipe} ,
+ * {@link WaterWavesMessage} .
+ *
+ * @see {@link WaterWavesOptions}
+ * @see {@link TextureRecipe}
+ * @see {@link WaterWavesMessage}
+ */
+export declare function waterWaves(options?: WaterWavesOptions): TextureRecipe<WaterWavesMessage>;

package/dist/features/textures/lib/water-waves.js

@@ -0,0 +1,154 @@
+import {
+  defineTexture
+} from "@pibbl/core";
+import { bytes } from "./wasm/water-waves-bytes.js";
+import { validateSeed } from "./palette.js";
+let compiled;
+class WaveField {
+  kernel;
+  image;
+  constructor(width, height, config2) {
+    const pages = Math.ceil((66024 + width * height * 4) / 65536);
+    const memory = new WebAssembly.Memory({ initial: pages, maximum: pages });
+    compiled ??= new WebAssembly.Module(
+      Uint8Array.from(atob(bytes), (c) => c.charCodeAt(0))
+    );
+    this.kernel = new WebAssembly.Instance(compiled, {
+      env: {
+        memory,
+        abort() {
+          throw new Error("Water waves WASM aborted.");
+        }
+      }
+    }).exports;
+    this.image = new ImageData(
+      new Uint8ClampedArray(memory.buffer, 66024, width * height * 4),
+      width,
+      height
+    );
+    this.configure(config2);
+  }
+  configure(config2) {
+    this.kernel.initializeModes(65536, config2.seed, config2.scale);
+  }
+  raster(time, strength) {
+    this.kernel.raster(
+      66024,
+      this.image.width,
+      this.image.height,
+      time,
+      strength
+    );
+  }
+}
+function config(input) {
+  const seed = validateSeed(input.seed ?? 0);
+  const speed = input.speed ?? 1;
+  const scale = input.scale ?? 4;
+  const rippleStrength = input.rippleStrength ?? 1;
+  if (!Number.isFinite(speed) || speed < 0)
+    throw new RangeError("Water wave speed must be finite and nonnegative.");
+  if (!Number.isInteger(scale) || scale < 1 || scale > 32)
+    throw new RangeError("Water wave scale must be an integer from 1 to 32.");
+  if (!Number.isFinite(rippleStrength) || rippleStrength < 0)
+    throw new RangeError(
+      "Water ripple strength must be finite and nonnegative."
+    );
+  return { seed, speed, scale, rippleStrength, paused: input.paused ?? false };
+}
+function assertDataTexture(context) {
+  if (context.palette !== void 0)
+    throw new TypeError(
+      "waterWaves is a numeric displacement map and does not accept a palette."
+    );
+}
+function isAnimating(state) {
+  return state.config.speed > 0 || state.rippleCount > 0;
+}
+function assertRippleCoordinate(value, name) {
+  if (!Number.isFinite(value) || value < 0 || value > 1)
+    throw new RangeError(
+      `Water ripple ${name} must be finite and within [0, 1].`
+    );
+}
+const recipe = /* @__PURE__ */ defineTexture({
+  create(context, input) {
+    assertDataTexture(context);
+    const next = config(input);
+    if (!next.paused && next.speed > 0) context.requestFrame();
+    return {
+      config: next,
+      field: new WaveField(context.canvas.width, context.canvas.height, next),
+      phase: 0,
+      paused: next.paused,
+      fresh: true,
+      rippleCount: 0
+    };
+  },
+  update(state, input, context) {
+    assertDataTexture(context);
+    const next = config(input);
+    const previous = state.config;
+    if (next.seed !== previous.seed || next.scale !== previous.scale) {
+      state.phase = 0;
+      state.field.configure(next);
+      context.invalidate();
+    }
+    if (next.rippleStrength !== previous.rippleStrength) context.invalidate();
+    if (next.paused !== previous.paused) state.paused = next.paused;
+    if (next.paused !== previous.paused || next.speed !== previous.speed)
+      state.fresh = true;
+    state.config = next;
+    if (!state.paused && isAnimating(state)) context.requestFrame();
+  },
+  receive(state, message, context) {
+    if (message.type === "pause") {
+      state.paused = message.paused;
+      state.fresh = true;
+      if (!state.paused && isAnimating(state)) context.requestFrame();
+      return;
+    }
+    if (message.type === "reset") {
+      state.phase = 0;
+      state.field.kernel.reset();
+      state.rippleCount = 0;
+      state.fresh = true;
+      context.invalidate();
+      return;
+    }
+    if (message.type === "ripple") {
+      assertRippleCoordinate(message.x, "x");
+      assertRippleCoordinate(message.y, "y");
+      if (!isAnimating(state)) state.fresh = true;
+      state.field.kernel.ripple(message.x, message.y);
+      state.rippleCount = Math.min(16, state.rippleCount + 1);
+      context.invalidate();
+      if (!state.paused) context.requestFrame();
+      return;
+    }
+    throw new TypeError("Unknown water wave message.");
+  },
+  advance(state, frame, context) {
+    if (state.paused || !isAnimating(state)) return;
+    if (!state.fresh) {
+      const elapsed = frame.delta / 1e3;
+      state.phase += elapsed * state.config.speed;
+      state.rippleCount = state.field.kernel.advance(elapsed);
+      context.invalidate();
+    }
+    state.fresh = false;
+    if (isAnimating(state)) context.requestFrame();
+  },
+  rasterize(state, context) {
+    const ctx = context.canvas.getContext("2d");
+    state.field.raster(state.phase, state.config.rippleStrength);
+    ctx.putImageData(state.field.image, 0, 0);
+  }
+});
+function waterWaves(options = {}) {
+  return recipe(options);
+}
+export {
+  waterWaves
+};
+//# sourceMappingURL=water-waves.js.map