@swf2es/native 0.0.0-stage → 0.1.0

package/src/render/draw-kernel.ts

@@ -0,0 +1,268 @@
+// BitmapData.draw of a bitmap in the normal blend mode, in the render
+// module (draw.zig), one call a draw. Each draw copies into the module's
+// input the rows of the source it reads and the destination's area, and
+// the area back out after: no source is kept between draws, which costs no
+// more than keeping them did for a game drawing hundreds of small bitmaps
+// a frame, and holds nothing for them. Its own instance, so that the
+// filters' calls (BitmapKernel) do not reset its input, let go of when its
+// owner says it went idle, and after a draw that grew it past KEEP_BYTES.
+import { renderInstance } from "./module.js";
+
+interface DrawExports {
+  memory: WebAssembly.Memory;
+  resetArena(bytes: number): number;
+  drawPixels(params: number): number;
+  compositePixels(params: number): number;
+}
+
+/**
+ * A draw, which its caller keeps and fills for each: the source's pixels
+ * and size and the rows it reads, the destination's pixels (read only) and
+ * width and the area drawn, and the numbers draw.zig takes.
+ */
+export interface DrawJob {
+  source: Uint32Array;
+  sourceWidth: number;
+  sourceHeight: number;
+  /** The first row the draw reads, and how many. */
+  sourceTop: number;
+  sourceRows: number;
+  into: Uint32Array;
+  intoWidth: number;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  /** composite's, unscaled at whole pixels (tx, ty), rather than drawBitmap's through the matrix. */
+  moved: boolean;
+  /** The matrix's inverse: a, b, c, d, tx, ty. */
+  inverse: Float64Array;
+  /** The prepared colour transform, multipliers in 256ths then offsets, red, green, blue, alpha. */
+  transform: Float64Array;
+  tx: number;
+  ty: number;
+  flags: number;
+}
+
+/** draw.zig's flags. */
+export const DRAW_SMOOTH = 1;
+export const DRAW_TRANSFORM = 2;
+export const DRAW_OPAQUE = 4;
+export const DRAW_SKIP_ZERO_ALPHA = 8;
+
+// draw.zig's results.
+const INVALID = 0;
+const WRITTEN = 2;
+/** draw.zig's DrawParams: 14 doubles, then 14 words. */
+const PARAMS = 168;
+/** The most a draw copies in, its source's rows and its area; a larger one is drawn by the caller. */
+const DRAWN_BYTES = 32 << 20;
+/** The input a new instance takes first. */
+const FIRST_BYTES = 1 << 20;
+/** The memory an instance keeps after a draw; past it, the instance is let go of. */
+const KEEP_BYTES = 16 << 20;
+
+/**
+ * What a draw did: refused, where the module could not take it and the
+ * caller draws it itself; drew nothing; or wrote the area, which `writeBack`
+ * then copies into the store.
+ */
+export type DrawResult = "refused" | "untouched" | "written";
+
+export class DrawKernel {
+  private wasm: DrawExports | null = null;
+  /** Whether making an instance failed once, after which the module is never tried again. */
+  private broken = false;
+  /** The input resetArena gave, and its bytes. */
+  private input = 0;
+  private inputBytes = 0;
+  private buffer: ArrayBuffer | null = null;
+  private words = new Uint32Array(0);
+  private doubles = new Float64Array(0);
+  private ints = new Int32Array(0);
+  /** Where the last draw's area lies in the input. */
+  private area = 0;
+  /** Whether the module drew since `idle` last asked. */
+  private busy = false;
+  /** How many draws the module took. */
+  drawn = 0;
+
+  /** A job to fill for each draw. */
+  static job(): DrawJob {
+    return {
+      source: new Uint32Array(0),
+      sourceWidth: 0,
+      sourceHeight: 0,
+      sourceTop: 0,
+      sourceRows: 0,
+      into: new Uint32Array(0),
+      intoWidth: 0,
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0,
+      moved: false,
+      inverse: new Float64Array(6),
+      transform: new Float64Array(8),
+      tx: 0,
+      ty: 0,
+      flags: 0,
+    };
+  }
+
+  /** Whether an instance is held, with its memory. */
+  get held(): boolean {
+    return this.wasm !== null;
+  }
+
+  /** The job drawn in the module; never a write to the destination, which `writeBack` makes. */
+  draw(job: DrawJob): DrawResult {
+    try {
+      return this.run(job);
+    } catch {
+      // A trap: never resume that instance.
+      this.release();
+      return "refused";
+    }
+  }
+
+  /** The area the last draw wrote, copied into `into`. */
+  writeBack(job: DrawJob, into: Uint32Array): void {
+    const { x, y, width: w, height: h, intoWidth } = job;
+    const base = this.area >> 2;
+    this.refresh();
+    const words = this.words;
+    for (let row = 0; row < h; row++) {
+      const at = base + row * w;
+      into.set(words.subarray(at, at + w), (y + row) * intoWidth + x);
+    }
+  }
+
+  /** Whether the module drew nothing since this was last asked. */
+  idle(): boolean {
+    const idle = !this.busy;
+    this.busy = false;
+    return idle;
+  }
+
+  /** The instance let go of, and its memory with it; the next draw makes another. */
+  release(): void {
+    this.wasm = null;
+    this.buffer = null;
+    this.words = new Uint32Array(0);
+    this.doubles = new Float64Array(0);
+    this.ints = new Int32Array(0);
+    this.input = 0;
+    this.inputBytes = 0;
+  }
+
+  private run(job: DrawJob): DrawResult {
+    const { sourceWidth: sw, sourceRows: rows, width: w, height: h } = job;
+    const sourceBytes = sw * rows * 4;
+    const areaBytes = w * h * 4;
+    if (
+      job.source.length !== sw * job.sourceHeight ||
+      sourceBytes + areaBytes > DRAWN_BYTES ||
+      !this.room(PARAMS + sourceBytes + areaBytes)
+    ) {
+      return "refused";
+    }
+
+    const wasm = this.wasm as DrawExports;
+    this.refresh();
+    const { words, doubles, ints } = this;
+    const p = this.input;
+    const src = p + PARAMS;
+    this.area = src + sourceBytes;
+    const top = job.sourceTop * sw;
+    words.set(job.source.subarray(top, top + rows * sw), src >> 2);
+
+    const base = this.area >> 2;
+    const { into, intoWidth, x, y } = job;
+    for (let row = 0; row < h; row++) {
+      const at = (y + row) * intoWidth + x;
+      words.set(into.subarray(at, at + w), base + row * w);
+    }
+
+    const d = p >> 3;
+    doubles.set(job.inverse, d);
+    doubles.set(job.transform, d + 6);
+    const i = (p + 112) >> 2;
+    words[i] = src;
+    words[i + 1] = sw;
+    words[i + 2] = job.sourceHeight;
+    words[i + 3] = this.area;
+    ints[i + 4] = x;
+    ints[i + 5] = y;
+    words[i + 6] = w;
+    words[i + 7] = h;
+    words[i + 8] = job.flags;
+    ints[i + 9] = job.tx;
+    ints[i + 10] = job.ty;
+    words[i + 11] = job.sourceTop;
+    words[i + 12] = rows;
+    words[i + 13] = 0;
+    const result = job.moved ? wasm.compositePixels(p) : wasm.drawPixels(p);
+    if (result === INVALID) {
+      return "refused";
+    }
+
+    this.drawn++;
+    this.busy = true;
+    return result === WRITTEN ? "written" : "untouched";
+  }
+
+  /**
+   * Whether the input holds `bytes`: an instance made where there is none,
+   * one grown past KEEP_BYTES made anew, and the input taken anew where it
+   * is smaller.
+   */
+  private room(bytes: number): boolean {
+    if (this.broken) {
+      return false;
+    }
+
+    // Grown past what it keeps by a large draw before, it goes, and its memory with it.
+    if (this.wasm && this.wasm.memory.buffer.byteLength > KEEP_BYTES) {
+      this.release();
+    }
+
+    if (this.wasm && this.inputBytes >= bytes) {
+      return true;
+    }
+
+    if (!this.wasm) {
+      try {
+        this.wasm = renderInstance(() => {
+          throw new Error("the draw kernel takes no tessellator");
+        }) as unknown as DrawExports;
+      } catch {
+        this.broken = true;
+        return false;
+      }
+    }
+
+    // Half again what is asked, so that a few larger draws do not each take it anew.
+    const want = Math.max(FIRST_BYTES, bytes + (bytes >> 1));
+    this.input = this.wasm.resetArena(want);
+    if (!this.input) {
+      // Out of memory: the instance goes, and the next draw that fits makes another.
+      this.release();
+      return false;
+    }
+
+    this.inputBytes = want;
+    return true;
+  }
+
+  /** The views of the memory made again where it grew, which detached them. */
+  private refresh(): void {
+    const buffer = (this.wasm as DrawExports).memory.buffer;
+    if (buffer !== this.buffer) {
+      this.buffer = buffer;
+      this.words = new Uint32Array(buffer);
+      this.doubles = new Float64Array(buffer);
+      this.ints = new Int32Array(buffer);
+    }
+  }
+}

