@pibbl/core 0.0.1

package/dist/features/textures/lib/presentation.js

@@ -0,0 +1,83 @@
+import { rasterizeField } from "./wasm/memory.js";
+class TextureRaster {
+  constructor(width, height) {
+    this.width = width;
+    this.height = height;
+    this.surface = new OffscreenCanvas(width, height);
+    const context = this.surface.getContext("2d");
+    if (!context) {
+      this.surface.width = this.surface.height = 0;
+      throw new Error("Textures require offscreen Canvas 2D.");
+    }
+    this.context = context;
+  }
+  width;
+  height;
+  surface;
+  context;
+  maskRaster;
+  maskSurface;
+  maskContext;
+  maskDirty = true;
+  update(field, lut, gain = 1) {
+    const raster = rasterizeField(field, lut, gain);
+    this.maskRaster = raster.mask;
+    this.context.putImageData(raster.image, 0, 0);
+    this.maskDirty = true;
+  }
+  getMask() {
+    if (!this.maskSurface) {
+      this.maskSurface = new OffscreenCanvas(this.width, this.height);
+      this.maskContext = this.maskSurface.getContext("2d") ?? void 0;
+      if (!this.maskContext)
+        throw new Error("Textures require offscreen Canvas 2D.");
+    }
+    if (this.maskDirty) {
+      if (!this.maskRaster)
+        throw new Error("Texture mask requires a live WASM raster.");
+      this.maskContext.putImageData(this.maskRaster(), 0, 0);
+      this.maskDirty = false;
+    }
+    return this.maskSurface;
+  }
+  draw(ctx, width, height, backingWidth, backingHeight, render) {
+    ctx.save();
+    try {
+      ctx.resetTransform();
+      ctx.clearRect(0, 0, backingWidth, backingHeight);
+      if (width <= 0 || height <= 0) return;
+      ctx.scale(backingWidth / width, backingHeight / height);
+      if (render) {
+        const raster = this;
+        const result = render(
+          ctx,
+          Object.freeze({
+            source: this.surface,
+            get mask() {
+              return raster.getMask();
+            },
+            width,
+            height,
+            textureWidth: this.width,
+            textureHeight: this.height
+          })
+        );
+        if (result && typeof result.then === "function")
+          throw new TypeError("Texture render callbacks must be synchronous.");
+      } else ctx.drawImage(this.surface, 0, 0, width, height);
+    } finally {
+      ctx.restore();
+    }
+  }
+  dispose() {
+    this.surface.width = this.surface.height = 0;
+    if (this.maskSurface) this.maskSurface.width = this.maskSurface.height = 0;
+    this.maskSurface = void 0;
+    this.maskContext = void 0;
+    this.maskRaster = void 0;
+  }
+}
+export {
+  TextureRaster
+};
+//# sourceMappingURL=presentation.js.map

