@swf2es/player 0.0.0-stage → 0.1.0

package/src/playerglobal/flash/display/Graphics.ts

@@ -0,0 +1,489 @@
+// flash.display.Graphics: the natives record into the display object's
+// drawing (display/drawing.ts), and readGraphicsData reads it back
+// (display/graphicsdata.ts). drawCircle and drawEllipse are playerglobal's
+// own, over curveTo.
+import type { Line, Matrix } from "@swf2es/format";
+import { avm2 } from "@swf2es/runtime";
+import { BitmapStore } from "../../../bitmap/bitmap.js";
+import type { DisplayObject } from "../../../display/display.js";
+import { CONTENT, Container, ShapeObject } from "../../../display/display.js";
+import { Drawing } from "../../../display/drawing.js";
+import { concat } from "../../../display/geometry.js";
+import { type GraphicsDatum, graphicsData } from "../../../display/graphicsdata.js";
+import type { Paint } from "../../../display/shapes.js";
+import type { Scripting } from "../../../scripting.js";
+import { CHECK, COPY, kernelOfShader, shaderUse } from "./shaders.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+const TWIPS = 20;
+const CAPS: Record<string, number> = { round: 0, none: 1, square: 2 };
+const JOINTS: Record<string, number> = { round: 0, bevel: 1, miter: 2 };
+/** Which way round a triangle drawTriangles drops: 1 clockwise on a y-down screen, -1 the other. */
+const CULLING: Record<string, number> = { none: 0, positive: 1, negative: -1 };
+const IDENTITY = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
+// Made once: a drawing may begin a bitmap fill for each triangle it draws on every frame.
+const MATRIX_NAMES = ["a", "b", "c", "d", "tx", "ty"].map((k) => avm2.qname(avm2.publicNs, k));
+
+/** The gradients begun with no matrix, which read back with Flash's default for one. */
+const unplaced = new WeakSet<Paint>();
+
+/** A Graphics object for `display`, made once. */
+export function graphicsOf(s: Scripting, o: AsObject): AsObject {
+  if (!o.$graphics) {
+    const g = s.rt.construct(s.rt.classNamed("flash.display::Graphics")) as AsObject;
+    g.$display = o.$display;
+    o.$graphics = g;
+  }
+
+  return o.$graphics;
+}
+
+/** 0xAARRGGBB of a color and an alpha in [0, 1], the alpha a byte floored as Flash stores it (0.5 is 127). */
+function argb(color: Value, alpha: Value): number {
+  const a = Math.floor(Math.max(0, Math.min(1, Number(alpha))) * 255);
+  return ((a << 24) | (Number(color) & 0xffffff)) >>> 0;
+}
+
+export function graphicsNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  const drawing = (o: { $display: DisplayObject }): Drawing => {
+    o.$display.drawing ??= new Drawing();
+    o.$display.invalidate(CONTENT);
+    return o.$display.drawing;
+  };
+  const num = (v: Value, fallback = 0) => {
+    const n = Number(v);
+    return Number.isNaN(n) ? fallback : n;
+  };
+  /** A shader as a fill takes it: TypeError 2007 for null, 2171 for no kernel, its inputs set (2164). */
+  const shaderOf = (shader: Value, how = COPY) => {
+    if (shader === null || shader === undefined) {
+      throw s.rt.error("TypeError", 2007, "shader");
+    }
+
+    if (!kernelOfShader(shader)) {
+      throw s.rt.error("ArgumentError", 2171);
+    }
+
+    return shaderUse(s, shader, 0, how);
+  };
+  /** A fill's matrix from an AS3 Matrix, or the identity for none. */
+  const matrixFrom = (matrix: Value): Matrix => {
+    if (matrix === null || matrix === undefined) {
+      return { ...IDENTITY };
+    }
+
+    const rt = s.rt;
+    const m = matrix as AsObject;
+
+    return {
+      a: rt.toNumber(rt.getProperty(m, MATRIX_NAMES[0])),
+      b: rt.toNumber(rt.getProperty(m, MATRIX_NAMES[1])),
+      c: rt.toNumber(rt.getProperty(m, MATRIX_NAMES[2])),
+      d: rt.toNumber(rt.getProperty(m, MATRIX_NAMES[3])),
+      tx: rt.toNumber(rt.getProperty(m, MATRIX_NAMES[4])),
+      ty: rt.toNumber(rt.getProperty(m, MATRIX_NAMES[5])),
+    };
+  };
+
+  /** The data of `display`'s drawing, a timeline shape's too, and with `recurse` its children's, each through `m`. */
+  const gather = (display: DisplayObject, m: Matrix, recurse: boolean, out: GraphicsDatum[]) => {
+    if (display instanceof ShapeObject) {
+      graphicsData(display.drawn()?.layers ?? [], m, unplaced, out);
+    }
+
+    graphicsData(display.drawing?.layers ?? [], m, unplaced, out);
+    if (recurse && display instanceof Container) {
+      for (const child of display.children) {
+        gather(child, concat(child.matrix, m), true, out);
+      }
+    }
+  };
+  const matrixOf = (m: Matrix): AsObject =>
+    s.rt.construct(
+      s.rt.classNamed("flash.geom::Matrix"),
+      m.a,
+      m.b,
+      m.c,
+      m.d,
+      m.tx,
+      m.ty,
+    ) as AsObject;
+  const vectorOf = (type: string, values: number[]): AsObject => {
+    const o = s.rt.resolve(s.rt.vector(type)).$it.instance();
+    o.$a = values;
+    return o;
+  };
+  const objectOf = (datum: GraphicsDatum): AsObject => {
+    const make = (name: string, ...args: Value[]) =>
+      s.rt.construct(s.rt.classNamed(`flash.display::${name}`), ...args) as AsObject;
+    switch (datum.type) {
+      case "solid":
+        return make("GraphicsSolidFill", datum.color, datum.alpha);
+      case "gradient":
+        return make(
+          "GraphicsGradientFill",
+          datum.radial ? "radial" : "linear",
+          s.rt.array(datum.colors),
+          s.rt.array(datum.alphas),
+          s.rt.array(datum.ratios),
+          matrixOf(datum.matrix),
+          datum.spread,
+          datum.linearRgb ? "linearRGB" : "rgb",
+          datum.focal,
+        );
+      case "bitmap": {
+        // A copy of its pixels, not the BitmapData it was begun with, as adl gives.
+        const store = datum.image instanceof BitmapStore ? datum.image : null;
+        let bitmap: AsObject | null = null;
+        if (store) {
+          bitmap = s.rt.construct(
+            s.rt.classNamed("flash.display::BitmapData"),
+            store.width,
+            store.height,
+            store.transparent,
+            0,
+          ) as AsObject;
+          bitmap.$store = store.clone();
+        }
+
+        return make("GraphicsBitmapFill", bitmap, matrixOf(datum.matrix), true, false);
+      }
+      case "path":
+        return make(
+          "GraphicsPath",
+          vectorOf("int", datum.commands),
+          vectorOf("Number", datum.data),
+          datum.winding,
+        );
+      default:
+        return make("GraphicsEndFill");
+    }
+  };
+
+  class GraphicsNatives {
+    declare $display: DisplayObject;
+
+    /** readGraphicsData's: what the drawing holds, in Flash's form, onto `target`. */
+    "flash.display:Graphics::nativeGetGraphicsData"(target: Value, recurse: Value): void {
+      const out: GraphicsDatum[] = [];
+      gather(this.$display, IDENTITY, !!recurse, out);
+      const list: Value[] = (target as AsObject).$a;
+      for (const datum of out) {
+        list.push(objectOf(datum));
+      }
+    }
+
+    clear(): void {
+      drawing(this).clear();
+    }
+
+    beginFill(color: Value, alpha: Value = 1): void {
+      drawing(this).beginFill({ type: "solid", color: argb(color, alpha) });
+    }
+
+    /** Recorded as a shape's gradient is drawn: its first stop's color, until gradients draw. */
+    /**
+     * As adl draws one: arrays of different lengths, or a ratio outside 0
+     * to 255, draw nothing; no stops draw black; past 16 stops are left
+     * out; an unknown spread or interpolation is pad or RGB; null alphas
+     * and ratios are opaque and even, null colours TypeError 2007.
+     */
+    beginGradientFill(
+      type: Value,
+      colors: Value,
+      alphas: Value,
+      ratios: Value,
+      matrix: Value = null,
+      spreadMethod: Value = "pad",
+      interpolationMethod: Value = "rgb",
+      focalPointRatio: Value = 0,
+    ): void {
+      const kind = s.rt.toString(type);
+      if (kind !== "linear" && kind !== "radial") {
+        throw s.rt.error("ArgumentError", 2008, "type");
+      }
+
+      if (colors === null || colors === undefined) {
+        throw s.rt.error("TypeError", 2007, "colors");
+      }
+
+      // Null alphas are opaque, and null ratios spread evenly, floor(255 k / (n - 1)), as adl draws them.
+      const array = (v: Value) => ((v as AsObject).$a as Value[] | undefined) ?? [];
+      const c = array(colors);
+      const a = alphas === null || alphas === undefined ? c.map(() => 1) : array(alphas);
+      const r =
+        ratios === null || ratios === undefined
+          ? c.map((_, k) => (c.length > 1 ? Math.floor((255 * k) / (c.length - 1)) : 0))
+          : array(ratios).map((v) => Math.trunc(s.rt.toNumber(v)));
+      if (a.length !== c.length || r.length !== c.length || r.some((v) => !(v >= 0 && v <= 255))) {
+        drawing(this).beginFill({ type: "solid", color: 0 });
+        return;
+      }
+
+      const spread = s.rt.toString(spreadMethod);
+      const fill: Paint = {
+        type: "gradient",
+        radial: kind === "radial",
+        focal: kind === "radial" ? num(focalPointRatio) : 0,
+        stops: c.slice(0, 16).map((color, i) => ({ ratio: r[i], color: argb(color, a[i]) })),
+        spread: spread === "reflect" ? 1 : spread === "repeat" ? 2 : 0,
+        linearRgb: s.rt.toString(interpolationMethod) === "linearRGB",
+        matrix: matrixFrom(matrix),
+      };
+      if (matrix === null || matrix === undefined) {
+        unplaced.add(fill);
+      }
+
+      drawing(this).beginFill(fill);
+    }
+
+    /** The BitmapData itself, not a copy: the fill shows its later changes, the shape a view of its store. */
+    beginBitmapFill(
+      bitmap: Value,
+      matrix: Value = null,
+      repeat: Value = true,
+      smooth: Value = false,
+    ): void {
+      if (bitmap === null || bitmap === undefined) {
+        throw s.rt.error("TypeError", 2007, "bitmap");
+      }
+
+      const store: BitmapStore | null | undefined = (bitmap as AsObject).$store;
+      if (!store) {
+        throw s.rt.error("ArgumentError", 2015);
+      }
+
+      store.views.add(this.$display.ref);
+      drawing(this).beginFill({
+        type: "image",
+        image: store,
+        matrix: matrixFrom(matrix),
+        repeat: !!repeat,
+        smooth: !!smooth,
+      });
+    }
+
+    /**
+     * A fill of the kernel's pixels, its parameters and images taken as they
+     * are now: the shape's points through the matrix's inverse are its
+     * coordinates, a pixel's centre each, as adl draws it.
+     */
+    beginShaderFill(shader: Value, matrix: Value = null): void {
+      drawing(this).beginFill({
+        type: "shader",
+        use: shaderOf(shader),
+        matrix: matrixFrom(matrix),
+      });
+    }
+
+    endFill(): void {
+      drawing(this).endFill();
+    }
+
+    lineStyle(
+      thickness: Value = Number.NaN,
+      color: Value = 0,
+      alpha: Value = 1,
+      pixelHinting: Value = false,
+      scaleMode: Value = "normal",
+      caps: Value = null,
+      joints: Value = null,
+      miterLimit: Value = 3,
+    ): void {
+      const t = Number(thickness);
+      if (Number.isNaN(t)) {
+        drawing(this).lineStyle(null);
+        return;
+      }
+
+      const cap = CAPS[String(caps ?? "round")] ?? 0;
+      const line: Line = {
+        width: Math.round(Math.max(0, Math.min(255, t)) * TWIPS),
+        color: argb(color, alpha),
+        startCap: cap,
+        endCap: cap,
+        join: JOINTS[String(joints ?? "round")] ?? 0,
+        miterLimit: num(miterLimit, 3),
+        noHScale: scaleMode === "none" || scaleMode === "vertical",
+        noVScale: scaleMode === "none" || scaleMode === "horizontal",
+        pixelHinting: !!pixelHinting,
+        noClose: false,
+        fill: null,
+      };
+      drawing(this).lineStyle(line);
+    }
+
+    lineGradientStyle(): void {
+      // The line keeps the color lineStyle gave it, as a shape's gradient line does.
+    }
+
+    lineBitmapStyle(): void {
+      // As lineGradientStyle.
+    }
+
+    /** Checked as adl checks it; the line keeps its colour, as a gradient's does. */
+    lineShaderStyle(shader: Value): void {
+      shaderOf(shader, CHECK);
+    }
+
+    drawRect(x: Value, y: Value, w: Value, h: Value): void {
+      drawing(this).drawRect(num(x), num(y), num(w), num(h));
+    }
+
+    drawRoundRect(x: Value, y: Value, w: Value, h: Value, ew: Value, eh: Value = Number.NaN): void {
+      const e = num(ew);
+      drawing(this).drawRoundRect(num(x), num(y), num(w), num(h), e, num(eh, e));
+    }
+
+    drawRoundRectComplex(
+      x: Value,
+      y: Value,
+      w: Value,
+      h: Value,
+      tl: Value,
+      tr: Value,
+      bl: Value,
+      br: Value,
+    ): void {
+      const r = (v: Value): [number, number] => {
+        const c = Math.min(Math.abs(num(v)), Math.abs(num(w)) / 2, Math.abs(num(h)) / 2);
+        return [c, c];
+      };
+      drawing(this).drawRoundRectComplex(
+        num(x),
+        num(y),
+        num(w),
+        num(h),
+        r(tl),
+        r(tr),
+        r(bl),
+        r(br),
+      );
+    }
+
+    moveTo(x: Value, y: Value): void {
+      drawing(this).moveTo(num(x), num(y));
+    }
+
+    lineTo(x: Value, y: Value): void {
+      drawing(this).lineTo(num(x), num(y));
+    }
+
+    curveTo(cx: Value, cy: Value, x: Value, y: Value): void {
+      drawing(this).curveTo(num(cx), num(cy), num(x), num(y));
+    }
+
+    cubicCurveTo(c1x: Value, c1y: Value, c2x: Value, c2y: Value, x: Value, y: Value): void {
+      drawing(this).cubicCurveTo(num(c1x), num(c1y), num(c2x), num(c2y), num(x), num(y));
+    }
+
+    /** As Flash checks: the winding one of its two, and the data's count even when there are commands (ArgumentError #2008, #2004). */
+    drawPath(commands: Value, data: Value, winding: Value = "evenOdd"): void {
+      if (winding !== "evenOdd" && winding !== "nonZero") {
+        throw s.rt.error("ArgumentError", 2008, "winding");
+      }
+
+      const c = (((commands as AsObject)?.$a as Value[] | undefined) ?? []).map((v) => Number(v));
+      const d = (((data as AsObject)?.$a as Value[] | undefined) ?? []).map((v) => Number(v));
+      if (c.length && d.length % 2) {
+        throw s.rt.error("ArgumentError", 2004);
+      }
+
+      drawing(this).drawPath(c, d, winding);
+    }
+
+    /**
+     * As Flash checks: the vertices in pairs, three of them a triangle
+     * without indices, indices in threes, and uvtData two or three a vertex,
+     * each ArgumentError #2004; then the culling one of its three, #2008.
+     * Null vertices draw nothing, and an index past the vertices ends the
+     * triangles there, without an error.
+     */
+    drawTriangles(
+      vertices: Value,
+      indices: Value = null,
+      uvtData: Value = null,
+      culling: Value = "none",
+    ): void {
+      if (vertices === null || vertices === undefined) {
+        return;
+      }
+
+      // The vectors' own storage, read, not copied: a Vector.<Number>'s and a Vector.<int>'s hold
+      // numbers alone, and a 3D engine passes thousands of them every frame.
+      const numbers = (v: Value) => (v as AsObject).$a as number[];
+      const given = numbers(vertices);
+      let coordinates = given;
+      // Flash keeps a point in twips as an int: NaN, or one past an int's range, is its least.
+      for (let i = 0; i < coordinates.length; i++) {
+        const x = coordinates[i] * TWIPS;
+        if (!(x >= -2147483648 && x <= 2147483647)) {
+          if (coordinates === given) {
+            coordinates = given.slice();
+          }
+
+          coordinates[i] = -2147483648 / TWIPS;
+        }
+      }
+
+      const n = coordinates.length / 2;
+      const order = indices === null || indices === undefined ? null : numbers(indices);
+      const uvt = uvtData === null || uvtData === undefined ? null : numbers(uvtData);
+      if (
+        coordinates.length % 2 ||
+        (order ? order.length % 3 : n % 3) ||
+        (uvt && uvt.length !== n * 2 && uvt.length !== n * 3)
+      ) {
+        throw s.rt.error("ArgumentError", 2004);
+      }
+
+      const cull =
+        typeof culling === "string" && Object.hasOwn(CULLING, culling)
+          ? CULLING[culling]
+          : undefined;
+      if (cull === undefined) {
+        throw s.rt.error("ArgumentError", 2008, "culling");
+      }
+
+      // Three a vertex, t 1 where Flash was given none.
+      let full = uvt;
+      if (uvt && uvt.length !== n * 3) {
+        full = new Array<number>(n * 3);
+        for (let v = 0; v < n; v++) {
+          full[3 * v] = uvt[2 * v];
+          full[3 * v + 1] = uvt[2 * v + 1];
+          full[3 * v + 2] = 1;
+        }
+      }
+
+      drawing(this).drawTriangles(coordinates, order, full, cull);
+    }
+
+    copyFrom(other: Value): void {
+      const source = (other as AsObject)?.$display?.drawing as Drawing | undefined;
+      if (source) {
+        drawing(this).copyFrom(source);
+        // Its BitmapData fills watched as the other's are.
+        for (const layer of source.layers) {
+          for (const { fill } of layer.fills) {
+            if (fill.type === "image" && fill.image instanceof BitmapStore) {
+              fill.image.views.add(this.$display.ref);
+            }
+          }
+
+          for (const mesh of layer.meshes ?? []) {
+            mesh.image.views.add(this.$display.ref);
+          }
+        }
+      } else {
+        drawing(this).clear();
+      }
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.display::Graphics", GraphicsNatives);
+  return natives;
+}

package/src/playerglobal/flash/display/InteractiveObject.ts

@@ -0,0 +1,124 @@
+// flash.display.InteractiveObject: what it keeps about input, kept as
+// fields with Flash's defaults until input reaches the player.
+import { avm2 } from "@swf2es/runtime";
+import { pickWork } from "../../../display/display.js";
+import { tabEnabledDefault } from "../../../input/keyboard.js";
+import type { Scripting } from "../../../scripting.js";
+import { displayOf } from "./DisplayObject.js";
+
+type Value = avm2.Value;
+
+/**
+ * `v` as an instance of the class `qualified` names, as Flash coerces a
+ * native's argument to its declared type: null for null and undefined,
+ * TypeError #1034 for anything else that is not one.
+ */
+export function coerceArgument(s: Scripting, v: Value, qualified: string): Value {
+  if (v === null || v === undefined) {
+    return null;
+  }
+
+  const cls = s.rt.classNamed(qualified);
+  if (s.rt.isInstance(v, cls)) {
+    return v;
+  }
+
+  throw s.rt.error("TypeError", 1034, s.rt.describe(v), cls.$it.name);
+}
+
+export function interactiveObjectNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class InteractiveObjectNatives {
+    declare $tabEnabled: boolean | undefined;
+    declare $tabIndex: number | undefined;
+    declare $focusRect: Value;
+    declare $mouseEnabled: boolean | undefined;
+    declare $doubleClickEnabled: boolean | undefined;
+    declare $accessibility: Value;
+    declare $softKeyboardArea: Value;
+    declare $needsSoftKeyboard: boolean | undefined;
+    declare $contextMenu: Value;
+
+    get tabEnabled(): boolean {
+      return this.$tabEnabled ?? tabEnabledDefault(displayOf(this as unknown as avm2.AsObject));
+    }
+
+    set tabEnabled(v: Value) {
+      this.$tabEnabled = !!v;
+    }
+
+    get tabIndex(): number {
+      return this.$tabIndex ?? -1;
+    }
+
+    set tabIndex(v: Value) {
+      this.$tabIndex = Number(v) | 0;
+    }
+
+    get focusRect(): Value {
+      return this.$focusRect ?? null;
+    }
+
+    set focusRect(v: Value) {
+      this.$focusRect = v;
+    }
+
+    get mouseEnabled(): boolean {
+      return this.$mouseEnabled ?? true;
+    }
+
+    set mouseEnabled(v: Value) {
+      this.$mouseEnabled = !!v;
+      pickWork.changes++;
+    }
+
+    get doubleClickEnabled(): boolean {
+      return this.$doubleClickEnabled ?? false;
+    }
+
+    set doubleClickEnabled(v: Value) {
+      this.$doubleClickEnabled = !!v;
+    }
+
+    get accessibilityImplementation(): Value {
+      return this.$accessibility ?? null;
+    }
+
+    set accessibilityImplementation(v: Value) {
+      this.$accessibility = v;
+    }
+
+    get softKeyboardInputAreaOfInterest(): Value {
+      return this.$softKeyboardArea ?? null;
+    }
+
+    set softKeyboardInputAreaOfInterest(v: Value) {
+      this.$softKeyboardArea = v;
+    }
+
+    get needsSoftKeyboard(): boolean {
+      return this.$needsSoftKeyboard ?? false;
+    }
+
+    set needsSoftKeyboard(v: Value) {
+      this.$needsSoftKeyboard = !!v;
+    }
+
+    /** Read when the host opens the SWF's context menu. */
+    get contextMenu(): Value {
+      return this.$contextMenu ?? null;
+    }
+
+    set contextMenu(v: Value) {
+      this.$contextMenu = coerceArgument(s, v, "flash.display::NativeMenu");
+    }
+
+    requestSoftKeyboard(): boolean {
+      return false;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.display::InteractiveObject", InteractiveObjectNatives);
+  return natives;
+}