package/src/render/dxt-encoder.ts

@@ -0,0 +1,121 @@
+// Compressed texture uploads, one whole level at a time in dxt.zig. The
+// input is kept between levels and grown only as needed; the result is a
+// view to consume before the next call, as context3d's TS encoder gives.
+import { renderInstance } from "./module.js";
+
+interface DxtExports {
+  memory: WebAssembly.Memory;
+  resetArena(bytes: number): number;
+  encodeDxt(
+    source: number,
+    destination: number,
+    width: number,
+    height: number,
+    alpha: number,
+  ): number;
+}
+
+/** Enough to keep a 2048² DXT5 upload's input and output, including growth slack. */
+const KEEP_BYTES = 32 << 20;
+const FIRST_BYTES = 64 << 10;
+
+export class DxtEncoder {
+  private wasm: DxtExports | null = null;
+  private broken = false;
+  private input = 0;
+  private inputBytes = 0;
+  /** Successful native encodes, so a reference comparison can rule out falling back. */
+  encoded = 0;
+
+  /** The memory kept now: a larger level's instance goes before the next call. */
+  get capacity(): number {
+    return this.wasm?.memory.buffer.byteLength ?? 0;
+  }
+
+  /** Release the instance and its memory; the next level makes another. */
+  release(): void {
+    this.wasm = null;
+    this.input = 0;
+    this.inputBytes = 0;
+  }
+
+  /**
+   * Top-down RGBA to DXT1 or DXT5, matching the TS encoder's blocks. The
+   * result stays valid until the next call; null leaves the level to TS.
+   */
+  encode = (rgba: Uint8Array, dxt5: boolean, width: number, height: number): Uint8Array | null => {
+    if (
+      !Number.isInteger(width) ||
+      !Number.isInteger(height) ||
+      width <= 0 ||
+      height <= 0 ||
+      width > 4096 ||
+      height > 4096 ||
+      rgba.length !== width * height * 4
+    ) {
+      return null;
+    }
+
+    try {
+      // A caller may use an earlier result as a smaller level's input. Preserve it if growth
+      // detaches that view, or a large earlier level causes its instance to be replaced.
+      if (this.wasm && rgba.buffer === this.wasm.memory.buffer) {
+        rgba = rgba.slice();
+      }
+
+      const length = Math.ceil(width / 4) * Math.ceil(height / 4) * (dxt5 ? 16 : 8);
+      if (!this.room(rgba.length + length)) {
+        return null;
+      }
+
+      const wasm = this.wasm as DxtExports;
+      const destination = this.input + rgba.length;
+      new Uint8Array(wasm.memory.buffer, this.input, rgba.length).set(rgba);
+      if (!wasm.encodeDxt(this.input, destination, width, height, dxt5 ? 1 : 0)) {
+        return null;
+      }
+
+      this.encoded++;
+      return new Uint8Array(wasm.memory.buffer, destination, length);
+    } catch {
+      // A trapped instance is never resumed, and a refused module leaves the TS path available.
+      this.release();
+      return null;
+    }
+  };
+
+  private room(bytes: number): boolean {
+    if (this.broken) {
+      return false;
+    }
+
+    if (this.wasm && this.wasm.memory.buffer.byteLength > KEEP_BYTES) {
+      this.release();
+    }
+
+    if (this.wasm && this.inputBytes >= bytes) {
+      return true;
+    }
+
+    if (!this.wasm) {
+      try {
+        this.wasm = renderInstance(() => {
+          throw new Error("the DXT encoder takes no tessellator");
+        }) as unknown as DxtExports;
+      } catch {
+        this.broken = true;
+        return false;
+      }
+    }
+
+    const want = Math.max(FIRST_BYTES, bytes + Math.floor(bytes / 2));
+    this.input = this.wasm.resetArena(want);
+    if (!this.input) {
+      this.release();
+      return false;
+    }
+
+    this.inputBytes = want;
+    return true;
+  }
+}