package/dist/features/textures/lib/presentation.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/textures/lib/presentation.ts"],
+  "sourcesContent": ["import type { ReactionDiffusionProps } from './reaction-diffusion.js';\nimport type { ProceduralTextureProps } from './procedural-texture.js';\nimport { rasterizeField } from \"./wasm/memory.js\";\n/**\n * Borrowed sources are valid only during the synchronous renderer callback.\n *\n * @see {@link TextureRenderer}\n */\nexport interface TextureRenderFrame {\n  /** Current offscreen texture raster available to the presentation callback. See {@link TextureRenderFrame}. */\n  readonly source: OffscreenCanvas;\n  /** White with texture intensity as alpha, allocated lazily on first access. */\n  readonly mask: OffscreenCanvas;\n  /**\n   * Horizontal extent in the units of the containing geometry or surface. See\n   * {@link TextureRenderFrame}.\n   */\n  readonly width: number;\n  /**\n   * Vertical extent in the units of the containing geometry or surface. See\n   * {@link TextureRenderFrame}.\n   */\n  readonly height: number;\n  /** Width of the underlying texture raster in pixels. See {@link TextureRenderFrame}. */\n  readonly textureWidth: number;\n  /** Height of the underlying texture raster in pixels. See {@link TextureRenderFrame}. */\n  readonly textureHeight: number;\n}\n/**\n * Custom presentation callback receiving an offscreen context and the current texture raster\n * frame.\n *\n * @param context - Offscreen drawing context to paint into.\n * @param texture - Current texture surface and frame metadata. See {@link TextureRenderFrame}.\n *\n * @see {@link TextureRenderFrame}\n * @see {@link ReactionDiffusionProps}\n * @see {@link ProceduralTextureProps}\n */\nexport type TextureRenderer = (\n  context: OffscreenCanvasRenderingContext2D,\n  texture: Readonly<TextureRenderFrame>,\n) => void;\n\nexport class TextureRaster {\n  readonly surface: OffscreenCanvas;\n  readonly context: OffscreenCanvasRenderingContext2D;\n  private maskRaster?: () => ImageData;\n  private maskSurface?: OffscreenCanvas;\n  private maskContext?: OffscreenCanvasRenderingContext2D;\n  private maskDirty = true;\n  constructor(\n    readonly width: number,\n    readonly height: number,\n  ) {\n    this.surface = new OffscreenCanvas(width, height);\n    const context = this.surface.getContext(\"2d\");\n    if (!context) {\n      this.surface.width = this.surface.height = 0;\n      throw new Error(\"Textures require offscreen Canvas 2D.\");\n    }\n    this.context = context;\n  }\n  update(field: Float32Array, lut: Uint8ClampedArray, gain = 1) {\n    const raster = rasterizeField(field, lut, gain);\n    this.maskRaster = raster.mask;\n    this.context.putImageData(raster.image, 0, 0);\n    this.maskDirty = true;\n  }\n  private getMask(): OffscreenCanvas {\n    if (!this.maskSurface) {\n      this.maskSurface = new OffscreenCanvas(this.width, this.height);\n      this.maskContext = this.maskSurface.getContext(\"2d\") ?? undefined;\n      if (!this.maskContext)\n        throw new Error(\"Textures require offscreen Canvas 2D.\");\n    }\n    if (this.maskDirty) {\n      if (!this.maskRaster)\n        throw new Error(\"Texture mask requires a live WASM raster.\");\n      this.maskContext!.putImageData(this.maskRaster(), 0, 0);\n      this.maskDirty = false;\n    }\n    return this.maskSurface;\n  }\n  draw(\n    ctx: OffscreenCanvasRenderingContext2D,\n    width: number,\n    height: number,\n    backingWidth: number,\n    backingHeight: number,\n    render?: TextureRenderer,\n  ) {\n    ctx.save();\n    try {\n      ctx.resetTransform();\n      ctx.clearRect(0, 0, backingWidth, backingHeight);\n      if (width <= 0 || height <= 0) return;\n      ctx.scale(backingWidth / width, backingHeight / height);\n      if (render) {\n        const raster = this;\n        const result: unknown = render(\n          ctx,\n          Object.freeze({\n            source: this.surface,\n            get mask() {\n              return raster.getMask();\n            },\n            width,\n            height,\n            textureWidth: this.width,\n            textureHeight: this.height,\n          }),\n        );\n        if (result && typeof (result as { then?: unknown }).then === \"function\")\n          throw new TypeError(\"Texture render callbacks must be synchronous.\");\n      } else ctx.drawImage(this.surface, 0, 0, width, height);\n    } finally {\n      ctx.restore();\n    }\n  }\n  dispose() {\n    this.surface.width = this.surface.height = 0;\n    if (this.maskSurface) this.maskSurface.width = this.maskSurface.height = 0;\n    this.maskSurface = undefined;\n    this.maskContext = undefined;\n\n    this.maskRaster = undefined;\n  }\n}\n"],
+  "mappings": "AAEA,SAAS,sBAAsB;AA0CxB,MAAM,cAAc;AAAA,EAOzB,YACW,OACA,QACT;AAFS;AACA;AAET,SAAK,UAAU,IAAI,gBAAgB,OAAO,MAAM;AAChD,UAAM,UAAU,KAAK,QAAQ,WAAW,IAAI;AAC5C,QAAI,CAAC,SAAS;AACZ,WAAK,QAAQ,QAAQ,KAAK,QAAQ,SAAS;AAC3C,YAAM,IAAI,MAAM,uCAAuC;AAAA,IACzD;AACA,SAAK,UAAU;AAAA,EACjB;AAAA,EAVW;AAAA,EACA;AAAA,EARF;AAAA,EACA;AAAA,EACD;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAY;AAAA,EAapB,OAAO,OAAqB,KAAwB,OAAO,GAAG;AAC5D,UAAM,SAAS,eAAe,OAAO,KAAK,IAAI;AAC9C,SAAK,aAAa,OAAO;AACzB,SAAK,QAAQ,aAAa,OAAO,OAAO,GAAG,CAAC;AAC5C,SAAK,YAAY;AAAA,EACnB;AAAA,EACQ,UAA2B;AACjC,QAAI,CAAC,KAAK,aAAa;AACrB,WAAK,cAAc,IAAI,gBAAgB,KAAK,OAAO,KAAK,MAAM;AAC9D,WAAK,cAAc,KAAK,YAAY,WAAW,IAAI,KAAK;AACxD,UAAI,CAAC,KAAK;AACR,cAAM,IAAI,MAAM,uCAAuC;AAAA,IAC3D;AACA,QAAI,KAAK,WAAW;AAClB,UAAI,CAAC,KAAK;AACR,cAAM,IAAI,MAAM,2CAA2C;AAC7D,WAAK,YAAa,aAAa,KAAK,WAAW,GAAG,GAAG,CAAC;AACtD,WAAK,YAAY;AAAA,IACnB;AACA,WAAO,KAAK;AAAA,EACd;AAAA,EACA,KACE,KACA,OACA,QACA,cACA,eACA,QACA;AACA,QAAI,KAAK;AACT,QAAI;AACF,UAAI,eAAe;AACnB,UAAI,UAAU,GAAG,GAAG,cAAc,aAAa;AAC/C,UAAI,SAAS,KAAK,UAAU,EAAG;AAC/B,UAAI,MAAM,eAAe,OAAO,gBAAgB,MAAM;AACtD,UAAI,QAAQ;AACV,cAAM,SAAS;AACf,cAAM,SAAkB;AAAA,UACtB;AAAA,UACA,OAAO,OAAO;AAAA,YACZ,QAAQ,KAAK;AAAA,YACb,IAAI,OAAO;AACT,qBAAO,OAAO,QAAQ;AAAA,YACxB;AAAA,YACA;AAAA,YACA;AAAA,YACA,cAAc,KAAK;AAAA,YACnB,eAAe,KAAK;AAAA,UACtB,CAAC;AAAA,QACH;AACA,YAAI,UAAU,OAAQ,OAA8B,SAAS;AAC3D,gBAAM,IAAI,UAAU,+CAA+C;AAAA,MACvE,MAAO,KAAI,UAAU,KAAK,SAAS,GAAG,GAAG,OAAO,MAAM;AAAA,IACxD,UAAE;AACA,UAAI,QAAQ;AAAA,IACd;AAAA,EACF;AAAA,EACA,UAAU;AACR,SAAK,QAAQ,QAAQ,KAAK,QAAQ,SAAS;AAC3C,QAAI,KAAK,YAAa,MAAK,YAAY,QAAQ,KAAK,YAAY,SAAS;AACzE,SAAK,cAAc;AACnB,SAAK,cAAc;AAEnB,SAAK,aAAa;AAAA,EACpB;AACF;",
+  "names": []
+}

