@swf2es/player 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,313 @@
+// flash.display.NativeWindow: an AIR application's window, as
+// Stage.nativeWindow gives it, over the host's AirWindow (hosts.ts). Its
+// bounds are the window's on the screen, its frame included, as AIR's are;
+// the stage keeps the size its scale mode gives it. A window a script opens
+// itself is not supported. Where the host does not say: adl's values
+// (AIR 51.3), but for the system's sizes, a browser's window having no
+// least size of its own.
+import { avm2 } from "@swf2es/runtime";
+import type { WindowBounds } from "../../../hosts.js";
+import type { Scripting } from "../../../scripting.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+/** The window each player's stage is in, made as a script first asks for it. */
+const windows = new WeakMap<Scripting, AsObject>();
+
+/** The application's window, Stage.nativeWindow's, or null where the host has none. */
+export function nativeWindowOf(s: Scripting): AsObject | null {
+  if (!s.application?.window) {
+    return null;
+  }
+
+  let window = windows.get(s);
+  if (!window) {
+    window = s.rt.construct(s.rt.classNamed("flash.display::NativeWindow"), null) as AsObject;
+    windows.set(s, window);
+  }
+
+  return window;
+}
+
+/** AIR's largest window, either way. */
+const MAX_SIDE = 107374182;
+
+export function nativeWindowNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  const prop = (o: Value, name: string) =>
+    Number(s.rt.getProperty(o as AsObject, avm2.qname(avm2.publicNs, name)));
+  const point = (x: number, y: number) =>
+    s.rt.construct(s.rt.classNamed("flash.geom::Point"), x, y);
+  let closed = false;
+  let alwaysInFront = false;
+  let minSize: Value = null;
+  let maxSize: Value = null;
+
+  /** The host's window behind `o`, which only the application's window has. */
+  const hostOf = (o: unknown) => {
+    const window = s.application?.window;
+    if (!window || o !== windows.get(s)) {
+      throw s.rt.unsupported("a NativeWindow a script opens");
+    }
+
+    return window;
+  };
+  const bounds = (o: unknown): WindowBounds => hostOf(o).bounds();
+  const move = (o: unknown, change: Partial<WindowBounds>) => {
+    const window = hostOf(o);
+    window.setBounds?.({ ...window.bounds(), ...change });
+  };
+
+  class NativeWindowNatives {
+    static get isSupported(): boolean {
+      return s.air;
+    }
+
+    static get supportsMenu(): boolean {
+      return false;
+    }
+
+    static get supportsNotification(): boolean {
+      return false;
+    }
+
+    static get supportsTransparency(): boolean {
+      return false;
+    }
+
+    static get systemMinSize(): Value {
+      return point(1, 1);
+    }
+
+    static get systemMaxSize(): Value {
+      return point(MAX_SIDE, MAX_SIDE);
+    }
+
+    get stage(): Value {
+      hostOf(this);
+      return s.stage?.object ?? null;
+    }
+
+    get title(): string {
+      return hostOf(this).title();
+    }
+
+    set title(v: Value) {
+      hostOf(this).setTitle?.(String(v));
+    }
+
+    get bounds(): Value {
+      const b = bounds(this);
+      return s.rt.construct(s.rt.classNamed("flash.geom::Rectangle"), b.x, b.y, b.width, b.height);
+    }
+
+    set bounds(v: Value) {
+      if (v === null) {
+        throw s.rt.error("TypeError", 2007, "bounds");
+      }
+
+      move(this, {
+        x: prop(v, "x"),
+        y: prop(v, "y"),
+        width: prop(v, "width"),
+        height: prop(v, "height"),
+      });
+    }
+
+    get x(): number {
+      return bounds(this).x;
+    }
+
+    set x(v: Value) {
+      move(this, { x: Number(v) });
+    }
+
+    get y(): number {
+      return bounds(this).y;
+    }
+
+    set y(v: Value) {
+      move(this, { y: Number(v) });
+    }
+
+    get width(): number {
+      return bounds(this).width;
+    }
+
+    set width(v: Value) {
+      move(this, { width: Number(v) });
+    }
+
+    get height(): number {
+      return bounds(this).height;
+    }
+
+    set height(v: Value) {
+      move(this, { height: Number(v) });
+    }
+
+    get displayState(): string {
+      return hostOf(this).displayState();
+    }
+
+    minimize(): void {
+      hostOf(this).minimize?.();
+    }
+
+    maximize(): void {
+      hostOf(this).maximize?.();
+    }
+
+    restore(): void {
+      hostOf(this).restore?.();
+    }
+
+    close(): void {
+      const window = hostOf(this);
+      if (!closed) {
+        closed = true;
+        window.close?.();
+      }
+    }
+
+    get closed(): boolean {
+      hostOf(this);
+      return closed;
+    }
+
+    get visible(): boolean {
+      return hostOf(this).visible();
+    }
+
+    set visible(v: Value) {
+      hostOf(this).setVisible?.(!!v);
+    }
+
+    get active(): boolean {
+      return hostOf(this).active();
+    }
+
+    activate(): void {
+      hostOf(this).activate?.();
+    }
+
+    get systemChrome(): string {
+      hostOf(this);
+      return "standard";
+    }
+
+    get transparent(): boolean {
+      hostOf(this);
+      return false;
+    }
+
+    get type(): string {
+      hostOf(this);
+      return "normal";
+    }
+
+    get minimizable(): boolean {
+      hostOf(this);
+      return true;
+    }
+
+    get maximizable(): boolean {
+      hostOf(this);
+      return true;
+    }
+
+    get resizable(): boolean {
+      hostOf(this);
+      return true;
+    }
+
+    // Moving and resizing by the mouse are the window manager's.
+    startMove(): boolean {
+      hostOf(this);
+      return false;
+    }
+
+    startResize(): boolean {
+      hostOf(this);
+      return false;
+    }
+
+    get minSize(): Value {
+      hostOf(this);
+      minSize ??= point(1, 1);
+      return minSize;
+    }
+
+    set minSize(v: Value) {
+      hostOf(this);
+      minSize = v;
+    }
+
+    get maxSize(): Value {
+      hostOf(this);
+      maxSize ??= point(MAX_SIDE, MAX_SIDE);
+      return maxSize;
+    }
+
+    set maxSize(v: Value) {
+      hostOf(this);
+      maxSize = v;
+    }
+
+    get alwaysInFront(): boolean {
+      hostOf(this);
+      return alwaysInFront;
+    }
+
+    set alwaysInFront(v: Value) {
+      hostOf(this);
+      alwaysInFront = !!v;
+    }
+
+    // One window: nothing to order it among.
+    orderToFront(): boolean {
+      hostOf(this);
+      return false;
+    }
+
+    orderToBack(): boolean {
+      hostOf(this);
+      return false;
+    }
+
+    orderInFrontOf(_window: Value): boolean {
+      hostOf(this);
+      return false;
+    }
+
+    orderInBackOf(_window: Value): boolean {
+      hostOf(this);
+      return false;
+    }
+
+    /** A point of the stage's on the screen: past the window's corner and its frame's border and title bar. */
+    globalToScreen(p: Value): Value {
+      const window = hostOf(this);
+      const b = window.bounds();
+      const offset = window.stageOffset();
+      return point(b.x + offset.x + prop(p, "x"), b.y + offset.y + prop(p, "y"));
+    }
+
+    get menu(): Value {
+      hostOf(this);
+      return null;
+    }
+
+    set menu(_v: Value) {
+      hostOf(this);
+    }
+
+    notifyUser(_type: Value): void {
+      hostOf(this);
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.display::NativeWindow", NativeWindowNatives);
+  return natives;
+}

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

@@ -0,0 +1,39 @@
+// flash.display.Shader: its ShaderData, which byteCode's AS3 setter makes,
+// and the precision hint, "full" or "fast": the CPU runs every kernel in full.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+
+export function shaderNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class ShaderNatives {
+    declare $data: Value | undefined;
+    declare $precision: string | undefined;
+
+    get data(): Value {
+      return this.$data ?? null;
+    }
+
+    set data(v: Value) {
+      this.$data = v ?? null;
+    }
+
+    get precisionHint(): string {
+      return this.$precision ?? "full";
+    }
+
+    set precisionHint(v: Value) {
+      const hint = v === null || v === undefined ? null : s.rt.toString(v);
+      if (hint !== "full" && hint !== "fast") {
+        throw s.rt.error("ArgumentError", 2004);
+      }
+
+      this.$precision = hint;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.display::Shader", ShaderNatives);
+  return natives;
+}

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

@@ -0,0 +1,105 @@
+// flash.display.ShaderData: a Pixel Bender kernel read from its bytecode
+// (format's readPbj), and as dynamic properties what adl gives a script of
+// it: the kernel's metadata of the first opcode, an int or a string, its
+// name, a ShaderParameter for each parameter but the outputs and
+// _OutCoord, and a ShaderInput for each input.
+import { PBJ_STRING, PBJ_TYPES, PbjError, type PbjKernel, readPbj } from "@swf2es/format";
+import { avm2 } from "@swf2es/runtime";
+import { OUT_COORD, PixelBender } from "../../../bitmap/pixel-bender.js";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+type AsObject = avm2.AsObject;
+
+/** A kernel's program, compiled when a job first runs it. */
+const programs = new WeakMap<PbjKernel, PixelBender>();
+
+export function programOf(kernel: PbjKernel): PixelBender {
+  let program = programs.get(kernel);
+  if (!program) {
+    program = new PixelBender(kernel);
+    programs.set(kernel, program);
+  }
+
+  return program;
+}
+
+/** A metadata value as adl gives it: a string, else a new Array of its numbers. */
+function metadataValue(s: Scripting, value: string | number[]): Value {
+  return typeof value === "string" ? value : s.rt.array([...value]);
+}
+
+export function shaderDataNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class ShaderDataNatives {
+    declare $kernel: PbjKernel | undefined;
+    declare $d: Map<string, Value>;
+
+    "flash.display:ShaderData::_setByteCode"(code: Value): void {
+      if (code === null || code === undefined) {
+        throw s.rt.error("TypeError", 2007, "byteCode");
+      }
+
+      // The whole ByteArray, whatever its position, which is left at its end.
+      const bytes = avm2.bytesOf(s.rt, code as AsObject);
+      let kernel: PbjKernel;
+      try {
+        kernel = readPbj(bytes.buffer.subarray(0, bytes.length));
+      } catch (e) {
+        if (!(e instanceof PbjError)) {
+          throw e;
+        }
+
+        throw e.errorID === 2030
+          ? s.rt.error("flash.errors::EOFError", 2030)
+          : s.rt.error("ArgumentError", 2004);
+      } finally {
+        bytes.position = bytes.length;
+      }
+
+      this.$kernel = kernel;
+      const own = this.$d;
+      for (const m of kernel.metadata) {
+        // An int of the kernel's is an int, not an Array of one.
+        own.set(m.key, typeof m.value === "string" ? m.value : m.value[0]);
+      }
+
+      if (kernel.name !== null) {
+        own.set("name", kernel.name);
+      }
+
+      let index = 0;
+      for (const p of kernel.parameters) {
+        if (p.output || p.name === OUT_COORD) {
+          continue;
+        }
+
+        const o = s.rt.construct(s.rt.classNamed("flash.display::ShaderParameter")) as AsObject;
+        o.$type = PBJ_TYPES[p.type] ?? null;
+        o.$index = index++;
+        o.$value = null;
+        for (const m of p.metadata) {
+          o.$d.set(m.key, metadataValue(s, m.value));
+          if (m.key === "defaultValue") {
+            o.$value = m.type === PBJ_STRING ? null : metadataValue(s, m.value);
+          }
+        }
+
+        o.$d.set("name", p.name);
+        own.set(p.name, o);
+      }
+
+      for (const input of kernel.inputs) {
+        const o = s.rt.construct(s.rt.classNamed("flash.display::ShaderInput")) as AsObject;
+        o.$channels = input.channels;
+        o.$index = input.index;
+        o.$d.set("name", input.name);
+        own.set(input.name, o);
+      }
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.display::ShaderData", ShaderDataNatives);
+  return natives;
+}

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

@@ -0,0 +1,101 @@
+// flash.display.ShaderInput: an image a kernel samples, a BitmapData or
+// floats in a ByteArray or a Vector.<Number>, which then need the width and
+// height set; its channels and index are the kernel's.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+
+/** The classes the shader natives test values against, resolved once a player. */
+export interface ShaderClasses {
+  array: avm2.AsObject;
+  bitmapData: avm2.AsObject;
+  byteArray: avm2.AsObject;
+  vector: avm2.AsObject;
+  shaderParameter: avm2.AsObject;
+  shaderInput: avm2.AsObject;
+  shaderEvent: avm2.AsObject;
+}
+
+const resolved = new WeakMap<Scripting, ShaderClasses>();
+
+/** The classes, looked up at the first call, once playerglobal is loaded. */
+export function shaderClasses(s: Scripting): ShaderClasses {
+  let classes = resolved.get(s);
+  if (!classes) {
+    classes = {
+      array: s.rt.classNamed("Array"),
+      bitmapData: s.rt.classNamed("flash.display::BitmapData"),
+      byteArray: s.rt.classNamed("flash.utils::ByteArray"),
+      vector: s.rt.resolve(s.rt.vector("Number")),
+      shaderParameter: s.rt.classNamed("flash.display::ShaderParameter"),
+      shaderInput: s.rt.classNamed("flash.display::ShaderInput"),
+      shaderEvent: s.rt.classNamed("flash.events::ShaderEvent"),
+    };
+    resolved.set(s, classes);
+  }
+
+  return classes;
+}
+
+/** Whether `v` is what a ShaderInput takes, and a ShaderJob writes: a BitmapData, a ByteArray or a Vector.<Number>. */
+export function isShaderImage(s: Scripting, v: Value): boolean {
+  const c = shaderClasses(s);
+  return (
+    s.rt.isInstance(v, c.bitmapData) ||
+    s.rt.isInstance(v, c.byteArray) ||
+    s.rt.isInstance(v, c.vector)
+  );
+}
+
+export function shaderInputNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class ShaderInputNatives {
+    declare $input: Value | undefined;
+    declare $width: number | undefined;
+    declare $height: number | undefined;
+    declare $channels: number | undefined;
+    declare $index: number | undefined;
+
+    get input(): Value {
+      return this.$input ?? null;
+    }
+
+    // null too is refused, as adl refuses it.
+    set input(v: Value) {
+      if (!isShaderImage(s, v)) {
+        throw s.rt.error("ArgumentError", 2004);
+      }
+
+      this.$input = v;
+    }
+
+    get width(): number {
+      return this.$width ?? 0;
+    }
+
+    set width(v: Value) {
+      this.$width = s.rt.toInt(v);
+    }
+
+    get height(): number {
+      return this.$height ?? 0;
+    }
+
+    set height(v: Value) {
+      this.$height = s.rt.toInt(v);
+    }
+
+    get channels(): number {
+      return this.$channels ?? 0;
+    }
+
+    get index(): number {
+      return this.$index ?? 0;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.display::ShaderInput", ShaderInputNatives);
+  return natives;
+}