@swf2es/player-hosts 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,614 @@
+import { avm2 } from "../../../../runtime/index.js";
+import { bounds, boundsIn, hitsObject, hitsPoint, placedRect, toStage, } from "../../../display/bounds.js";
+import { ButtonObject, CONTENT, MovieClip, rootOf, scriptWork, TextObject, TRANSFORM, } from "../../../display/display.js";
+import { copyFilter } from "../../../display/filters.js";
+import { apply, invert, isProjective } from "../../../display/geometry.js";
+import { stagePoint3D } from "../../../display/perspective.js";
+import { gridInside, sliceBounds } from "../../../display/scale9.js";
+import { filterClassName, filterKindOf, recordOf } from "../filters/BitmapFilter.js";
+import { copyMap } from "../filters/DisplacementMapFilter.js";
+import { colorOf, matrixOf } from "../geom/Transform.js";
+import { kernelOfShader, shaderUse } from "./shaders.js";
+const MATRIX_NAME = avm2.qname(avm2.publicNs, "matrix");
+const COLOR_NAME = avm2.qname(avm2.publicNs, "colorTransform");
+const name = (n) => avm2.qname(avm2.publicNs, n);
+/** The blend modes Flash accepts; another is ArgumentError #2008. */
+const BLEND_MODES = new Set([
+    "normal",
+    "layer",
+    "multiply",
+    "screen",
+    "lighten",
+    "darken",
+    "difference",
+    "add",
+    "subtract",
+    "invert",
+    "alpha",
+    "erase",
+    "overlay",
+    "hardlight",
+    "shader",
+]);
+/** The nearest whole number, a half to the even one. */
+function halfEven(v) {
+    const r = Math.round(v);
+    return r - v === 0.5 && r % 2 !== 0 ? r - 1 : r;
+}
+function point(s, x, y) {
+    return s.rt.construct(s.rt.classNamed("flash.geom::Point"), x, y);
+}
+/** A point of the stage's in `d`'s plane: through a 3D object's in perspective, NaN where the matrices flatten it. */
+function stageToLocal(s, d, p) {
+    const x = Number(s.rt.getProperty(p, name("x")));
+    const y = Number(s.rt.getProperty(p, name("y")));
+    const up = toStage(d, s.stage);
+    const m = invert(up);
+    if (m) {
+        return apply(m, x, y);
+    }
+    // Divided by the zero determinant all the same: infinities where a point is off the line.
+    const dx = x - up.tx;
+    const dy = y - up.ty;
+    return [(up.d * dx - up.c * dy) / 0, (up.a * dy - up.b * dx) / 0];
+}
+/** Flash keeps positions in twips, so what it reports of bounds is a multiple of a twentieth. */
+const twips = (v) => Math.round(v * 20) / 20;
+/** The object's width and height in its parent's space, or what that would be for one with no parent: its bounds through its own matrix. */
+function size(d) {
+    const r = placedRect(d, bounds(d, true) ?? { xMin: 0, yMin: 0, xMax: 0, yMax: 0 });
+    return [twips(r.xMax - r.xMin), twips(r.yMax - r.yMin)];
+}
+function rectangle(s, r) {
+    return s.rt.construct(s.rt.classNamed("flash.geom::Rectangle"), twips(r.xMin), twips(r.yMin), twips(r.xMax - r.xMin), twips(r.yMax - r.yMin));
+}
+/**
+ * A text field's x and y are its box's corner, not its origin: its
+ * DefineEditText bounds' corner, scaled, added to where it is placed, as
+ * Flash and Ruffle read and set them. A box authored inset from its origin
+ * so moves to where a script puts it. The offset is whole twips, cut
+ * toward zero as Ruffle's is, and none for a NaN scale.
+ */
+function fieldOffset(d) {
+    if (!(d instanceof TextObject)) {
+        return [0, 0];
+    }
+    const twips = (v) => Math.trunc(v) || 0;
+    return [twips(d.scaleX * d.left * 20), twips(d.scaleY * d.top * 20)];
+}
+/**
+ * `at` in pixels moved by `offset` in twips, summed in twips: Flash's
+ * positions are whole twips, without a pixel sum's noise.
+ */
+/**
+ * A position as Flash keeps it, in whole twips: truncated toward zero, and
+ * past int's range int's least, as x86 converts it (the bitmap-sampling
+ * case's traces, from adl). NaN is 0.
+ */
+function wholeTwips(v) {
+    const twips = Math.trunc((v || 0) * 20);
+    return (twips >= -0x80000000 && twips <= 0x7fffffff ? twips : -0x80000000) / 20;
+}
+function withOffset(at, offset) {
+    return offset === 0 ? at : (at * 20 + offset) / 20;
+}
+/** The display object `o` is the face of. */
+export function displayOf(o) {
+    return o.$display;
+}
+export function displayObjectHooks(s) {
+    return {
+        "flash.display::DisplayObject": {
+            // The one the player has pending, when it constructs a timeline child's
+            // class; else one for the class, for a `new` from a script.
+            create: (traits) => {
+                const o = Object.create(traits.proto);
+                const made = s.pending === null;
+                const display = s.pending ?? s.symbols.displayFor(traits);
+                s.pending = null;
+                // Flash names each display object without a name of its own as it
+                // is made, instance1, instance2, ..., the stage aside.
+                if (display.name === "" && display !== s.stage) {
+                    display.name = `instance${++s.instances}`;
+                }
+                o.$display = display;
+                display.object = o;
+                // A clip alive now has its frame scripts to run (Scripting.runFrameScripts).
+                scriptWork.changes++;
+                // Only a MovieClip plays its timeline: a sprite bound to a class that
+                // extends Sprite alone stays on its first frame, as fl.controls'
+                // components do, whose second frame holds their skins. An AVM1
+                // movie's root, an AVM1Movie, is no Sprite and plays.
+                if (display instanceof MovieClip && spriteOnly(traits)) {
+                    display.playing = false;
+                }
+                if (made) {
+                    s.lifecycle.made(display);
+                }
+                return o;
+            },
+        },
+    };
+}
+/** Whether `traits` is Sprite's or a subclass's that does not extend MovieClip. */
+function spriteOnly(traits) {
+    for (let t = traits; t; t = t.base) {
+        if (t.name === "flash.display::MovieClip") {
+            return false;
+        }
+        if (t.name === "flash.display::Sprite") {
+            return true;
+        }
+    }
+    return false;
+}
+/** Move a display object, by a copy of its matrix, and have it drawn again. */
+function transform(d, change) {
+    const m = { ...d.matrix };
+    change(m);
+    d.matrix = m;
+    d.touch();
+    d.invalidate(TRANSFORM);
+}
+const IDENTITY_COLOR = { rMul: 1, gMul: 1, bMul: 1, aMul: 1, rAdd: 0, gAdd: 0, bAdd: 0, aAdd: 0 };
+/** Whether `d` is on the display list: under the stage. */
+function onStage(s, d) {
+    for (let o = d; o; o = o.parent) {
+        if (o === s.stage) {
+            return true;
+        }
+    }
+    return false;
+}
+export function displayObjectNatives(s) {
+    const natives = {};
+    // How the natives are written: each runs with the AS3 object as `this`,
+    // whose $display is the player's display object (registerNativeClass).
+    class DisplayObjectNatives {
+        get name() {
+            return this.$display.name;
+        }
+        /** Flash refuses a timeline-placed object's name, so a script's touch there never marks it (the `replaces` case). */
+        set name(v) {
+            if (v === null || v === undefined) {
+                throw s.rt.error("TypeError", 2007, "name");
+            }
+            if (this.$display.placeFrame > 0) {
+                throw s.rt.error("flash.errors::IllegalOperationError", 2078);
+            }
+            this.$display.name = v;
+        }
+        get visible() {
+            return this.$display.visible;
+        }
+        // Visible, mask and cacheAsBitmap are no touch in Flash, whatever they are set to: the
+        // timeline still puts another shape or text in the object's place (`scripted-touch`).
+        set visible(v) {
+            this.$display.visible = !!v;
+            this.$display.invalidate(TRANSFORM);
+            if (!v) {
+                this.$display.focusDrop?.(this.$display);
+            }
+        }
+        get x() {
+            return withOffset(this.$display.matrix.tx, fieldOffset(this.$display)[0]);
+        }
+        // A NaN position is 0, as Flash has it (the corpus's `displayobject_invalid_floats`), and
+        // any other in whole twips.
+        set x(v) {
+            const offset = fieldOffset(this.$display)[0];
+            if (this.$display.space) {
+                this.$display.touch();
+                this.$display.set3D("x", withOffset(Number(v) || 0, -offset));
+                return;
+            }
+            transform(this.$display, (m) => {
+                m.tx = withOffset(wholeTwips(Number(v)), -offset);
+            });
+        }
+        get y() {
+            return withOffset(this.$display.matrix.ty, fieldOffset(this.$display)[1]);
+        }
+        set y(v) {
+            const offset = fieldOffset(this.$display)[1];
+            if (this.$display.space) {
+                this.$display.touch();
+                this.$display.set3D("y", withOffset(Number(v) || 0, -offset));
+                return;
+            }
+            transform(this.$display, (m) => {
+                m.ty = withOffset(wholeTwips(Number(v)), -offset);
+            });
+        }
+        // The scales and the rotation are the display object's own, kept apart from the matrix as Flash keeps them.
+        get scaleX() {
+            return this.$display.scaleX;
+        }
+        set scaleX(v) {
+            this.$display.touch();
+            this.$display.setScaleX(Number(v));
+        }
+        get scaleY() {
+            return this.$display.scaleY;
+        }
+        set scaleY(v) {
+            this.$display.touch();
+            this.$display.setScaleY(Number(v));
+        }
+        get rotation() {
+            return this.$display.rotation;
+        }
+        set rotation(v) {
+            this.$display.touch();
+            this.$display.setRotation(Number(v));
+        }
+        // Any of these set puts the object in 3D, even to what it was (the corpus's `displayobject_z`).
+        get z() {
+            return this.$display.space?.z ?? 0;
+        }
+        set z(v) {
+            this.$display.touch();
+            this.$display.set3D("z", Number(v));
+        }
+        get rotationX() {
+            return this.$display.space?.rotationX ?? 0;
+        }
+        set rotationX(v) {
+            this.$display.touch();
+            this.$display.set3D("rotationX", Number(v));
+        }
+        get rotationY() {
+            return this.$display.space?.rotationY ?? 0;
+        }
+        set rotationY(v) {
+            this.$display.touch();
+            this.$display.set3D("rotationY", Number(v));
+        }
+        // 0 in 2D, whatever the rotation, as Flash reads it.
+        get rotationZ() {
+            return this.$display.space ? this.$display.rotation : 0;
+        }
+        set rotationZ(v) {
+            this.$display.touch();
+            this.$display.set3D("rotationZ", Number(v));
+        }
+        get scaleZ() {
+            return this.$display.space?.scaleZ ?? 1;
+        }
+        set scaleZ(v) {
+            this.$display.touch();
+            this.$display.set3D("scaleZ", Number(v));
+        }
+        get alpha() {
+            return this.$display.colorTransform?.aMul ?? 1;
+        }
+        set alpha(v) {
+            const d = this.$display;
+            d.touch();
+            d.colorTransform = { ...(d.colorTransform ?? IDENTITY_COLOR), aMul: Number(v) };
+            d.invalidate(TRANSFORM);
+        }
+        // A button's state has none: the button is no container to a script.
+        get parent() {
+            const parent = this.$display.parent;
+            return parent instanceof ButtonObject ? null : (parent?.object ?? null);
+        }
+        get stage() {
+            return onStage(s, this.$display) ? (s.stage?.object ?? null) : null;
+        }
+        /** The root of the SWF this is in, main or loaded; null off the display list, as Flash has it. */
+        get root() {
+            return rootOf(this.$display)?.object ?? null;
+        }
+        /** The LoaderInfo of the SWF this is in; null off the display list. */
+        // The stage's is the main SWF's, as Flash's.
+        get loaderInfo() {
+            if (this.$display === s.stage) {
+                return s.root?.loaderInfo ?? null;
+            }
+            return rootOf(this.$display)?.loaderInfo ?? null;
+        }
+        get mouseX() {
+            const m = invert(toStage(this.$display, s.stage));
+            return m ? apply(m, s.mouseStageX, s.mouseStageY)[0] : 0;
+        }
+        get mouseY() {
+            const m = invert(toStage(this.$display, s.stage));
+            return m ? apply(m, s.mouseStageX, s.mouseStageY)[1] : 0;
+        }
+        /** The bounds through the object's own matrix, in its parent's space. */
+        get width() {
+            return size(this.$display)[0];
+        }
+        /**
+         * scaleX becomes the value over the object's untransformed width, as
+         * Flash sets it: positive whatever the sign was, from a scale of 0 as
+         * from any other, and not at all for a negative value or no width.
+         * Under a turn or skew, where Flash's rule is more involved, the
+         * current scale is adjusted in proportion instead. The width is
+         * Flash's, in twips: a drawing thinner than one is no width (the
+         * corpus's `nan_scale`).
+         */
+        set width(v) {
+            const value = Number(v);
+            if (!(value >= 0)) {
+                return;
+            }
+            const d = this.$display;
+            d.touch();
+            // A TextField's is its field's, resized at its scale, the text as it was.
+            if (d instanceof TextObject) {
+                d.width = value / (Math.abs(d.scaleX) || 1);
+                d.invalidate(CONTENT);
+                d.fit();
+                return;
+            }
+            const r = bounds(d, true);
+            const base = r ? twips(r.xMax - r.xMin) : 0;
+            const current = d.rotation === 0 && d.skew === 0 ? base : size(d)[0];
+            // Nothing to measure that way: a scale of 0, as adl gives it, and of 0 the other way too
+            // where there is nothing at all, so that content drawn later stays unseen (size-of-empty).
+            if (!(current > 0)) {
+                d.setScaleX(0);
+                if (r === null) {
+                    d.setScaleY(0);
+                }
+            }
+            else if (d.rotation === 0 && d.skew === 0) {
+                d.setScaleX(value / base);
+            }
+            else {
+                d.setScaleX((d.scaleX * value) / current);
+            }
+        }
+        get height() {
+            return size(this.$display)[1];
+        }
+        set height(v) {
+            const value = Number(v);
+            if (!(value >= 0)) {
+                return;
+            }
+            const d = this.$display;
+            d.touch();
+            // A TextField's is its field's, resized at its scale, the text as it was.
+            if (d instanceof TextObject) {
+                d.height = value / (Math.abs(d.scaleY) || 1);
+                d.invalidate(CONTENT);
+                d.fit();
+                return;
+            }
+            const r = bounds(d, true);
+            const base = r ? twips(r.yMax - r.yMin) : 0;
+            const current = d.rotation === 0 && d.skew === 0 ? base : size(d)[1];
+            // Nothing to measure that way: a scale of 0, as adl gives it, and of 0 the other way too
+            // where there is nothing at all, so that content drawn later stays unseen (size-of-empty).
+            if (!(current > 0)) {
+                d.setScaleY(0);
+                if (r === null) {
+                    d.setScaleX(0);
+                }
+            }
+            else if (d.rotation === 0 && d.skew === 0) {
+                d.setScaleY(value / base);
+            }
+            else {
+                d.setScaleY((d.scaleY * value) / current);
+            }
+        }
+        getBounds(target) {
+            return rectangle(s, boundsIn(this.$display, target?.$display ?? null, s.stage, true));
+        }
+        getRect(target) {
+            return rectangle(s, boundsIn(this.$display, target?.$display ?? null, s.stage, false));
+        }
+        /** hitTestPoint(x, y, shapeFlag) asks with `point`; hitTestObject(other) without. */
+        "flash.display:DisplayObject::_hitTest"(point, x, y, shape, other) {
+            if (point) {
+                return hitsPoint(this.$display, Number(x), Number(y), !!shape, s.root);
+            }
+            const o = other?.$display;
+            return o ? hitsObject(this.$display, o, s.stage) : false;
+        }
+        get blendMode() {
+            return this.$display.blendMode;
+        }
+        set blendMode(v) {
+            const mode = s.rt.toString(v);
+            if (!BLEND_MODES.has(mode)) {
+                throw s.rt.error("ArgumentError", 2008, "blendMode");
+            }
+            this.$display.touch();
+            this.$display.setBlendMode(mode);
+        }
+        /** Taken as it is set, its first input what is below and its second the object (shaders.ts). */
+        set blendShader(v) {
+            if (v === null || v === undefined) {
+                throw s.rt.error("TypeError", 2007, "blendShader");
+            }
+            // A Shader of no kernel has no data to blend with, as adl words it.
+            if (!kernelOfShader(v)) {
+                throw s.rt.error("TypeError", 2007, "data");
+            }
+            this.$display.touch();
+            this.$display.setBlendShader(shaderUse(s, v, 2));
+        }
+        // Flash caches an object with filters whatever cacheAsBitmap was set to, and reads it so.
+        get cacheAsBitmap() {
+            return this.$display.cachedAsBitmap || this.$display.filters.length > 0;
+        }
+        set cacheAsBitmap(v) {
+            this.$display.setCachedAsBitmap(!!v);
+        }
+        get cacheAsBitmapMatrix() {
+            return this.$cacheAsBitmapMatrix ?? null;
+        }
+        set cacheAsBitmapMatrix(v) {
+            this.$cacheAsBitmapMatrix = v;
+        }
+        /** Copies each time, as Flash gives them: `filters === filters` is false, and a filter changed is not the object's. */
+        get filters() {
+            return s.rt.array(this.$display.filters.map((f) => {
+                const o = s.rt.construct(s.rt.classNamed(filterClassName(f.kind)));
+                o.$filter = copyFilter(f);
+                return o;
+            }));
+        }
+        // A list refused, #2005, leaves the object untouched (`scripted-moves`).
+        set filters(v) {
+            const list = v ? (v.$a ?? []) : [];
+            const filters = list.map((item) => {
+                const kind = item && typeof item === "object" ? filterKindOf(s.rt, item) : null;
+                if (!kind) {
+                    throw s.rt.error("ArgumentError", 2005, 0, "Filter");
+                }
+                const f = copyFilter(recordOf(item, kind));
+                // A displacement map's pixels are taken as they are, as Flash takes
+                // them: the object draws with those, whatever is drawn on the map
+                // after, till its filters are set again; the map itself it keeps.
+                if (f.kind === "displacementMap" && f.mapBitmap) {
+                    f.mapSnapshot = copyMap(s, f.mapBitmap);
+                }
+                // A kernel's parameters and images likewise, its first input the object (shaders.ts).
+                if (f.kind === "shader") {
+                    if (!kernelOfShader(f.shader)) {
+                        throw s.rt.error("ArgumentError", 2171);
+                    }
+                    f.shaderUse = shaderUse(s, f.shader, 1);
+                }
+                return f;
+            });
+            this.$display.touch();
+            this.$display.filters = filters;
+            this.$display.invalidate(TRANSFORM);
+        }
+        get mask() {
+            return this.$display.mask?.object ?? null;
+        }
+        set mask(v) {
+            const mask = v?.$display ?? null;
+            this.$display.setMask(mask);
+        }
+        get metaData() {
+            return this.$metaData ?? null;
+        }
+        set metaData(v) {
+            this.$metaData = v;
+        }
+        get opaqueBackground() {
+            return this.$opaqueBackground ?? null;
+        }
+        set opaqueBackground(v) {
+            this.$display.touch();
+            this.$opaqueBackground = v === null || v === undefined ? null : s.rt.toUint(v);
+        }
+        /** Whole pixels, each of x, y, width and height cut toward 0, as adl reports a grid. */
+        get scale9Grid() {
+            const g = this.$display.scale9Grid;
+            return g
+                ? s.rt.construct(s.rt.classNamed("flash.geom::Rectangle"), Math.trunc(g.xMin), Math.trunc(g.yMin), Math.trunc(g.xMax - g.xMin), Math.trunc(g.yMax - g.yMin))
+                : null;
+        }
+        /**
+         * Kept in whole pixels, cut toward 0. A grid not strictly inside the
+         * bounds a grid divides (display/scale9.ts), as given, is kept as well,
+         * and then refused with ArgumentError #2004, as adl does.
+         */
+        set scale9Grid(v) {
+            const d = this.$display;
+            d.touch();
+            d.invalidate(CONTENT);
+            if (!v) {
+                d.scale9Grid = null;
+                return;
+            }
+            const [x, y, w, h] = ["x", "y", "width", "height"].map((k) => Number(s.rt.getProperty(v, name(k))));
+            const [cx, cy] = [Math.trunc(x), Math.trunc(y)];
+            d.scale9Grid = { xMin: cx, yMin: cy, xMax: cx + Math.trunc(w), yMax: cy + Math.trunc(h) };
+            if (!gridInside(sliceBounds(d), { xMin: x, yMin: y, xMax: x + w, yMax: y + h })) {
+                throw s.rt.error("ArgumentError", 2004);
+            }
+        }
+        get scrollRect() {
+            const r = this.$display.scrollRect;
+            return r ? rectangle(s, r) : null;
+        }
+        /** Each edge to a whole pixel, a half to even, as Flash keeps them; drawn from the next render. */
+        set scrollRect(v) {
+            this.$display.touch();
+            let r = null;
+            if (v) {
+                const [x, y, w, h] = ["x", "y", "width", "height"].map((k) => Number(s.rt.getProperty(v, name(k))));
+                r = { xMin: halfEven(x), yMin: halfEven(y), xMax: halfEven(x + w), yMax: halfEven(y + h) };
+            }
+            this.$display.scrollRect = r;
+            s.scrolled.add(this.$display);
+        }
+        get accessibilityProperties() {
+            return this.$accessibilityProperties ?? null;
+        }
+        set accessibilityProperties(v) {
+            this.$accessibilityProperties = v;
+        }
+        /** A point of this object's space in the stage's: through the matrices up to the stage. */
+        /** Through a plane, to a whole pixel, as adl gives it (the `three-d-bounds` case). */
+        localToGlobal(p) {
+            const m = toStage(this.$display, s.stage);
+            const x = Number(s.rt.getProperty(p, name("x")));
+            const y = Number(s.rt.getProperty(p, name("y")));
+            const [gx, gy] = apply(m, x, y);
+            return isProjective(m) ? point(s, Math.round(gx) + 0, Math.round(gy) + 0) : point(s, gx, gy);
+        }
+        /**
+         * A point of the stage's space in this object's: the inverse of the way up. Through a plane,
+         * to a twip, as adl gives it.
+         */
+        globalToLocal(p) {
+            const [x, y] = stageToLocal(s, this.$display, p);
+            if (!isProjective(toStage(this.$display, s.stage))) {
+                return point(s, x, y);
+            }
+            return point(s, Math.round(x * 20) / 20 + 0, Math.round(y * 20) / 20 + 0);
+        }
+        /**
+         * A point of this object's 3D space on the stage: through the 3D
+         * transforms above it to its projector's space, projected there, as
+         * drawn. Flash reports it to a quarter pixel.
+         */
+        local3DToGlobal(v) {
+            const get = (key) => Number(s.rt.getProperty(v, name(key)));
+            const [x, y] = stagePoint3D(this.$display, get("x"), get("y"), get("z"), s.stage);
+            return point(s, Math.round(x * 4) / 4, Math.round(y * 4) / 4);
+        }
+        /** The point of this object's plane, z = 0, under a point of the stage, as a Vector3D. */
+        globalToLocal3D(p) {
+            const [x, y] = stageToLocal(s, this.$display, p);
+            return s.rt.construct(s.rt.classNamed("flash.geom::Vector3D"), x, y, 0);
+        }
+        /** One Transform per display object, made when first asked for. */
+        get transform() {
+            if (!this.$transform) {
+                this.$transform = s.rt.construct(s.rt.classNamed("flash.geom::Transform"), this);
+            }
+            return this.$transform;
+        }
+        /** Takes the given Transform's matrix, 2D or 3D, and color transform, not the object. */
+        set transform(v) {
+            if (v) {
+                const t = v;
+                const from = t.$display;
+                if (from.space) {
+                    this.$display.setMatrix3D(from.space.shown);
+                }
+                else {
+                    this.$display.setMatrix(matrixOf(s, s.rt.getProperty(t, MATRIX_NAME)));
+                }
+                this.$display.colorTransform = colorOf(s, s.rt.getProperty(t, COLOR_NAME));
+                this.$display.touch();
+                this.$display.invalidate(TRANSFORM);
+            }
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::DisplayObject", DisplayObjectNatives);
+    return natives;
+}