package/dist/features/textures/lib/procedural-texture.d.ts

@@ -0,0 +1,44 @@
+import { type TexturePalette, type TextureResolution } from "./palette.js";
+import { type TextureRenderer } from "./presentation.js";
+import { type TextureKind } from "./material-field.js";
+/**
+ * Authored inputs for ProceduralTexture, including the declared data and presentation options.
+ *
+ * @see {@link TextureKind}
+ * @see {@link TextureResolution}
+ * @see {@link TexturePalette}
+ * @see {@link TextureRenderer}
+ * @see {@link ProceduralTexture}
+ */
+export interface ProceduralTextureProps {
+    /** Selects the kind of geometry, material, or result. See {@link TextureKind}. */
+    readonly kind: TextureKind;
+    /**
+     * Seed used for deterministic sampling or simulation initialization. See
+     * {@link ProceduralTextureProps}.
+     */
+    readonly seed?: number;
+    /** Dimensions of the simulation or raster grid. See {@link TextureResolution}. */
+    readonly resolution?: TextureResolution;
+    /** Feature frequency across the texture, from 1 to 32. */
+    readonly scale?: number;
+    /** Distortion, grain strength, or cellular jitter, from 0 to 1. */
+    readonly detail?: number;
+    /** Ordered colors used to present texture intensity. See {@link TexturePalette}. */
+    readonly palette?: TexturePalette;
+    /**
+     * Renders the current data or resources using the supplied context. See {@link TextureRenderer}
+     * .
+     */
+    readonly render?: TextureRenderer;
+}
+/**
+ * A seeded static material. It requests no continuing animation frames.
+ *
+ * @param props - Authored component inputs, supplied through JSX or createElement. See the linked
+ * props and style types.
+ * @throws When called directly; Pibbl mounts this component through JSX or createElement.
+ *
+ * @see {@link ProceduralTextureProps}
+ */
+export declare const ProceduralTexture: import("@pibbl/core").PibblComponent<ProceduralTextureProps & import("@pibbl/core").PibblRenderLayerComponentProps>;

