@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/player/playerglobal/flash/geom/Transform.js

@@ -0,0 +1,245 @@
+import { avm2 } from "../../../../runtime/index.js";
+import { bounds, boundsIn } from "../../../display/bounds.js";
+import { TRANSFORM } from "../../../display/display.js";
+import { concat } from "../../../display/geometry.js";
+import { determinant3D, identity3D, invert3D, multiply3D, } from "../../../display/matrix3d.js";
+import { alwaysProjects, projectionFrom, projectionObject } from "./PerspectiveProjection.js";
+const MATRIX = ["a", "b", "c", "d", "tx", "ty"];
+const COLOR = [
+    ["rMul", "redMultiplier"],
+    ["gMul", "greenMultiplier"],
+    ["bMul", "blueMultiplier"],
+    ["aMul", "alphaMultiplier"],
+    ["rAdd", "redOffset"],
+    ["gAdd", "greenOffset"],
+    ["bAdd", "blueOffset"],
+    ["aAdd", "alphaOffset"],
+];
+// Made once: a script reads and writes a transform on every frame.
+const MATRIX_NAMES = MATRIX.map((k) => avm2.qname(avm2.publicNs, k));
+const COLOR_NAMES = COLOR.map(([, name]) => avm2.qname(avm2.publicNs, name));
+const IDENTITY_COLOR = {
+    rMul: 1,
+    gMul: 1,
+    bMul: 1,
+    aMul: 1,
+    rAdd: 0,
+    gAdd: 0,
+    bAdd: 0,
+    aAdd: 0,
+};
+/** A new flash.geom.Matrix of `m`. */
+function matrixObject(s, m) {
+    return s.rt.construct(s.rt.classNamed("flash.geom::Matrix"), m.a, m.b, m.c, m.d, m.tx, m.ty);
+}
+/** The matrix a flash.geom.Matrix holds. */
+export function matrixOf(s, o) {
+    const value = (i) => Number(s.rt.getProperty(o, MATRIX_NAMES[i]));
+    return { a: value(0), b: value(1), c: value(2), d: value(3), tx: value(4), ty: value(5) };
+}
+/** A new flash.geom.ColorTransform of `c`. */
+function colorObject(s, c) {
+    return s.rt.construct(s.rt.classNamed("flash.geom::ColorTransform"), c.rMul, c.gMul, c.bMul, c.aMul, c.rAdd, c.gAdd, c.bAdd, c.aAdd);
+}
+/** The color transform a flash.geom.ColorTransform holds. */
+export function colorOf(s, o) {
+    const value = (i) => Number(s.rt.getProperty(o, COLOR_NAMES[i]));
+    return {
+        rMul: value(0),
+        gMul: value(1),
+        bMul: value(2),
+        aMul: value(3),
+        rAdd: value(4),
+        gAdd: value(5),
+        bAdd: value(6),
+        aAdd: value(7),
+    };
+}
+export function transformNatives(s) {
+    const natives = {};
+    /** Each 3D object's own Matrix3D, while it shares the object's matrix (`matrix3D`). */
+    const bound = new WeakMap();
+    class TransformNatives {
+        "flash.geom:Transform::ctor"(display) {
+            this.$display = display.$display;
+        }
+        /** Null in 3D. */
+        get matrix() {
+            return this.$display.space ? null : matrixObject(s, this.$display.matrix);
+        }
+        /** Null puts the object in 3D, its matrix3D made from the 2D one; a matrix takes it back to 2D. */
+        set matrix(v) {
+            this.$display.touch();
+            if (v) {
+                this.$display.setMatrix(matrixOf(s, v));
+            }
+            else {
+                this.$display.enter3D();
+            }
+        }
+        get colorTransform() {
+            return colorObject(s, this.$display.colorTransform ?? IDENTITY_COLOR);
+        }
+        set colorTransform(v) {
+            if (v) {
+                this.$display.colorTransform = colorOf(s, v);
+                this.$display.touch();
+                this.$display.invalidate(TRANSFORM);
+            }
+        }
+        /**
+         * Its own scroll's shift left out, as Flash's does, its parents' taken in; null for a 3D
+         * object. Under one, adl gives it in the space of the bitmap that object is drawn into: up
+         * to the 3D object, then moved by the bitmap's corner, two pixels out from its bounds'
+         * top left out to whole pixels (the `three-d-bounds` case).
+         */
+        get concatenatedMatrix() {
+            const d = this.$display;
+            if (d.space) {
+                return null;
+            }
+            let m = d.matrix;
+            let p = d.parent;
+            for (; p && p !== s.stage && !p.space; p = p.parent) {
+                m = concat(m, p.placed);
+            }
+            const r = p?.space ? bounds(p, true) : null;
+            if (r) {
+                m = { ...m, tx: m.tx + 2 - Math.floor(r.xMin), ty: m.ty + 2 - Math.floor(r.yMin) };
+            }
+            return matrixObject(s, m);
+        }
+        /** The color transform to the stage: multipliers multiplied, offsets carried through the parents' multipliers. */
+        get concatenatedColorTransform() {
+            const c = { ...(this.$display.colorTransform ?? IDENTITY_COLOR) };
+            for (let p = this.$display.parent; p && p !== s.stage; p = p.parent) {
+                const q = p.colorTransform;
+                if (!q) {
+                    continue;
+                }
+                for (const [mul, , add] of [
+                    ["rMul", 0, "rAdd"],
+                    ["gMul", 0, "gAdd"],
+                    ["bMul", 0, "bAdd"],
+                    ["aMul", 0, "aAdd"],
+                ]) {
+                    c[add] = c[add] * q[mul] + q[add];
+                    c[mul] = c[mul] * q[mul];
+                }
+            }
+            return colorObject(s, c);
+        }
+        /**
+         * The object's own Matrix3D, null in 2D: one, which shares its matrix, so that what a script
+         * does to it moves the object and what the object's properties do shows in it, as adl's
+         * does (Matrix3D's natives tell its `$owner`). A new one once the object leaves 3D.
+         */
+        get matrix3D() {
+            const d = this.$display;
+            const space = d.space;
+            if (!space) {
+                return null;
+            }
+            let m = bound.get(d);
+            if (!m || m.$matrix3D !== space.raw) {
+                m = s.rt.construct(s.rt.classNamed("flash.geom::Matrix3D"));
+                m.$matrix3D = space.raw;
+                m.$owner = d;
+                bound.set(d, m);
+            }
+            return m;
+        }
+        /**
+         * Taken as the object's own, and apart into the 3D properties, as adl
+         * does, even one of the same values; null back to 2D, at the identity.
+         * The object's own Matrix3D set back changes nothing, its properties
+         * kept as they were set. One that is another object's is refused, as is
+         * any whose float32 determinant is 0.
+         */
+        set matrix3D(v) {
+            const d = this.$display;
+            const held = bound.get(d);
+            if (!v) {
+                if (held) {
+                    held.$owner = null;
+                    bound.delete(d);
+                }
+                d.touch();
+                d.setMatrix3D(null);
+                return;
+            }
+            const m = v;
+            const raw = m.$matrix3D;
+            if (m === held && d.space?.raw === raw) {
+                d.touch();
+                return;
+            }
+            const owner = m.$owner;
+            if (owner && owner !== d && owner.space?.raw === raw) {
+                throw s.rt.error("ArgumentError", 2189);
+            }
+            if (determinant3D(raw) === 0) {
+                throw s.rt.error("ArgumentError", 2188);
+            }
+            if (held) {
+                held.$owner = null;
+            }
+            d.touch();
+            d.setMatrix3D(raw, false, true);
+            m.$owner = d;
+            bound.set(d, m);
+        }
+        /**
+         * The matrix3D from this object's space to `relativeTo`'s, through
+         * their concatenated transforms, each 2D one taken as 3D; null for an
+         * object in 2D, as Flash gives.
+         */
+        getRelativeMatrix3D(relativeTo) {
+            if (relativeTo === null || relativeTo === undefined) {
+                throw s.rt.error("TypeError", 2007, "relativeTo");
+            }
+            const d = this.$display;
+            if (!d.space) {
+                return null;
+            }
+            const target = relativeTo.$display;
+            const toTarget = invert3D(concatenated3D(target)) ?? identity3D();
+            const m = s.rt.construct(s.rt.classNamed("flash.geom::Matrix3D"));
+            m.$matrix3D.set(multiply3D(toTarget, concatenated3D(d)));
+            return m;
+        }
+        /** A new one of this object's, which reads and writes this object's; null for an object with none. */
+        get perspectiveProjection() {
+            const d = this.$display;
+            return d.projection || alwaysProjects(s, d) ? projectionObject(s, d) : null;
+        }
+        set perspectiveProjection(v) {
+            this.$display.projection = v ? projectionFrom(s, v) : null;
+            // What is in it is drawn through it.
+            this.$display.invalidate(TRANSFORM);
+        }
+        /** The bounds on the stage, out to whole pixels. */
+        get pixelBounds() {
+            const r = boundsIn(this.$display, s.stage, s.stage, true);
+            // Math.ceil gives -0 for an edge just left of 0, which Flash reports as 0.
+            const x = Math.ceil(r.xMin) || 0;
+            const y = Math.ceil(r.yMin) || 0;
+            const right = Math.ceil(r.xMax);
+            const bottom = Math.ceil(r.yMax);
+            return s.rt.construct(s.rt.classNamed("flash.geom::Rectangle"), x, y, right - x, bottom - y);
+        }
+    }
+    /** `d`'s transform to the top of its list, each 2D matrix taken as 3D. */
+    const concatenated3D = (d) => {
+        let m = identity3D();
+        for (let o = d; o && o !== s.stage; o = o.parent) {
+            const local = o.space
+                ? o.space.shown
+                : Float32Array.of(o.matrix.a, o.matrix.b, 0, 0, o.matrix.c, o.matrix.d, 0, 0, 0, 0, 1, 0, o.matrix.tx, o.matrix.ty, 0, 1);
+            m = multiply3D(local, m);
+        }
+        return m;
+    };
+    avm2.registerNativeClass(natives, "flash.geom::Transform", TransformNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/geom/Utils3D.js

@@ -0,0 +1,85 @@
+// flash.geom.Utils3D: points through a projection matrix, to the plane w = 1,
+// and a matrix turned part of the way to face a point.
+import { avm2 } from "../../../../runtime/index.js";
+import { interpolate3D, pointAt3D, transform3D, translation3D } from "../../../display/matrix3d.js";
+const f = Math.fround;
+export function utils3DNatives(s) {
+    const natives = {};
+    const nonNull = (v, name) => {
+        if (v === null || v === undefined) {
+            throw s.rt.error("TypeError", 2007, name);
+        }
+        return v;
+    };
+    const component = (v, name) => s.rt.toNumber(s.rt.getProperty(v, s.rt.publicName(name)));
+    /** A vector grown with zeros to `n`, as Flash grows it; a fixed one too short is RangeError 1126. */
+    const grow = (v, n) => {
+        if (v.$a.length >= n) {
+            return;
+        }
+        if (v.$fixed) {
+            throw s.rt.error("RangeError", 1126, v.$a.length, n);
+        }
+        while (v.$a.length < n) {
+            v.$a.push(0);
+        }
+    };
+    const xyz = (v) => ["x", "y", "z"].map((name) => component(v, name));
+    class Utils3DNatives {
+        /**
+         * A new matrix, `mat` interpolated toward its translation alone turned
+         * by pointAt, the percent held to 0 to 1, as adl has it: so the scale
+         * goes to 1 with it. Where pointAt would leave the matrix, a copy of
+         * it. The translation is lerped apart from the rotation, and the last
+         * element is 1, so a NaN direction leaves both as they were.
+         */
+        static pointTowards(percent, mat, pos, at = null, up = null) {
+            const from = nonNull(mat, "fromMat").$matrix3D;
+            const target = xyz(nonNull(pos, "target"));
+            const position = translation3D(from[12], from[13], from[14]);
+            const turned = pointAt3D(position, target, at === null || at === undefined ? [0, 1, 0] : xyz(at), up === null || up === undefined ? [0, 0, 1] : xyz(up));
+            const out = s.rt.construct(s.rt.classNamed("flash.geom::Matrix3D"));
+            const raw = out.$matrix3D;
+            if (!turned) {
+                raw.set(from);
+                return out;
+            }
+            const p = Math.max(0, Math.min(1, s.rt.toNumber(percent)));
+            raw.set(interpolate3D(from, turned, p));
+            for (let i = 0; i < 3; i++) {
+                raw[12 + i] = from[12 + i] + (position[12 + i] - from[12 + i]) * p;
+            }
+            raw[15] = 1;
+            return out;
+        }
+        /**
+         * transformVector's float32 result times the float32 reciprocal of its
+         * w, as adl has it; the Flash Player of Ruffle's corpus rounds the
+         * products to float32 too.
+         */
+        static projectVector(m, v) {
+            const raw = nonNull(m, "m").$matrix3D;
+            const at = nonNull(v, "v");
+            const [x, y, z, w] = transform3D(raw, component(at, "x"), component(at, "y"), component(at, "z"));
+            const over = f(1 / w);
+            return s.rt.construct(s.rt.classNamed("flash.geom::Vector3D"), x * over, y * over, z * over, w);
+        }
+        /** Each (x, y, z) of `verts` through the matrix in float32, to an (x, y) in `projected` over w in doubles, and 1/w to its t in `uvts`. */
+        static projectVectors(m, verts, projected, uvts) {
+            const raw = nonNull(m, "m").$matrix3D;
+            const input = nonNull(verts, "verts").$a;
+            const out = nonNull(projected, "projectedVerts");
+            const uvt = nonNull(uvts, "uvts");
+            grow(uvt, input.length);
+            grow(out, Math.floor(input.length / 3) * 2);
+            for (let i = 0, j = 0; i + 2 < input.length; i += 3, j += 2) {
+                const [x, y, , w] = transform3D(raw, Number(input[i]), Number(input[i + 1]), Number(input[i + 2]));
+                out.$a[j] = x / w;
+                out.$a[j + 1] = y / w;
+                uvt.$a[i + 2] = 1 / w;
+            }
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.geom::Utils3D", Utils3DNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/globalization/Collator.js

@@ -0,0 +1,149 @@
+// flash.globalization.Collator onto Intl.Collator. Intl has no options for
+// character width or kana, so those fold the strings before comparing:
+// full- and half-width forms to their plain ones, hiragana to katakana.
+// Where ICU's order and Windows' differ in their data (kana, widths), ICU's stands.
+import { avm2 } from "../../../../runtime/index.js";
+import { availableLocales, NO_ERROR, nonNull, resolveLocale, UNSUPPORTED_ERROR, } from "./locale.js";
+class CollatorSettings {
+    status;
+    locale;
+    ignoreCase;
+    ignoreDiacritics;
+    ignoreKanaType;
+    ignoreSymbols;
+    ignoreCharacterWidth;
+    numericComparison = false;
+    collator = null;
+    constructor(locale, matching) {
+        this.locale = locale;
+        this.status = locale.status;
+        this.ignoreCase = matching;
+        this.ignoreDiacritics = matching;
+        this.ignoreKanaType = matching;
+        this.ignoreSymbols = matching;
+        this.ignoreCharacterWidth = matching;
+    }
+    set(option, value) {
+        this[option] = value;
+        this.collator = null;
+        // Flash in adl reports numeric comparison unsupported, and compares as it would without it.
+        this.status = option === "numericComparison" ? UNSUPPORTED_ERROR : NO_ERROR;
+    }
+    compare(a, b) {
+        this.collator ??= new Intl.Collator(this.locale.actual, {
+            sensitivity: this.ignoreCase
+                ? this.ignoreDiacritics
+                    ? "base"
+                    : "accent"
+                : this.ignoreDiacritics
+                    ? "case"
+                    : "variant",
+            ignorePunctuation: this.ignoreSymbols,
+        });
+        this.status = NO_ERROR;
+        // Windows tells a string of what it ignores alone from the empty one.
+        if ((a === "") !== (b === "")) {
+            return a === "" ? -1 : 1;
+        }
+        a = this.fold(a);
+        b = this.fold(b);
+        // Windows' word sort sets hyphens and apostrophes aside, so that "co-op" stays beside
+        // "coop": compared without them, then by how many each has, after the same word without.
+        const words = (text) => text.replace(/['-]/g, "");
+        const count = (text) => text.length - words(text).length;
+        if (this.ignoreSymbols) {
+            return this.collator.compare(a, b);
+        }
+        return (this.collator.compare(words(a), words(b)) ||
+            Math.sign(count(a) - count(b)) ||
+            this.collator.compare(a, b));
+    }
+    fold(text) {
+        // Windows takes ß for ss at every strength, where ICU tells them apart.
+        text = text.replaceAll("\u00df", "ss").replaceAll("\u1e9e", "SS");
+        if (this.ignoreCharacterWidth) {
+            text = text.replace(/[\uff01-\uffee]/g, (c) => c.normalize("NFKC"));
+        }
+        if (this.ignoreKanaType) {
+            text = text.replace(/[\u3041-\u3096\u309d\u309e]/g, (c) => String.fromCharCode(c.charCodeAt(0) + 0x60));
+        }
+        // ICU's ignorePunctuation leaves symbols ("$1" against "1"), which Windows ignores too.
+        if (this.ignoreSymbols) {
+            text = text.replace(/\p{S}/gu, "");
+        }
+        return text;
+    }
+}
+export function collatorNatives(s) {
+    const natives = {};
+    const settings = (o) => o.$settings;
+    const strings = (a, b) => [
+        nonNull(s, a, "string1"),
+        nonNull(s, b, "string2"),
+    ];
+    class CollatorNatives {
+        static getAvailableLocaleIDNames() {
+            return availableLocales(s);
+        }
+        "flash.globalization:Collator::ctor"(name, mode) {
+            const locale = resolveLocale(s, nonNull(s, name, "requestedLocaleIDName"));
+            if (nonNull(s, mode, "initialMode") !== "sorting" && mode !== "matching") {
+                throw s.rt.error("ArgumentError", 1508, "initialMode");
+            }
+            this.$settings = new CollatorSettings(locale, mode === "matching");
+        }
+        get lastOperationStatus() {
+            return settings(this).status;
+        }
+        get requestedLocaleIDName() {
+            return settings(this).locale.requested;
+        }
+        get actualLocaleIDName() {
+            return settings(this).locale.actual;
+        }
+        get ignoreCase() {
+            return settings(this).ignoreCase;
+        }
+        set ignoreCase(v) {
+            settings(this).set("ignoreCase", v);
+        }
+        get ignoreDiacritics() {
+            return settings(this).ignoreDiacritics;
+        }
+        set ignoreDiacritics(v) {
+            settings(this).set("ignoreDiacritics", v);
+        }
+        get ignoreKanaType() {
+            return settings(this).ignoreKanaType;
+        }
+        set ignoreKanaType(v) {
+            settings(this).set("ignoreKanaType", v);
+        }
+        get ignoreSymbols() {
+            return settings(this).ignoreSymbols;
+        }
+        set ignoreSymbols(v) {
+            settings(this).set("ignoreSymbols", v);
+        }
+        get ignoreCharacterWidth() {
+            return settings(this).ignoreCharacterWidth;
+        }
+        set ignoreCharacterWidth(v) {
+            settings(this).set("ignoreCharacterWidth", v);
+        }
+        get numericComparison() {
+            return settings(this).numericComparison;
+        }
+        set numericComparison(v) {
+            settings(this).set("numericComparison", v);
+        }
+        compare(a, b) {
+            return settings(this).compare(...strings(a, b));
+        }
+        equals(a, b) {
+            return settings(this).compare(...strings(a, b)) === 0;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.globalization::Collator", CollatorNatives);
+    return natives;
+}