@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/player/playerglobal/flash/display/Stage.js

@@ -0,0 +1,231 @@
+// flash.display.Stage: the stage's size and frame rate, invalidate, which
+// asks for a RENDER event before the frame is drawn, focus, which keys go
+// to (input/keyboard.ts), and the two container methods Stage declares native
+// again, which do as a container's do.
+import { avm2 } from "../../../../runtime/index.js";
+import { setFocus } from "../../../input/keyboard.js";
+import { stageAlignment } from "../../../stage.js";
+import { displayOf } from "./DisplayObject.js";
+import { containerNatives } from "./DisplayObjectContainer.js";
+import { nativeWindowOf } from "./NativeWindow.js";
+export function stageNatives(s) {
+    const natives = {};
+    class StageNatives {
+        "flash.display:Stage::requireOwnerPermissions"() {
+            // One owner: the SWF the player runs.
+        }
+        get frameRate() {
+            return s.frameRate;
+        }
+        /** The AIR application's window the stage is in; null outside AIR, or where the host has none. */
+        get nativeWindow() {
+            return nativeWindowOf(s);
+        }
+        set frameRate(v) {
+            s.frameRate = Math.max(0.01, Math.min(1000, Number(v)));
+        }
+        get stageWidth() {
+            return s.stageWidth;
+        }
+        /** The embedding page sizes the stage: a SWF's own sizes are taken and dropped, as in Ruffle. */
+        set stageWidth(_v) { }
+        get stageHeight() {
+            return s.stageHeight;
+        }
+        set stageHeight(_v) { }
+        /** Undocumented; null in AIR's adl, and in Flash Player as Ruffle found it. */
+        get displayContextInfo() {
+            return null;
+        }
+        invalidate() {
+            s.invalidated = true;
+        }
+        get scaleMode() {
+            return s.liveStageLayout ? s.stageScaleMode : "showAll";
+        }
+        set scaleMode(v) {
+            if (!s.liveStageLayout) {
+                return;
+            }
+            if (v == null) {
+                throw s.rt.error("TypeError", 2007, "scaleMode");
+            }
+            const value = s.rt.toString(v);
+            switch (value) {
+                case "showAll":
+                case "noScale":
+                case "noBorder":
+                case "exactFit":
+                    break;
+                default:
+                    throw s.rt.error("ArgumentError", 2008, "scaleMode");
+            }
+            s.stageScaleModeSet = true;
+            if (value !== s.stageScaleMode) {
+                s.stageScaleMode = value;
+                s.onStageLayout?.();
+            }
+        }
+        get align() {
+            return s.liveStageLayout ? s.stageAlign : "";
+        }
+        set align(v) {
+            if (!s.liveStageLayout) {
+                return;
+            }
+            if (v == null) {
+                throw s.rt.error("TypeError", 2007, "align");
+            }
+            const value = stageAlignment(s.rt.toString(v));
+            s.stageAlignSet = true;
+            if (value !== s.stageAlign) {
+                s.stageAlign = value;
+                s.onStageLayout?.();
+            }
+        }
+        get quality() {
+            return s.quality;
+        }
+        set quality(v) {
+            s.quality = String(v).toUpperCase();
+        }
+        get displayState() {
+            return "normal";
+        }
+        set displayState(_v) {
+            // No full screen.
+        }
+        get focus() {
+            return s.focus?.object ?? null;
+        }
+        // A field given focus keeps its selection (the corpus's edittext_focus_selection).
+        set focus(v) {
+            setFocus(s, v ? (displayOf(v) ?? null) : null);
+        }
+        get showDefaultContextMenu() {
+            return s.showDefaultContextMenu;
+        }
+        set showDefaultContextMenu(v) {
+            s.showDefaultContextMenu = s.rt.toBoolean(v);
+        }
+        // Kept, though no focus rectangle is drawn.
+        get stageFocusRect() {
+            return focusRect;
+        }
+        set stageFocusRect(v) {
+            focusRect = !!v;
+        }
+        /** The background, opaque: what a SWF's SetBackgroundColor gave until set, the alpha set ignored. */
+        get color() {
+            return ((s.stageColor ?? 0xffffff) | 0xff000000) >>> 0;
+        }
+        set color(v) {
+            s.stageColor = s.rt.toUint(v) & 0xffffff;
+            // A redraw asked for: a host that reads Player.background as it draws shows it.
+            s.updates++;
+        }
+        get allowsFullScreen() {
+            return true;
+        }
+        get allowsFullScreenInteractive() {
+            return false;
+        }
+        get browserZoomFactor() {
+            return 1;
+        }
+        get contentsScaleFactor() {
+            return 1;
+        }
+        get fullScreenWidth() {
+            return s.screenCapabilities.screenResolutionX;
+        }
+        get fullScreenHeight() {
+            return s.screenCapabilities.screenResolutionY;
+        }
+        get fullScreenSourceRect() {
+            return fullScreenSource;
+        }
+        set fullScreenSourceRect(v) {
+            fullScreenSource = v ?? null;
+        }
+        get colorCorrection() {
+            return colorCorrection;
+        }
+        set colorCorrection(v) {
+            if (v === null || v === undefined) {
+                throw s.rt.error("TypeError", 2007, "colorCorrection");
+            }
+            colorCorrection = s.rt.toString(v);
+        }
+        get colorCorrectionSupport() {
+            return "unsupported";
+        }
+        // Kept: the pointer is not locked, which only full screen allows.
+        get mouseLock() {
+            return mouseLock;
+        }
+        set mouseLock(v) {
+            mouseLock = !!v;
+        }
+        get wmodeGPU() {
+            return false;
+        }
+        get softKeyboardRect() {
+            return s.rt.construct(s.rt.classNamed("flash.geom::Rectangle"), 0, 0, 0, 0);
+        }
+        get orientation() {
+            return "unknown";
+        }
+        get deviceOrientation() {
+            return "unknown";
+        }
+        get autoOrients() {
+            return false;
+        }
+        "flash.display:Stage::setAutoOrients"(_v) { }
+        get supportedOrientations() {
+            const strings = s.rt.resolve(s.rt.vector("String")).$it.instance();
+            strings.$a = [];
+            return strings;
+        }
+        static get supportsOrientationChange() {
+            return false;
+        }
+        isFocusInaccessible() {
+            return false;
+        }
+        /** No StageVideo: the vector is empty. */
+        get stageVideos() {
+            return vectorOf("flash.media::StageVideo", []);
+        }
+        /** Flash's four, each of which fails to get a Context3D, as Flash without a GPU (Stage3D.ts). */
+        get stage3Ds() {
+            stage3Ds ??= [0, 1, 2, 3].map(() => s.rt.construct(s.rt.classNamed("flash.display::Stage3D")));
+            return vectorOf("flash.display::Stage3D", stage3Ds, true);
+        }
+    }
+    let focusRect = true;
+    let fullScreenSource = null;
+    let colorCorrection = "default";
+    let mouseLock = false;
+    let stage3Ds = null;
+    /** A Vector of the named class holding `values`. */
+    const vectorOf = (name, values, fixed = false) => {
+        const cls = s.rt.applyType(s.rt.classNamed("__AS3__.vec::Vector"), [s.rt.classNamed(name)]);
+        const o = cls.$it.instance();
+        o.$a = [...values];
+        o.$fixed = fixed;
+        return o;
+    };
+    avm2.registerNativeClass(natives, "flash.display::Stage", StageNatives);
+    const container = containerNatives(s);
+    for (const name of ["removeChildAt", "swapChildrenAt"]) {
+        natives[`flash.display::Stage#${name}`] =
+            container[`flash.display::DisplayObjectContainer#${name}`];
+    }
+    // Undocumented accessors Stage declares: null, and a write that changes
+    // nothing, as adl gives them. A JavaScript class cannot spell them.
+    natives["flash.display::Stage#get:constructor"] = avm2.plain(() => null);
+    natives["flash.display::Stage#set:constructor"] = avm2.plain(() => undefined);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/display/Stage3D.js

@@ -0,0 +1,54 @@
+// flash.display.Stage3D without Stage3D rendering: its position and
+// visibility kept, and each request for a Context3D answered as Flash
+// answers it without a GPU, an ErrorEvent #3702 in a later frame, so that
+// content that falls back to the display list can.
+import { avm2 } from "../../../../runtime/index.js";
+import { dispatchEvent } from "../../../scripting/events.js";
+export function stage3DNatives(s) {
+    const natives = {};
+    const unavailable = (target) => {
+        s.loads.deferHostEvent(() => dispatchEvent(s, target, s.rt.construct(s.rt.classNamed("flash.events::ErrorEvent"), "error", false, false, "Error #3702: Context3D not available.", 3702)));
+    };
+    /** A position within -8192 to 8191; else ArgumentError 2006, as the corpus's `stage3d_x_y` has Flash's. */
+    const position = (v) => {
+        const n = s.rt.toNumber(v);
+        if (!(n >= -8192 && n <= 8191)) {
+            throw s.rt.error("ArgumentError", 2006);
+        }
+        return n;
+    };
+    class Stage3DNatives {
+        get context3D() {
+            return null;
+        }
+        requestContext3D(_mode = "auto", _profile = "baseline") {
+            unavailable(this);
+        }
+        requestContext3DMatchingProfiles(profiles) {
+            if (profiles === null || profiles === undefined) {
+                throw s.rt.error("TypeError", 2007, "profiles");
+            }
+            unavailable(this);
+        }
+        get x() {
+            return this.$x ?? 0;
+        }
+        set x(v) {
+            this.$x = position(v);
+        }
+        get y() {
+            return this.$y ?? 0;
+        }
+        set y(v) {
+            this.$y = position(v);
+        }
+        get visible() {
+            return this.$visible ?? true;
+        }
+        set visible(v) {
+            this.$visible = !!v;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::Stage3D", Stage3DNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/display/shaders.js

@@ -0,0 +1,228 @@
+// What a Shader's kernel runs with, read from its ShaderData as adl reads
+// it: each parameter's numbers and each input's image. A ShaderJob reads
+// them as it starts; a ShaderFilter, a blend shader and a shader fill as
+// they are set, and draw with those after, whatever the script sets later
+// (the shader-filters and shader-blends cases).
+import { PBJ_TYPE_SIZES, PBJ_TYPES, pbjFloatType, } from "../../../../format/index.js";
+import { avm2 } from "../../../../runtime/index.js";
+import { OUT_COORD } from "../../../bitmap/pixel-bender.js";
+import { storeOf } from "./BitmapData.js";
+import { programOf } from "./ShaderData.js";
+import { shaderClasses } from "./ShaderInput.js";
+/** A parameter value's number as its register takes it: float32, or an int as SSE truncates one. */
+function numberOf(v, float) {
+    if (float) {
+        return Math.fround(v);
+    }
+    const t = Math.trunc(v);
+    return t >= -2147483648 && t <= 2147483647 ? t : -2147483648;
+}
+/** The kernel a Shader holds: its ShaderData's, or null for none. */
+export function kernelOfShader(shader) {
+    const data = shader?.$data ?? null;
+    const kernel = data?.$kernel;
+    return data && kernel ? { data, kernel } : null;
+}
+/**
+ * A parameter's numbers: those of the ShaderParameter of its name, where
+ * one of its type is there, else its default, as adl takes them; each a
+ * number, or ArgumentError 2004, as many as its type holds, 0 past the
+ * Array's end.
+ */
+export function parameterValues(s, data, p) {
+    const classes = shaderClasses(s);
+    const size = PBJ_TYPE_SIZES[p.type] ?? 0;
+    const float = pbjFloatType(p.type);
+    const own = data.$d.get(p.name);
+    let value;
+    if (s.rt.isInstance(own, classes.shaderParameter) && own.$type === (PBJ_TYPES[p.type] ?? null)) {
+        value = own.$value ?? null;
+    }
+    else {
+        const fallback = p.metadata.filter((m) => m.key === "defaultValue").pop();
+        value = fallback && typeof fallback.value !== "string" ? s.rt.array([...fallback.value]) : null;
+    }
+    const values = [];
+    const items = s.rt.isInstance(value, classes.array) ? value.$a : [];
+    for (let k = 0; k < size; k++) {
+        if (k >= items.length) {
+            values.push(0);
+            continue;
+        }
+        const item = items[k];
+        if (typeof item !== "number") {
+            throw s.rt.error("ArgumentError", 2004);
+        }
+        values.push(numberOf(item, float));
+    }
+    return values;
+}
+/** Every input parameter's numbers, but _OutCoord's, which each pixel sets. */
+export function kernelValues(s, data, kernel) {
+    const values = new Map();
+    for (const p of kernel.parameters) {
+        if (!p.output && p.name !== OUT_COORD) {
+            values.set(p, parameterValues(s, data, p));
+        }
+    }
+    return values;
+}
+/** How a use takes its inputs' images: read as they are now, copied to draw with later, or checked alone. */
+export const READ = 0;
+export const COPY = 1;
+export const CHECK = 2;
+/**
+ * The copy of each input taken last, by its BitmapData's store, its Vector
+ * or its ByteArray: kept while a use holds it, and shared by the uses that
+ * take the same pixels (its store's version) or numbers (their hash), as a
+ * fill begun on every frame takes them, its texture with them.
+ */
+const copies = new WeakMap();
+/** The copy of `source` kept for `version` and this size, else the one `make` makes, kept now. */
+function shared(source, version, width, height, channels, make) {
+    const kept = copies.get(source);
+    const image = kept &&
+        kept.version === version &&
+        kept.width === width &&
+        kept.height === height &&
+        kept.channels === channels
+        ? kept.image.deref()
+        : undefined;
+    if (image) {
+        return image;
+    }
+    const made = make();
+    copies.set(source, { version, width, height, channels, image: new WeakRef(made) });
+    return made;
+}
+/** A hash of `floats`' bits, FNV-1a, which says whether numbers taken again are the same. */
+function hashOf(floats) {
+    const words = new Uint32Array(floats.buffer, floats.byteOffset, floats.length);
+    let h = 0x811c9dc5;
+    for (let i = 0; i < words.length; i++) {
+        h = Math.imul(h ^ words[i], 0x01000193);
+    }
+    return h >>> 0;
+}
+/**
+ * An input's image, read now: a BitmapData's pixels, or as many floats
+ * as its size needs; a ByteArray's position is moved past them by
+ * `read`, once nothing refuses the job, as adl leaves it where it was
+ * then. `how` READ takes them as they are, COPY as a copy (shared, as
+ * `copies` keeps them) for a use that draws with them later, and CHECK
+ * only checks them, null.
+ */
+export function inputImage(s, data, name, channels, read, how = READ) {
+    const classes = shaderClasses(s);
+    const refuse = (id, ...args) => {
+        throw s.rt.error("ArgumentError", id, ...args);
+    };
+    const own = data.$d.get(name);
+    if (!s.rt.isInstance(own, classes.shaderInput)) {
+        refuse(2167);
+    }
+    const o = own;
+    const input = o.$input ?? null;
+    if (input === null) {
+        refuse(2164, name);
+    }
+    if (s.rt.isInstance(input, classes.bitmapData)) {
+        const store = storeOf(s, input);
+        const { width, height } = store;
+        switch (how) {
+            case CHECK:
+                return null;
+            case COPY:
+                return shared(store, store.version, width, height, channels, () => ({
+                    width,
+                    height,
+                    pixels: store.readable.slice(),
+                    channels,
+                }));
+            default:
+                return { width, height, pixels: store.readable, channels };
+        }
+    }
+    const width = o.$width ?? 0;
+    const height = o.$height ?? 0;
+    if (width <= 0 || height <= 0) {
+        refuse(2166, name);
+    }
+    // Allocated once the input is known to hold them, whatever size the script set.
+    const count = width * height * channels;
+    if (s.rt.isInstance(input, classes.vector)) {
+        const items = input.$a;
+        if (items.length < count) {
+            refuse(2165, name);
+        }
+        if (how === CHECK) {
+            return null;
+        }
+        const floats = Float32Array.from(items.slice(0, count));
+        const image = { width, height, floats, channels };
+        return how === COPY
+            ? shared(input, hashOf(floats), width, height, channels, () => image)
+            : image;
+    }
+    // From the start, whatever the position, which is left past what was read.
+    const bytes = avm2.bytesOf(s.rt, input);
+    if (bytes.length < count * 4) {
+        refuse(2165, name);
+    }
+    if (how === CHECK) {
+        return null;
+    }
+    const floats = new Float32Array(count);
+    for (let i = 0; i < count; i++) {
+        floats[i] = bytes.view.getFloat32(i * 4, bytes.littleEndian);
+    }
+    read.push(() => {
+        bytes.position = count * 4;
+    });
+    const image = { width, height, floats, channels };
+    return how === COPY
+        ? shared(input, hashOf(floats), width, height, channels, () => image)
+        : image;
+}
+/**
+ * What a ShaderFilter, a blend shader or a shader fill draws with, read as
+ * it is set, and what applyFilter runs with: `bound` inputs, the first
+ * ones, are the use's own (a filter's object, a blend's background and
+ * foreground), and the rest must be set; each needs `bound` inputs at
+ * least (2167), and a filter and a blend a kernel of four channels out
+ * (2162). `how` takes its inputs' images (inputImage); CHECK takes no
+ * values either, and moves no ByteArray.
+ */
+export function shaderUse(s, shader, bound, how = COPY) {
+    const found = kernelOfShader(shader);
+    const { data, kernel } = found;
+    const outputs = kernel.parameters.filter((p) => p.output);
+    if (bound > 0 && outputs[outputs.length - 1]?.type !== 0x4) {
+        throw s.rt.error("ArgumentError", 2162);
+    }
+    if (kernel.inputs.length < bound) {
+        throw s.rt.error("ArgumentError", 2167);
+    }
+    const images = new Map();
+    const read = [];
+    for (const input of kernel.inputs.slice(bound)) {
+        const image = inputImage(s, data, input.name, input.channels, read, how);
+        if (image) {
+            images.set(input.index, image);
+        }
+    }
+    // A texture sampled that no input declares, as a job refuses it.
+    for (const texture of programOf(kernel).sampled) {
+        if (!kernel.inputs.some((input) => input.index === texture)) {
+            throw s.rt.error("ArgumentError", 2167);
+        }
+    }
+    if (how === CHECK) {
+        return { kernel, values: new Map(), images };
+    }
+    const values = kernelValues(s, data, kernel);
+    for (const move of read) {
+        move();
+    }
+    return { kernel, values, images };
+}

package/dist/thread/player/playerglobal/flash/events/Event.js

@@ -0,0 +1,58 @@
+// flash.events.Event's natives, which Flash Player's playerglobal has:
+// its constructor's private native ctor keeps the type and flags, and
+// dispatch sets the target, current target and phase in the fields they
+// read (scripting/events.ts's eventFields). Ours keeps them all in AS3.
+import { avm2 } from "../../../../runtime/index.js";
+import { AT_TARGET } from "../../../scripting/events.js";
+export function eventNatives(s) {
+    const natives = {};
+    class EventNatives {
+        "flash.events:Event::ctor"(type, bubbles, cancelable) {
+            if (type == null) {
+                throw s.rt.error("TypeError", 2007, "type");
+            }
+            this.$type = String(type);
+            this.$bubbles = !!bubbles;
+            this.$cancelable = !!cancelable;
+            this.$target = null;
+            this.$currentTarget = null;
+            this.$phase = AT_TARGET;
+            this.$stopped = 0;
+            this.$prevented = false;
+        }
+        get type() {
+            return this.$type;
+        }
+        get bubbles() {
+            return this.$bubbles;
+        }
+        get cancelable() {
+            return this.$cancelable;
+        }
+        get target() {
+            return this.$target;
+        }
+        get currentTarget() {
+            return this.$currentTarget;
+        }
+        get eventPhase() {
+            return this.$phase;
+        }
+        stopPropagation() {
+            this.$stopped = Math.max(this.$stopped, 1);
+        }
+        stopImmediatePropagation() {
+            this.$stopped = 2;
+        }
+        preventDefault() {
+            if (this.$cancelable) {
+                this.$prevented = true;
+            }
+        }
+        isDefaultPrevented() {
+            return this.$prevented;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.events::Event", EventNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/events/EventDispatcher.js

@@ -0,0 +1,103 @@
+// flash.events.EventDispatcher: listeners by type on the object itself,
+// which the player's dispatch (scripting/events.ts) calls along a display
+// object's parent chain. The player broadcasts its frame and activation
+// events through it.
+import { avm2 } from "../../../../runtime/index.js";
+import { dispatchEvent, displayOf } from "../../../scripting/events.js";
+/** The events Flash broadcasts to every display object that listens, on the display list or not, target only. */
+const BROADCAST = new Set(["enterFrame", "frameConstructed", "exitFrame", "render"]);
+/**
+ * The events Flash broadcasts to every EventDispatcher that listens, display
+ * object or not, target only: the player's activation, which, unlike a
+ * frame's events, holds no listener alive (Scripting.activationTargets).
+ */
+const ACTIVATION = new Set(["activate", "deactivate"]);
+function listeners(o) {
+    if (!o.$listeners) {
+        o.$listeners = new Map();
+    }
+    return o.$listeners;
+}
+/** An event type, declared String: refused as null, as Flash refuses it. */
+function eventType(s, type) {
+    if (type === null || type === undefined) {
+        throw s.rt.error("TypeError", 2007, "type");
+    }
+    return type;
+}
+/** `fn` added to `o`'s listeners for `type`, as EventDispatcher.addEventListener adds it; whether it was new. */
+export function addListener(s, o, type, fn, useCapture, priority) {
+    const key = eventType(s, type);
+    if (typeof fn !== "object" && typeof fn !== "function") {
+        return false;
+    }
+    const list = listeners(o).get(key) ?? [];
+    const capture = !!useCapture;
+    if (list.some((l) => l.fn === fn && l.capture === capture)) {
+        return false;
+    }
+    const listener = { fn, capture, priority: Number(priority) | 0 };
+    // Higher priority first; the same priority in the order added.
+    let at = list.length;
+    while (at > 0 && list[at - 1].priority < listener.priority) {
+        at--;
+    }
+    list.splice(at, 0, listener);
+    listeners(o).set(key, list);
+    // A display object listening for a frame event is broadcast to, wherever it is; any
+    // dispatcher listening for activation is, held weakly.
+    if (BROADCAST.has(key) && o.$display) {
+        s.broadcastTargets(key).add(o);
+    }
+    else if (ACTIVATION.has(key)) {
+        s.activationTargets(key).add(o);
+    }
+    return true;
+}
+/** `fn` taken from `o`'s listeners for `type`, as EventDispatcher.removeEventListener takes it. */
+export function removeListener(s, o, type, fn, useCapture) {
+    const key = eventType(s, type);
+    const list = o.$listeners?.get(key);
+    const at = list?.findIndex((l) => l.fn === fn && l.capture === !!useCapture) ?? -1;
+    if (list && at >= 0) {
+        list.splice(at, 1);
+        if (list.length === 0 && BROADCAST.has(key)) {
+            s.broadcastTargets(key).delete(o);
+        }
+        else if (list.length === 0 && ACTIVATION.has(key)) {
+            s.activationTargets(key).delete(o);
+        }
+    }
+}
+export function eventDispatcherNatives(s) {
+    const natives = {};
+    const typeOf = (type) => eventType(s, type);
+    class EventDispatcherNatives {
+        "flash.events:EventDispatcher::ctor"(target) {
+            this.$target = target ?? null;
+        }
+        addEventListener(type, fn, useCapture, priority) {
+            addListener(s, this, type, fn, useCapture, priority);
+        }
+        removeEventListener(type, fn, useCapture) {
+            removeListener(s, this, type, fn, useCapture);
+        }
+        hasEventListener(type) {
+            return (this.$listeners?.get(typeOf(type))?.length ?? 0) > 0;
+        }
+        willTrigger(type) {
+            const key = typeOf(type);
+            for (let o = this; o; o = displayOf(o)?.parent?.object ?? null) {
+                if ((o.$listeners?.get(key)?.length ?? 0) > 0) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        "flash.events:EventDispatcher::dispatchEventFunction"(event) {
+            return dispatchEvent(s, this, event);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.events::EventDispatcher", EventDispatcherNatives);
+    return natives;
+}