package/dist/features/textures/lib/procedural-texture.js

@@ -0,0 +1,110 @@
+import { releaseField } from "./wasm/memory.js";
+import { defineRenderLayer } from "@pibbl/core";
+import {
+  paletteLut,
+  texturePalettes,
+  validateResolution,
+  validateSeed
+} from "./palette.js";
+import { TextureRaster } from "./presentation.js";
+import { materialField } from "./material-field.js";
+function normalize(p) {
+  if (!["marble", "paper", "cellular"].includes(p.kind))
+    throw new TypeError("Unknown procedural texture kind.");
+  const scale = p.scale ?? 6, detail = p.detail ?? 0.65;
+  if (!Number.isFinite(scale) || scale < 1 || scale > 32 || !Number.isFinite(detail) || detail < 0 || detail > 1)
+    throw new RangeError(
+      "Texture scale must be in [1,32] and detail in [0,1]."
+    );
+  return {
+    kind: p.kind,
+    seed: validateSeed(p.seed),
+    resolution: validateResolution(p.resolution),
+    scale,
+    detail,
+    palette: [...p.palette ?? texturePalettes.porcelain],
+    render: p.render
+  };
+}
+function generate(o, previous) {
+  return materialField(
+    o.resolution.width,
+    o.resolution.height,
+    o.kind,
+    o.seed,
+    o.scale,
+    o.detail,
+    previous
+  );
+}
+const ProceduralTexture = /* @__PURE__ */ defineRenderLayer({
+  create(context, props) {
+    const options = normalize(props), lut = paletteLut(options.palette);
+    const output = context.canvas.getContext("2d");
+    if (!output) throw new Error("ProceduralTexture requires Canvas 2D.");
+    const raster = new TextureRaster(
+      options.resolution.width,
+      options.resolution.height
+    );
+    try {
+      return {
+        options,
+        lut,
+        output,
+        raster,
+        field: generate(options),
+        dirty: true
+      };
+    } catch (error) {
+      raster.dispose();
+      throw error;
+    }
+  },
+  update(r, props) {
+    const next = normalize(props), old = r.options;
+    if (next.palette.join() !== old.palette.join()) {
+      r.lut = paletteLut(next.palette);
+      r.dirty = true;
+    }
+    const resized = next.resolution.width !== old.resolution.width || next.resolution.height !== old.resolution.height;
+    if (resized || next.kind !== old.kind || next.seed !== old.seed || next.scale !== old.scale || next.detail !== old.detail) {
+      const field = generate(next, r.field);
+      if (resized) {
+        const raster = new TextureRaster(
+          next.resolution.width,
+          next.resolution.height
+        );
+        r.raster.dispose();
+        r.raster = raster;
+      }
+      if (field !== r.field) releaseField(r.field);
+      r.field = field;
+      r.dirty = true;
+    }
+    r.options = next;
+  },
+  render(r, _frame, context) {
+    if (r.dirty) {
+      r.raster.update(r.field, r.lut);
+      r.dirty = false;
+    }
+    r.raster.draw(
+      r.output,
+      context.size.width,
+      context.size.height,
+      context.size.backingWidth,
+      context.size.backingHeight,
+      r.options.render
+    );
+  },
+  dispose(r) {
+    r.raster.dispose();
+    releaseField(r.field);
+    r.field = new Float32Array(0);
+    r.options.render = void 0;
+  }
+});
+export {
+  ProceduralTexture
+};
+//# sourceMappingURL=procedural-texture.js.map

