@swf2es/player 0.0.0-stage → 0.1.1

package/src/scene/lines.ts

@@ -0,0 +1,322 @@
+// A shape layer's lines as the renderer of swf2es's own keeps them: stroked
+// by the tessellator's line builder (strokes.ts) for each transform a layer
+// is seen through, found again
+// by a hash of the transform's numbers, and kept while the geometries keep
+// them, within a budget of vertices for those not drawn lately.
+import { type Geometries, type GeometryHandle, IDLE_FRAMES } from "@swf2es/render";
+import type { ShapeLayer } from "../display/shapes.js";
+import { evenWidth, scalesEvenly } from "../display/stretch.js";
+import { same } from "../display/value-lists.js";
+import type { FillTessellator } from "./fills.js";
+import { layerStrokes } from "./strokes.js";
+
+/**
+ * The vertices kept lines may hold before those drawn neither this frame
+ * nor the last go, the least lately drawn first: a layer seen through ever
+ * new transforms, as a zoom shows it, would otherwise keep each for the
+ * geometries' idle frames. Past it with nothing idle, it grows to half
+ * again what is drawn, and comes back down as less is.
+ */
+const LINE_VERTICES = 1_000_000;
+
+/**
+ * How often, in frames, the kept lines are looked over whatever they hold:
+ * those the geometries let go of, and those that stroked to nothing, add
+ * no vertices that would bring the budget on.
+ */
+const SWEEP_FRAMES = 60;
+
+/** The bits of a number, read as two ints, for mixHash. */
+const hashFloat = new Float64Array(1);
+const hashInts = new Int32Array(hashFloat.buffer);
+
+/** `h` mixed with the bits of `x`, zero's two signs alike and every NaN, as same() takes them. */
+function mixHash(h: number, x: number): number {
+  hashFloat[0] = x === 0 ? 0 : Number.isNaN(x) ? Number.NaN : x;
+  return Math.imul(Math.imul(h ^ hashInts[0], 0x9e3779b1) ^ hashInts[1], 0x85ebca6b);
+}
+
+/**
+ * A layer's lines as of its drawing's `version`: whether they all scale
+ * both ways (scalesEvenly), what the layer brings to its object's settled
+ * stretch (evenWidth), whether any is of whole alpha, and their entries by
+ * their key's hash.
+ */
+export interface LayerLines {
+  version: number;
+  even: boolean;
+  width: number;
+  whole: boolean;
+  byHash: Map<number, LineEntry[]>;
+}
+
+/**
+ * A layer's lines as stroked through the linear transform (a b c d), at
+ * least `least` wide, as wide as `by` makes them (a 9-slice's line space)
+ * or null; their geometry, and the drawing's version they were made for.
+ */
+interface LineEntry {
+  a: number;
+  b: number;
+  c: number;
+  d: number;
+  least: number;
+  by: number[] | null;
+  /** Drawn at whole alpha, where lines of whole alpha may overlap themselves (layerStrokes). */
+  opaque: boolean;
+  handle: GeometryHandle | null;
+  version: number;
+  /**
+   * Its layer's lines and its key's hash there, which hold no layer; its
+   * vertices, -1 once forgotten; and the frame it was last drawn.
+   */
+  within: LayerLines;
+  hash: number;
+  vertices: number;
+  usedAt: number;
+}
+
+/** Each shape layer's lines, by the transform they are stroked through (take). */
+export class LineCache {
+  /**
+   * Lines stroked anew and lines found stroked already, which the bench and the draw counts read.
+   */
+  readonly counts = { strokeContexts: 0, strokeReuses: 0 };
+  private readonly byLayer = new WeakMap<ShapeLayer, LayerLines>();
+  /** Every entry, and the vertices they hold. */
+  private readonly entries: LineEntry[] = [];
+  private vertices = 0;
+  private limit: number;
+  /** The frame the entries were last looked over. */
+  private swept = 0;
+
+  constructor(
+    private readonly geometries: Geometries,
+    private readonly tessellator: FillTessellator,
+    private readonly budget = LINE_VERTICES,
+  ) {
+    this.limit = budget;
+  }
+
+  /** How many transforms' lines are kept, of every layer. */
+  get kept(): number {
+    return this.entries.length;
+  }
+
+  /** `layer`'s lines as of its drawing's `version`, what is known of them worked out again for another. */
+  of(layer: ShapeLayer, version: number): LayerLines {
+    let lines = this.byLayer.get(layer);
+    if (!lines) {
+      lines = {
+        version: -1,
+        even: false,
+        width: 0,
+        whole: false,
+        byHash: new Map(),
+      };
+      this.byLayer.set(layer, lines);
+    }
+
+    if (lines.version !== version) {
+      lines.version = version;
+      lines.even = scalesEvenly(layer);
+      lines.width = evenWidth(layer);
+      lines.whole = false;
+      for (let i = 0; !lines.whole && i < layer.strokes.length; i++) {
+        lines.whole = layer.strokes[i].line.color >>> 24 === 255;
+      }
+    }
+
+    return lines;
+  }
+
+  /**
+   * `layer`'s lines through the linear transform (a b c d), at least `least`
+   * wide, drawn opaque or not: stroked again for another transform, screen
+   * or version of its drawing, the old ones kept while drawn as the
+   * geometries keep them.
+   */
+  take(
+    layer: ShapeLayer,
+    version: number,
+    a: number,
+    b: number,
+    c: number,
+    d: number,
+    least: number,
+    by: readonly number[] | null,
+    drawnOpaque: boolean,
+  ): GeometryHandle | null {
+    const frame = this.geometries.frame;
+    if (frame - this.swept >= SWEEP_FRAMES) {
+      this.trim(frame);
+    }
+
+    const lines = this.of(layer, version);
+    // Only a line of whole alpha draws otherwise when opaque (layerStrokes): a layer of none keeps
+    // one geometry through a fade.
+    const opaque = drawnOpaque && lines.whole;
+    // Found by a hash of the key's numbers, compared as numbers: a layer seen by many instances
+    // keeps a transform for each, and a key formatted on every frame cost more than drawing it.
+    let hash = mixHash(mixHash(mixHash(mixHash(mixHash(opaque ? 1 : 0, a), b), c), d), least);
+    if (by) {
+      hash = mixHash(mixHash(mixHash(mixHash(hash, by[0]), by[1]), by[2]), by[3]);
+    }
+
+    let bucket = lines.byHash.get(hash);
+    let known: LineEntry | null = null;
+    for (let i = 0; bucket && i < bucket.length; i++) {
+      const e = bucket[i];
+      if (
+        same(e.a, a) &&
+        same(e.b, b) &&
+        same(e.c, c) &&
+        same(e.d, d) &&
+        same(e.least, least) &&
+        e.opaque === opaque &&
+        (e.by === null
+          ? by === null
+          : by !== null &&
+            same(e.by[0], by[0]) &&
+            same(e.by[1], by[1]) &&
+            same(e.by[2], by[2]) &&
+            same(e.by[3], by[3]))
+      ) {
+        known = e;
+        break;
+      }
+    }
+
+    if (
+      known &&
+      known.version === version &&
+      (!known.handle || this.geometries.alive(known.handle))
+    ) {
+      known.usedAt = frame;
+      this.counts.strokeReuses++;
+      return known.handle;
+    }
+
+    if (known?.handle && this.geometries.alive(known.handle)) {
+      this.geometries.remove(known.handle.id);
+    }
+
+    this.counts.strokeContexts++;
+    const data = layerStrokes(layer, a, b, c, d, least, this.tessellator.lines, by, opaque);
+    // Not built, as where no instance could be made: none kept, so that a later frame asks again.
+    if (data === undefined) {
+      return null;
+    }
+
+    const handle = data ? this.geometries.add(data) : null;
+    const vertices = data ? data.positions.length / 2 : 0;
+    if (known) {
+      this.vertices += vertices - known.vertices;
+      known.handle = handle;
+      known.version = version;
+      known.vertices = vertices;
+      known.usedAt = frame;
+    } else {
+      if (!bucket) {
+        bucket = [];
+        lines.byHash.set(hash, bucket);
+      }
+
+      const entry: LineEntry = {
+        a,
+        b,
+        c,
+        d,
+        least,
+        by: by ? [by[0], by[1], by[2], by[3]] : null,
+        opaque,
+        handle,
+        version,
+        within: lines,
+        hash,
+        vertices,
+        usedAt: frame,
+      };
+      bucket.push(entry);
+      this.entries.push(entry);
+      this.vertices += vertices;
+    }
+
+    if (this.vertices > this.limit) {
+      this.trim(frame);
+    }
+
+    return handle;
+  }
+
+  /**
+   * The kept lines looked over: those the geometries let go of, or that
+   * stroked to nothing and went undrawn for their idle frames, forgotten;
+   * then, past three quarters of the budget, those drawn neither in this
+   * `frame` nor the last let go of, the least lately drawn first; the limit
+   * set to half again what is left, the budget at least.
+   */
+  private trim(frame: number): void {
+    this.swept = frame;
+    const entries = this.entries;
+    const most = (this.budget * 3) / 4;
+    let kept = 0;
+    for (const e of entries) {
+      if (e.handle ? this.geometries.alive(e.handle) : frame - e.usedAt <= IDLE_FRAMES) {
+        entries[kept++] = e;
+      } else {
+        this.forget(e);
+      }
+    }
+
+    entries.length = kept;
+    if (this.vertices > most) {
+      // Mid-walk, those drawn last frame may yet be drawn in this one.
+      const idle = entries.filter((e) => e.usedAt < frame - 1).sort((x, y) => x.usedAt - y.usedAt);
+      for (let i = 0; i < idle.length && this.vertices > most; i++) {
+        if (idle[i].handle) {
+          this.geometries.remove((idle[i].handle as GeometryHandle).id);
+        }
+
+        this.forget(idle[i]);
+      }
+
+      kept = 0;
+      for (const e of entries) {
+        if (e.vertices >= 0) {
+          entries[kept++] = e;
+        }
+      }
+
+      entries.length = kept;
+    }
+
+    this.limit = Math.max(this.budget, this.vertices * 1.5);
+  }
+
+  /** `layer`'s lines let go of, as its drawing draws it no more: the next sweep forgets them. */
+  drop(layer: ShapeLayer): void {
+    for (const bucket of this.byLayer.get(layer)?.byHash.values() ?? []) {
+      for (const e of bucket) {
+        if (e.handle && this.geometries.alive(e.handle)) {
+          this.geometries.remove(e.handle.id);
+        }
+      }
+    }
+  }
+
+  /** Line entry `e` taken out of its layer's lines, its vertices no longer counted. */
+  private forget(e: LineEntry): void {
+    const bucket = e.within.byHash.get(e.hash);
+    const at = bucket ? bucket.indexOf(e) : -1;
+    if (bucket && at >= 0) {
+      bucket.splice(at, 1);
+      if (bucket.length === 0) {
+        e.within.byHash.delete(e.hash);
+      }
+    }
+
+    this.vertices -= e.vertices;
+    e.vertices = -1;
+  }
+}