package/src/render/index.ts

@@ -0,0 +1,37 @@
+// The render module's wrappers, each over an instance of its own: fills
+// (Tessellator), a layer's lines (LineBuilder, also a Tessellator's
+// `tessellate.lines`) and BitmapData's CPU filters and pixel operations
+// (BitmapKernel), BitmapData.draw of a bitmap (DrawKernel), and DXT1/DXT5
+// texture encoding (DxtEncoder).
+export {
+  BitmapKernel,
+  type BitmapKernelOptions,
+  type BitmapRect,
+  type BitmapSource,
+  type ConvolutionFilter,
+  type CopyOp,
+  type LayerFilter,
+  type PerlinSetup,
+  type PixelRegion,
+} from "./bitmap-kernel.js";
+export {
+  DRAW_OPAQUE,
+  DRAW_SKIP_ZERO_ALPHA,
+  DRAW_SMOOTH,
+  DRAW_TRANSFORM,
+  type DrawJob,
+  DrawKernel,
+  type DrawResult,
+} from "./draw-kernel.js";
+export { DxtEncoder } from "./dxt-encoder.js";
+export { LineBuilder, type LineBuilderOptions, type LineGeometry } from "./lines.js";
+export {
+  type FillGeometry,
+  type FillTessellate,
+  PATH_CUBIC,
+  PATH_CURVE,
+  PATH_LINE,
+  PATH_MOVE,
+  Tessellator,
+  type TessellatorOptions,
+} from "./tessellator.js";