package/dist/features/textures/lib/procedural-texture.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/textures/lib/procedural-texture.ts"],
+  "sourcesContent": ["import { releaseField } from \"./wasm/memory.js\";\nimport { defineRenderLayer } from \"@pibbl/core\";\nimport {\n  paletteLut,\n  texturePalettes,\n  validateResolution,\n  validateSeed,\n  type TexturePalette,\n  type TextureResolution,\n} from \"./palette.js\";\nimport { TextureRaster, type TextureRenderer } from \"./presentation.js\";\nimport { materialField, type TextureKind } from \"./material-field.js\";\n\n/**\n * Authored inputs for ProceduralTexture, including the declared data and presentation options.\n *\n * @see {@link TextureKind}\n * @see {@link TextureResolution}\n * @see {@link TexturePalette}\n * @see {@link TextureRenderer}\n * @see {@link ProceduralTexture}\n */\nexport interface ProceduralTextureProps {\n  /** Selects the kind of geometry, material, or result. See {@link TextureKind}. */\n  readonly kind: TextureKind;\n  /**\n   * Seed used for deterministic sampling or simulation initialization. See\n   * {@link ProceduralTextureProps}.\n   */\n  readonly seed?: number;\n  /** Dimensions of the simulation or raster grid. See {@link TextureResolution}. */\n  readonly resolution?: TextureResolution;\n  /** Feature frequency across the texture, from 1 to 32. */\n  readonly scale?: number;\n  /** Distortion, grain strength, or cellular jitter, from 0 to 1. */\n  readonly detail?: number;\n  /** Ordered colors used to present texture intensity. See {@link TexturePalette}. */\n  readonly palette?: TexturePalette;\n  /**\n   * Renders the current data or resources using the supplied context. See {@link TextureRenderer}\n   * .\n   */\n  readonly render?: TextureRenderer;\n}\nfunction normalize(p: ProceduralTextureProps) {\n  if (![\"marble\", \"paper\", \"cellular\"].includes(p.kind))\n    throw new TypeError(\"Unknown procedural texture kind.\");\n  const scale = p.scale ?? 6,\n    detail = p.detail ?? 0.65;\n  if (\n    !Number.isFinite(scale) ||\n    scale < 1 ||\n    scale > 32 ||\n    !Number.isFinite(detail) ||\n    detail < 0 ||\n    detail > 1\n  )\n    throw new RangeError(\n      \"Texture scale must be in [1,32] and detail in [0,1].\",\n    );\n  return {\n    kind: p.kind,\n    seed: validateSeed(p.seed),\n    resolution: validateResolution(p.resolution),\n    scale,\n    detail,\n    palette: [...(p.palette ?? texturePalettes.porcelain)],\n    render: p.render,\n  };\n}\ntype Options = ReturnType<typeof normalize>;\ninterface Resources {\n  options: Options;\n  field: Float32Array;\n  raster: TextureRaster;\n  lut: Uint8ClampedArray;\n  output: OffscreenCanvasRenderingContext2D;\n  dirty: boolean;\n}\nfunction generate(o: Options, previous?: Float32Array) {\n  return materialField(\n    o.resolution.width,\n    o.resolution.height,\n    o.kind,\n    o.seed,\n    o.scale,\n    o.detail,\n    previous,\n  );\n}\n\n/**\n * A seeded static material. It requests no continuing animation frames.\n *\n * @param props - Authored component inputs, supplied through JSX or createElement. See the linked\n * props and style types.\n * @throws When called directly; Pibbl mounts this component through JSX or createElement.\n *\n * @see {@link ProceduralTextureProps}\n */\nexport const ProceduralTexture = /* @__PURE__ */ defineRenderLayer<\n  ProceduralTextureProps,\n  Resources\n>({\n  create(context, props) {\n    const options = normalize(props),\n      lut = paletteLut(options.palette);\n    const output = context.canvas.getContext(\"2d\");\n    if (!output) throw new Error(\"ProceduralTexture requires Canvas 2D.\");\n    const raster = new TextureRaster(\n      options.resolution.width,\n      options.resolution.height,\n    );\n    try {\n      return {\n        options,\n        lut,\n        output,\n        raster,\n        field: generate(options),\n        dirty: true,\n      };\n    } catch (error) {\n      raster.dispose();\n      throw error;\n    }\n  },\n  update(r, props) {\n    const next = normalize(props),\n      old = r.options;\n    if (next.palette.join() !== old.palette.join()) {\n      r.lut = paletteLut(next.palette);\n      r.dirty = true;\n    }\n    const resized =\n      next.resolution.width !== old.resolution.width ||\n      next.resolution.height !== old.resolution.height;\n    if (\n      resized ||\n      next.kind !== old.kind ||\n      next.seed !== old.seed ||\n      next.scale !== old.scale ||\n      next.detail !== old.detail\n    ) {\n      const field = generate(next, r.field);\n      if (resized) {\n        const raster = new TextureRaster(\n          next.resolution.width,\n          next.resolution.height,\n        );\n        r.raster.dispose();\n        r.raster = raster;\n      }\n      if (field !== r.field) releaseField(r.field);\n      r.field = field;\n      r.dirty = true;\n    }\n    r.options = next;\n  },\n  render(r, _frame, context) {\n    if (r.dirty) {\n      r.raster.update(r.field, r.lut);\n      r.dirty = false;\n    }\n    r.raster.draw(\n      r.output,\n      context.size.width,\n      context.size.height,\n      context.size.backingWidth,\n      context.size.backingHeight,\n      r.options.render,\n    );\n  },\n  dispose(r) {\n    r.raster.dispose();\n    releaseField(r.field);\n    r.field = new Float32Array(0);\n    r.options.render = undefined;\n  },\n});\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAC7B,SAAS,yBAAyB;AAClC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AACP,SAAS,qBAA2C;AACpD,SAAS,qBAAuC;AAiChD,SAAS,UAAU,GAA2B;AAC5C,MAAI,CAAC,CAAC,UAAU,SAAS,UAAU,EAAE,SAAS,EAAE,IAAI;AAClD,UAAM,IAAI,UAAU,kCAAkC;AACxD,QAAM,QAAQ,EAAE,SAAS,GACvB,SAAS,EAAE,UAAU;AACvB,MACE,CAAC,OAAO,SAAS,KAAK,KACtB,QAAQ,KACR,QAAQ,MACR,CAAC,OAAO,SAAS,MAAM,KACvB,SAAS,KACT,SAAS;AAET,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AACF,SAAO;AAAA,IACL,MAAM,EAAE;AAAA,IACR,MAAM,aAAa,EAAE,IAAI;AAAA,IACzB,YAAY,mBAAmB,EAAE,UAAU;AAAA,IAC3C;AAAA,IACA;AAAA,IACA,SAAS,CAAC,GAAI,EAAE,WAAW,gBAAgB,SAAU;AAAA,IACrD,QAAQ,EAAE;AAAA,EACZ;AACF;AAUA,SAAS,SAAS,GAAY,UAAyB;AACrD,SAAO;AAAA,IACL,EAAE,WAAW;AAAA,IACb,EAAE,WAAW;AAAA,IACb,EAAE;AAAA,IACF,EAAE;AAAA,IACF,EAAE;AAAA,IACF,EAAE;AAAA,IACF;AAAA,EACF;AACF;AAWO,MAAM,oBAAoC,kCAG/C;AAAA,EACA,OAAO,SAAS,OAAO;AACrB,UAAM,UAAU,UAAU,KAAK,GAC7B,MAAM,WAAW,QAAQ,OAAO;AAClC,UAAM,SAAS,QAAQ,OAAO,WAAW,IAAI;AAC7C,QAAI,CAAC,OAAQ,OAAM,IAAI,MAAM,uCAAuC;AACpE,UAAM,SAAS,IAAI;AAAA,MACjB,QAAQ,WAAW;AAAA,MACnB,QAAQ,WAAW;AAAA,IACrB;AACA,QAAI;AACF,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,OAAO,SAAS,OAAO;AAAA,QACvB,OAAO;AAAA,MACT;AAAA,IACF,SAAS,OAAO;AACd,aAAO,QAAQ;AACf,YAAM;AAAA,IACR;AAAA,EACF;AAAA,EACA,OAAO,GAAG,OAAO;AACf,UAAM,OAAO,UAAU,KAAK,GAC1B,MAAM,EAAE;AACV,QAAI,KAAK,QAAQ,KAAK,MAAM,IAAI,QAAQ,KAAK,GAAG;AAC9C,QAAE,MAAM,WAAW,KAAK,OAAO;AAC/B,QAAE,QAAQ;AAAA,IACZ;AACA,UAAM,UACJ,KAAK,WAAW,UAAU,IAAI,WAAW,SACzC,KAAK,WAAW,WAAW,IAAI,WAAW;AAC5C,QACE,WACA,KAAK,SAAS,IAAI,QAClB,KAAK,SAAS,IAAI,QAClB,KAAK,UAAU,IAAI,SACnB,KAAK,WAAW,IAAI,QACpB;AACA,YAAM,QAAQ,SAAS,MAAM,EAAE,KAAK;AACpC,UAAI,SAAS;AACX,cAAM,SAAS,IAAI;AAAA,UACjB,KAAK,WAAW;AAAA,UAChB,KAAK,WAAW;AAAA,QAClB;AACA,UAAE,OAAO,QAAQ;AACjB,UAAE,SAAS;AAAA,MACb;AACA,UAAI,UAAU,EAAE,MAAO,cAAa,EAAE,KAAK;AAC3C,QAAE,QAAQ;AACV,QAAE,QAAQ;AAAA,IACZ;AACA,MAAE,UAAU;AAAA,EACd;AAAA,EACA,OAAO,GAAG,QAAQ,SAAS;AACzB,QAAI,EAAE,OAAO;AACX,QAAE,OAAO,OAAO,EAAE,OAAO,EAAE,GAAG;AAC9B,QAAE,QAAQ;AAAA,IACZ;AACA,MAAE,OAAO;AAAA,MACP,EAAE;AAAA,MACF,QAAQ,KAAK;AAAA,MACb,QAAQ,KAAK;AAAA,MACb,QAAQ,KAAK;AAAA,MACb,QAAQ,KAAK;AAAA,MACb,EAAE,QAAQ;AAAA,IACZ;AAAA,EACF;AAAA,EACA,QAAQ,GAAG;AACT,MAAE,OAAO,QAAQ;AACjB,iBAAa,EAAE,KAAK;AACpB,MAAE,QAAQ,IAAI,aAAa,CAAC;AAC5B,MAAE,QAAQ,SAAS;AAAA,EACrB;AACF,CAAC;",
+  "names": []
+}