package/src/scene/masks.ts

@@ -0,0 +1,195 @@
+// Masks as the view draws them (RenderView): a mask's draws begun, used
+// for what it masks and popped, as stencil markers in the scene list; a
+// rectangle, a scroll's or a text's gutter, as the unit quad; and an
+// object drawn whole as a mask, fills alone.
+import { IDENTITY } from "@swf2es/format";
+import {
+  type Geometries,
+  MASK_BEGIN,
+  MASK_POP,
+  MASK_USE,
+  NORMAL,
+  type Rows,
+  type SceneList,
+  SNAP,
+} from "@swf2es/render";
+import { BitmapObject } from "../display/bitmapobject.js";
+import { Container } from "../display/container.js";
+import { CLEAN, type DisplayObject } from "../display/displayobject.js";
+import { ShapeObject } from "../display/shapeobject.js";
+import { facing } from "../display/shapes.js";
+import { StaticTextObject, TextObject } from "../display/textobjects.js";
+import type { Parts } from "./parts.js";
+import { unsupported } from "./shapes.js";
+import { fieldItems, staticItems, type TextOmissions } from "./text.js";
+import { placedRow } from "./text-items.js";
+
+export class Masks {
+  /** The masks pushed and not yet popped, as each one's first draw and count. */
+  private readonly stack: number[] = [];
+
+  constructor(
+    private readonly geometries: Geometries,
+    private readonly parts: Parts,
+  ) {}
+
+  /** A mask begun: its draws follow, till it is used (maskUse); its first entry's index. */
+  maskBegin(scene: SceneList): number {
+    scene.marker(MASK_BEGIN);
+    return scene.length;
+  }
+
+  /**
+   * The mask begun at entry `first` (maskBegin) used from here, its draws
+   * those since. Begun and used around the mask's draws, with no closure:
+   * one in the walk kept every number it took in a context made on each
+   * call, boxed, though no mask was drawn.
+   */
+  maskUse(scene: SceneList, first: number): void {
+    const count = scene.length - first;
+    scene.marker(MASK_USE, first, count);
+    this.stack.push(first, count);
+  }
+
+  /** The mask pushed last taken out: its draws named again. */
+  popMask(scene: SceneList): void {
+    const count = this.stack.pop() as number;
+    const first = this.stack.pop() as number;
+    scene.marker(MASK_POP, first, count);
+  }
+
+  /** A rectangle of `o`'s space, x y width height, under its transform (a b c d tx ty), as a mask's draw. */
+  rectMask(
+    scene: SceneList,
+    rows: Rows,
+    a: number,
+    b: number,
+    c: number,
+    d: number,
+    tx: number,
+    ty: number,
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+  ): void {
+    const quad = this.parts.unitQuad();
+    const row = placedRow(
+      rows,
+      a,
+      b,
+      c,
+      d,
+      tx,
+      ty,
+      { a: width, b: 0, c: 0, d: height, tx: x, ty: y },
+      null,
+    );
+    this.geometries.use(quad.id);
+    scene.draw(quad.id, row, NORMAL);
+  }
+
+  /**
+   * `o` and all in it drawn as a mask, under its parent's transform: fills
+   * alone, a drawing's non-zero, glyphs and bitmaps' rectangles, whatever
+   * their visibility, as Flash masks by them. `own` says (a b c d tx ty) is
+   * already `o`'s own place, as a mask elsewhere on the list is found; else
+   * its own matrix is applied. Flags are cleared as the walk clears them.
+   */
+  walkMask(
+    scene: SceneList,
+    rows: Rows,
+    snapshotting: boolean,
+    o: DisplayObject,
+    pa: number,
+    pb: number,
+    pc: number,
+    pd: number,
+    ptx: number,
+    pty: number,
+    own: boolean,
+  ): void {
+    const m = own ? IDENTITY : o.flatPlaced;
+    // What would clip a mask's own coverage needs a stencil within the stencil: drawn whole, and counted.
+    if (o.mask || o.scroll || o.clipDepth > 0) {
+      unsupported.masks++;
+    }
+
+    const a = pa * m.a + pc * m.b;
+    const b = pb * m.a + pd * m.b;
+    const c = pa * m.c + pc * m.d;
+    const d = pb * m.c + pd * m.d;
+    const tx = pa * m.tx + pc * m.ty + ptx;
+    const ty = pb * m.tx + pd * m.ty + pty;
+    const shape = o instanceof ShapeObject ? o.drawn() : null;
+    const version = o.drawing ? o.drawing.version : 0;
+    const layers = o.drawing
+      ? facing(o.drawing.layers, a * d - b * c < 0, version)
+      : (shape?.layers ?? null);
+    // A mask's drawing drawn again lets go of its old layers too.
+    if (o.drawing && layers) {
+      this.parts.dropUndrawn(o, layers, version);
+    }
+
+    // Its row made as its first draw needs it, in place: a closure here kept every number it took
+    // in a context made on each call, boxed, as the walk's did.
+    let row = -1;
+    if (layers) {
+      for (let i = 0; i < layers.length; i++) {
+        for (const { part, handle } of this.parts.partsOf(layers[i], version, o.drawing !== null)) {
+          // A mesh of a bitmap disposed of draws nothing, as it is drawn, and so masks nothing.
+          if (part.mesh?.image.disposed) {
+            continue;
+          }
+
+          this.geometries.use(handle.id);
+          if (row < 0) {
+            row = rows.add(a, b, c, d, tx, ty, null);
+          }
+
+          scene.draw(handle.id, row, NORMAL);
+        }
+      }
+    }
+
+    if (o instanceof TextObject || o instanceof StaticTextObject) {
+      const omitted: TextOmissions = { advanced: false, clip: null, clipFrom: 0, clipTo: 0 };
+      for (const item of o instanceof TextObject
+        ? fieldItems(o, omitted)
+        : staticItems(o, omitted)) {
+        const geometry = item.kind === "glyph" ? this.parts.glyphGeometry(item.glyph) : null;
+        if (item.kind === "glyph" && geometry) {
+          const glyphRow = placedRow(rows, a, b, c, d, tx, ty, item.m, null);
+          this.geometries.use(geometry.id);
+          scene.draw(geometry.id, glyphRow, NORMAL, -1, SNAP);
+        }
+      }
+    }
+
+    const store = o instanceof BitmapObject ? o.store : null;
+    if (store && !store.disposed && store.width > 0 && store.height > 0) {
+      const quad = this.parts.quad(store.width, store.height);
+      this.geometries.use(quad.id);
+      if (row < 0) {
+        row = rows.add(a, b, c, d, tx, ty, null);
+      }
+
+      scene.draw(quad.id, row, NORMAL);
+    }
+
+    if (o instanceof Container) {
+      for (const child of o.children) {
+        this.walkMask(scene, rows, snapshotting, child, a, b, c, d, tx, ty, false);
+      }
+
+      if (!snapshotting) {
+        o.descendantsDirty = false;
+      }
+    }
+
+    // A draw for BitmapData leaves them for the stage's.
+    if (!snapshotting) {
+      o.dirty = CLEAN;
+    }
+  }
+}