package/src/render/lines.ts

@@ -0,0 +1,161 @@
+import { renderInstance, renderModule } from "./module.js";
+
+/** A layer's lines as triangles: two floats a vertex, its colour, and three indices a triangle. */
+export interface LineGeometry {
+  positions: Float32Array;
+  colors: Uint32Array;
+  indices: Uint32Array;
+}
+
+interface NativeExports {
+  memory: WebAssembly.Memory;
+  lineInput(n: number): number;
+  lineHeader(): number;
+  lineBuild(length: number): number;
+  setLimit(n: number): void;
+  bandsOnly(on: number): void;
+}
+
+export interface LineBuilderOptions {
+  /** Maximum arena address, including the C stack; at most 128 MiB. */
+  memoryLimit?: number;
+  /** Drop instances larger than this after each call. Defaults to 8 MiB. */
+  retainMemory?: number;
+  /** Fill outlines by the module's bands alone, never by libtess2: for tests of the bands. */
+  bands?: boolean;
+}
+
+/**
+ * A shape layer's lines built in one call by the render module's
+ * strokes.zig, its outlines filled by the module's libtess2, or its bands
+ * where libtess2 fails: the caller writes the layer into input() as
+ * strokes.zig reads it (the player's scene/strokes.ts) and calls build()
+ * with its length. Its instance is its own, apart from any Tessellator's,
+ * and held to the same limits as a Tessellator's (TessellatorOptions),
+ * which pass them on: where a fill would have run out of memory, so do the
+ * lines, and none are drawn.
+ */
+export class LineBuilder {
+  private instance: NativeExports | null = null;
+  private view = new Float64Array(0);
+  private layout = new Uint32Array(0);
+  /** libtess2 trapped the last instance: the next fills its outlines by the bands alone. */
+  private trapped = false;
+  private lastUnwound = false;
+  private readonly limit: number;
+  private readonly keep: number;
+  private readonly bands: boolean;
+
+  constructor(options: LineBuilderOptions = {}) {
+    this.limit = options.memoryLimit ?? 128 << 20;
+    this.keep = options.retainMemory ?? 8 << 20;
+    this.bands = options.bands ?? false;
+    renderModule();
+  }
+
+  /** Whether the last build() unwound, which the next, in a new instance by the bands, may not. */
+  get unwound(): boolean {
+    return this.lastUnwound;
+  }
+
+  /** Current retained Wasm capacity. */
+  get capacity(): number {
+    return this.instance?.memory.buffer.byteLength ?? 0;
+  }
+
+  /** A view of at least `n` f64s of input, valid until build(); null where no instance could be made. */
+  input(n: number): Float64Array | null {
+    if (!this.instance) {
+      try {
+        this.instance = renderInstance(() => {
+          throw new Error("line tessellation allocation failed");
+        }) as unknown as NativeExports;
+      } catch {
+        return null;
+      }
+
+      this.instance.setLimit(this.limit);
+      this.instance.bandsOnly(Number(this.bands || this.trapped));
+    }
+
+    const x = this.instance;
+    if (n > this.view.length || this.view.buffer !== x.memory.buffer) {
+      const size = Math.max(n, this.view.length * 2, 1024);
+      const at = x.lineInput(size);
+      if (!at) {
+        this.dispose();
+        return null;
+      }
+
+      this.view = new Float64Array(x.memory.buffer, at, size);
+    }
+
+    return this.view;
+  }
+
+  /**
+   * The layer in the input's first `length` f64s, copied out in one
+   * block: null for none, undefined where the module refused it (a
+   * position not a number) or failed. Where libtess2 trapped, the next
+   * instance fills the layer's outlines by the bands alone, for the
+   * caller's next input() and build().
+   */
+  build(length: number): LineGeometry | null | undefined {
+    this.lastUnwound = false;
+    const x = this.instance;
+    if (!x) {
+      return undefined;
+    }
+
+    try {
+      const status = x.lineBuild(length);
+      // Built without unwinding: libtess2 again for the next.
+      if (this.trapped) {
+        this.trapped = false;
+        x.bandsOnly(Number(this.bands));
+      }
+
+      if (status !== 0) {
+        return undefined;
+      }
+
+      const [at, vertices, count] = this.header(x);
+      if (count === 0) {
+        return null;
+      }
+
+      const copy = x.memory.buffer.slice(at, at + (vertices * 3 + count) * 4);
+      return {
+        positions: new Float32Array(copy, 0, vertices * 2),
+        colors: new Uint32Array(copy, vertices * 8, vertices),
+        indices: new Uint32Array(copy, vertices * 12, count),
+      };
+    } catch {
+      // libtess2 unwound through the failure import: never resume that instance.
+      this.dispose();
+      this.trapped = true;
+      this.lastUnwound = true;
+      return undefined;
+    } finally {
+      if (this.capacity > this.keep) {
+        this.dispose();
+      }
+    }
+  }
+
+  /** strokes.zig's layout, read again where memory grew. */
+  private header(x: NativeExports): Uint32Array {
+    if (this.layout.buffer !== x.memory.buffer) {
+      this.layout = new Uint32Array(x.memory.buffer, x.lineHeader(), 3);
+    }
+
+    return this.layout;
+  }
+
+  /** The instance let go, its memory with it; the next input() makes another. */
+  dispose(): void {
+    this.instance = null;
+    this.view = new Float64Array(0);
+    this.layout = new Uint32Array(0);
+  }
+}