package/dist/features/textures/lib/rain-drops.d.ts

@@ -0,0 +1,96 @@
+import { type TextureRecipe } from "@pibbl/core";
+/**
+ * Rain rate, gravity, initial drops, condensation, trail, and outline controls for a raindrop texture.
+ *
+ * @see {@link rainDrops}
+ */
+export interface RainDropsOptions {
+    /**
+     * Seed used for deterministic sampling or simulation initialization. See
+     * {@link RainDropsOptions}.
+     */
+    readonly seed?: number;
+    /** New beads per second, from 0 through 120. */
+    readonly rainRate?: number;
+    /** Downward acceleration multiplier, from 0 through 10. */
+    readonly gravity?: number;
+    /** Number of drops seeded before continuous rain starts. See {@link RainDropsOptions}. */
+    readonly initialDrops?: number;
+    /** Whether simulation or playback advancement is suspended. See {@link RainDropsOptions}. */
+    readonly paused?: boolean;
+    /** Fine droplet film coverage, from 0 (clear) through 1 (mist). */
+    readonly condensation?: number;
+    /** Seconds controlling trail drying and condensation recovery, from 0 through 60. */
+    readonly trailPersistence?: number;
+    /** Residual water left behind a moving drop, from 0 through 1. */
+    readonly trailStrength?: number;
+    /** Outline and path variation, from 0 (smooth) through 1. */
+    readonly irregularity?: number;
+}
+/**
+ * Pause, reset, finger-wipe, release, and localized nudge commands for a raindrop texture.
+ *
+ * @see {@link rainDrops}
+ */
+export type RainDropsMessage = {
+    /** The literal "pause" identifying this variant. See {@link RainDropsMessage}. */
+    readonly type: "pause";
+    /** Whether simulation or playback advancement is suspended. See {@link RainDropsMessage}. */
+    readonly paused: boolean;
+} | {
+    /** The literal "reset" identifying this variant. See {@link RainDropsMessage}. */
+    readonly type: "reset";
+}
+/** Begin or move one finger contact; successive positions wipe a continuous path. */
+ | {
+    /** The literal "finger" identifying this variant. See {@link RainDropsMessage}. */
+    readonly type: "finger";
+    /**
+     * Horizontal coordinate or displacement in the containing coordinate system. See
+     * {@link RainDropsMessage}.
+     */
+    readonly x: number;
+    /**
+     * Vertical coordinate or displacement in the containing coordinate system. See
+     * {@link RainDropsMessage}.
+     */
+    readonly y: number;
+    /** Radius in the coordinate system of this geometry or effect. See {@link RainDropsMessage}. */
+    readonly radius?: number;
+} | {
+    /** The literal "release" identifying this variant. See {@link RainDropsMessage}. */
+    readonly type: "release";
+}
+/** Center and movement use normalized width/height; radius uses the shorter side. */
+ | {
+    /** The literal "nudge" identifying this variant. See {@link RainDropsMessage}. */
+    readonly type: "nudge";
+    /**
+     * Horizontal coordinate or displacement in the containing coordinate system. See
+     * {@link RainDropsMessage}.
+     */
+    readonly x: number;
+    /**
+     * Vertical coordinate or displacement in the containing coordinate system. See
+     * {@link RainDropsMessage}.
+     */
+    readonly y: number;
+    /** Horizontal displacement applied by the interaction. See {@link RainDropsMessage}. */
+    readonly dx: number;
+    /** Vertical displacement applied by the interaction. See {@link RainDropsMessage}. */
+    readonly dy: number;
+    /** Radius in the coordinate system of this geometry or effect. See {@link RainDropsMessage}. */
+    readonly radius?: number;
+};
+/**
+ * A seeded rain-on-glass displacement map, advanced by Pibbl's scheduler.
+ *
+ * @param options - Raindrop simulation and appearance settings. See {@link RainDropsOptions}.
+ * @returns A raindrop texture recipe accepting raindrop messages. See {@link TextureRecipe} ,
+ * {@link RainDropsMessage} .
+ *
+ * @see {@link RainDropsOptions}
+ * @see {@link TextureRecipe}
+ * @see {@link RainDropsMessage}
+ */
+export declare function rainDrops(options?: RainDropsOptions): TextureRecipe<RainDropsMessage>;