package/src/render/module.ts

@@ -0,0 +1,30 @@
+import { decodeBase64 } from "../base64.js";
+import { binary } from "./binary.js";
+
+let module: WebAssembly.Module | null = null;
+
+/**
+ * The render module (root.zig), compiled once and shared: the bitmap
+ * kernels, DXT encoder, tessellator and lines each make an instance of their
+ * own, so that each has its memory and lifecycle apart. It needs wasm
+ * SIMD throughout; this throws where the host refuses to compile it, as
+ * without SIMD or Wasm or under a CSP without 'wasm-unsafe-eval'.
+ */
+export function renderModule(): WebAssembly.Module {
+  module ??= new WebAssembly.Module(decodeBase64(binary));
+  return module;
+}
+
+/**
+ * What an instance imports: libtess2's longjmp, which `failure` must
+ * throw from, and the host's own sine and cosine, which the lines take so
+ * that theirs are the player's JS's to the last bit.
+ */
+function renderImports(failure: () => never): object {
+  return { env: { failure, sine: Math.sin, cosine: Math.cos } };
+}
+
+/** An instance of the module, its memory its own. */
+export function renderInstance(failure: () => never): Record<string, unknown> {
+  return new WebAssembly.Instance(renderModule(), renderImports(failure)).exports;
+}