@swf2es/player-hosts 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,361 @@
+// flash.geom.Matrix3D's 16 float32 values, in column-major rawData order,
+// and its arithmetic, display/matrix3d.ts's float32 as Flash's.
+import { avm2 } from "../../../../runtime/index.js";
+import { compose3D, decompose3D, determinant3D, interpolate3D, invert3D, multiply3D, pointAt3D, rotation3D, scale3D, transform3D, translation3D, } from "../../../display/matrix3d.js";
+/** The first index copyRawDataTo refuses: 2^28. */
+const MAX_INDEX = 0x10000000;
+function identity() {
+    return Float32Array.of(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+}
+/** Matrix3D's values; its native constructor assigns them. */
+function data(o) {
+    return o.$matrix3D;
+}
+const ORIENTATIONS = ["eulerAngles", "axisAngle", "quaternion"];
+/**
+ * The members that change a Matrix3D in place and tell a display object that holds it. Flash's
+ * copyToMatrix3D, copyRowFrom and copyColumnFrom change it without telling it: the object stays
+ * where it was (Space.shown), its properties as they were (`three-d-matrix`).
+ */
+const CHANGES = [
+    "rawData",
+    "copyFrom",
+    "copyRawDataFrom",
+    "identity",
+    "transpose",
+    "appendTranslation",
+    "prependTranslation",
+    "appendScale",
+    "prependScale",
+    "appendRotation",
+    "prependRotation",
+    "append",
+    "prepend",
+    "invert",
+    "position",
+    "pointAt",
+    "recompose",
+    "interpolateTo",
+];
+export function matrix3DNatives(s) {
+    const natives = {};
+    let numberVector = null;
+    const axes = ["x", "y", "z", "w"];
+    const checkedAxis = (value, axis) => {
+        if (value === null || value === undefined) {
+            throw s.rt.error("TypeError", 2007, "vector3D");
+        }
+        const n = s.rt.toUint(axis);
+        if (n > 3) {
+            throw s.rt.error("ArgumentError", 2004);
+        }
+        return n;
+    };
+    const vector = (values) => {
+        numberVector ??= s.rt.resolve(s.rt.vector("Number"));
+        const o = numberVector.$it.instance();
+        o.$a = Array.from(values);
+        return o;
+    };
+    const nonNull = (v, name) => {
+        if (v === null || v === undefined) {
+            throw s.rt.error("TypeError", 2007, name);
+        }
+        return v;
+    };
+    const vector3D = (x, y, z, w) => s.rt.construct(s.rt.classNamed("flash.geom::Vector3D"), x, y, z, w);
+    const read3D = (v) => axes.map((axis) => s.rt.toNumber(s.rt.getProperty(v, s.rt.publicName(axis))));
+    const xyz = (v) => {
+        const [x, y, z] = read3D(v);
+        return [x, y, z];
+    };
+    const matrix3D = (raw) => {
+        const o = s.rt.construct(s.rt.classNamed("flash.geom::Matrix3D"));
+        data(o).set(raw);
+        return o;
+    };
+    const orientation = (style) => {
+        const name = s.rt.toString(nonNull(style, "orientationStyle"));
+        if (!ORIENTATIONS.includes(name)) {
+            throw s.rt.error("Error", 2187, name);
+        }
+        return name;
+    };
+    const scales = (x, y, z) => {
+        const sx = s.rt.toNumber(x);
+        const sy = s.rt.toNumber(y);
+        const sz = s.rt.toNumber(z);
+        if (sx === 0 || sy === 0 || sz === 0) {
+            throw s.rt.error("ArgumentError", 2183);
+        }
+        return scale3D(sx, sy, sz);
+    };
+    const rotation = (degrees, axis, pivot) => rotation3D(s.rt.toNumber(degrees), read3D(nonNull(axis, "axis")), pivot === null || pivot === undefined ? [0, 0, 0] : read3D(pivot), s.rt.swfVersion >= 13);
+    class Matrix3DNatives {
+        "flash.geom:Matrix3D::ctor"(raw) {
+            const values = raw?.$a;
+            this.$matrix3D = values?.length === 16 ? Float32Array.from(values.map(Number)) : identity();
+        }
+        get rawData() {
+            return vector(data(this));
+        }
+        set rawData(raw) {
+            const values = raw?.$a;
+            if (values?.length === 16) {
+                data(this).set(values.map(Number));
+            }
+        }
+        clone() {
+            const copy = s.rt.construct(s.rt.classNamed("flash.geom::Matrix3D"));
+            data(copy).set(data(this));
+            return copy;
+        }
+        copyFrom(source) {
+            if (source === null || source === undefined) {
+                throw s.rt.error("TypeError", 2007, "source");
+            }
+            data(this).set(data(source));
+        }
+        copyToMatrix3D(dest) {
+            if (dest === null || dest === undefined) {
+                throw s.rt.error("TypeError", 2007, "dest");
+            }
+            data(dest).set(data(this));
+        }
+        copyRawDataFrom(source, index = 0, transpose = false) {
+            if (source === null || source === undefined) {
+                throw s.rt.error("TypeError", 2007, "source");
+            }
+            const values = source.$a;
+            const start = s.rt.toUint(index);
+            if (start + 16 > values.length) {
+                throw s.rt.error("ArgumentError", 2004);
+            }
+            const m = data(this);
+            if (transpose) {
+                for (let i = 0; i < 16; i++) {
+                    m[i] = Number(values[start + (i % 4) * 4 + (i >> 2)]);
+                }
+            }
+            else {
+                for (let i = 0; i < 16; i++) {
+                    m[i] = Number(values[start + i]);
+                }
+            }
+        }
+        copyRawDataTo(dest, index = 0, transpose = false) {
+            if (dest === null || dest === undefined) {
+                throw s.rt.error("TypeError", 2007, "dest");
+            }
+            const vector = dest;
+            const values = vector.$a;
+            const start = s.rt.toUint(index);
+            // Below this adl pads the vector out to the index, however far; from it, a negative index too, it refuses.
+            if (start >= MAX_INDEX) {
+                throw s.rt.error("ArgumentError", 2004);
+            }
+            if (vector.$fixed && start + 16 > values.length) {
+                throw s.rt.error("RangeError", 1126);
+            }
+            while (values.length < start + 16) {
+                values.push(0);
+            }
+            const m = data(this);
+            for (let i = 0; i < 16; i++) {
+                values[start + i] = m[transpose ? (i % 4) * 4 + (i >> 2) : i];
+            }
+        }
+        copyRowTo(row, dest) {
+            const n = checkedAxis(dest, row);
+            const m = data(this);
+            for (let i = 0; i < 4; i++) {
+                s.rt.setProperty(dest, s.rt.publicName(axes[i]), m[n + i * 4]);
+            }
+        }
+        copyColumnTo(column, dest) {
+            const n = checkedAxis(dest, column);
+            const m = data(this);
+            for (let i = 0; i < 4; i++) {
+                s.rt.setProperty(dest, s.rt.publicName(axes[i]), m[n * 4 + i]);
+            }
+        }
+        copyRowFrom(row, source) {
+            const n = checkedAxis(source, row);
+            const m = data(this);
+            for (let i = 0; i < 4; i++) {
+                m[n + i * 4] = s.rt.toNumber(s.rt.getProperty(source, s.rt.publicName(axes[i])));
+            }
+        }
+        copyColumnFrom(column, source) {
+            const n = checkedAxis(source, column);
+            const m = data(this);
+            for (let i = 0; i < 4; i++) {
+                m[n * 4 + i] = s.rt.toNumber(s.rt.getProperty(source, s.rt.publicName(axes[i])));
+            }
+        }
+        identity() {
+            data(this).set(identity());
+        }
+        transpose() {
+            const m = data(this);
+            for (let row = 0; row < 4; row++) {
+                for (let col = row + 1; col < 4; col++) {
+                    const a = row * 4 + col;
+                    const b = col * 4 + row;
+                    const value = m[a];
+                    m[a] = m[b];
+                    m[b] = value;
+                }
+            }
+        }
+        appendTranslation(x, y, z) {
+            const m = data(this);
+            m[12] += Math.fround(s.rt.toNumber(x));
+            m[13] += Math.fround(s.rt.toNumber(y));
+            m[14] += Math.fround(s.rt.toNumber(z));
+        }
+        prependTranslation(x, y, z) {
+            const t = translation3D(s.rt.toNumber(x), s.rt.toNumber(y), s.rt.toNumber(z));
+            data(this).set(multiply3D(data(this), t));
+        }
+        appendScale(x, y, z) {
+            data(this).set(multiply3D(scales(x, y, z), data(this)));
+        }
+        prependScale(x, y, z) {
+            data(this).set(multiply3D(data(this), scales(x, y, z)));
+        }
+        appendRotation(degrees, axis, pivot = null) {
+            data(this).set(multiply3D(rotation(degrees, axis, pivot), data(this)));
+        }
+        prependRotation(degrees, axis, pivot = null) {
+            data(this).set(multiply3D(data(this), rotation(degrees, axis, pivot)));
+        }
+        append(lhs) {
+            data(this).set(multiply3D(data(nonNull(lhs, "lhs")), data(this)));
+        }
+        prepend(rhs) {
+            data(this).set(multiply3D(data(this), data(nonNull(rhs, "rhs"))));
+        }
+        /** Of the opposite sign before SWF 13, as adl has it. */
+        get determinant() {
+            const d = determinant3D(data(this));
+            return s.rt.swfVersion >= 13 ? d : -d;
+        }
+        invert() {
+            const inverse = invert3D(data(this));
+            if (inverse) {
+                data(this).set(inverse);
+            }
+            return inverse !== null;
+        }
+        get position() {
+            const m = data(this);
+            return vector3D(m[12], m[13], m[14], 0);
+        }
+        set position(v) {
+            if (v === null || v === undefined) {
+                return;
+            }
+            const [x, y, z] = read3D(v);
+            const m = data(this);
+            m[12] = x;
+            m[13] = y;
+            m[14] = z;
+        }
+        // Both round the vector to float32 first; transformVectors works in doubles.
+        transformVector(v) {
+            const [x, y, z, w] = transform3D(data(this), ...xyz(nonNull(v, "vector")));
+            return vector3D(x, y, z, w);
+        }
+        deltaTransformVector(v) {
+            const [x, y, z, w] = transform3D(data(this), ...xyz(nonNull(v, "vector")), 0);
+            return vector3D(x, y, z, w);
+        }
+        transformVectors(vin, vout) {
+            const input = nonNull(vin, "vin").$a;
+            const output = nonNull(vout, "vout");
+            const n = Math.floor(input.length / 3) * 3;
+            if (n > output.$a.length) {
+                if (output.$fixed) {
+                    throw s.rt.error("RangeError", 1126, output.$a.length, n);
+                }
+                while (output.$a.length < n) {
+                    output.$a.push(0);
+                }
+            }
+            const m = Array.from(data(this));
+            for (let i = 0; i < n; i += 3) {
+                const x = Number(input[i]);
+                const y = Number(input[i + 1]);
+                const z = Number(input[i + 2]);
+                output.$a[i] = m[0] * x + m[4] * y + m[8] * z + m[12];
+                output.$a[i + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
+                output.$a[i + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
+            }
+        }
+        pointAt(pos, at = null, up = null) {
+            const turned = pointAt3D(data(this), xyz(nonNull(pos, "position")), at === null || at === undefined ? [0, 1, 0] : xyz(at), up === null || up === undefined ? [0, 0, 1] : xyz(up));
+            if (turned) {
+                data(this).set(turned);
+            }
+        }
+        decompose(style = "eulerAngles") {
+            const parts = decompose3D(data(this), orientation(style));
+            const cls = s.rt.applyType(s.rt.classNamed("__AS3__.vec::Vector"), [
+                s.rt.classNamed("flash.geom::Vector3D"),
+            ]);
+            const o = cls.$it.instance();
+            o.$a = parts.map(([x, y, z, w]) => vector3D(x, y, z, w));
+            return o;
+        }
+        /** False, the matrix left as it was, for fewer than three components or a null one. */
+        recompose(components, style = "eulerAngles") {
+            const list = nonNull(components, "components").$a;
+            const how = orientation(style);
+            const parts = list.slice(0, 3);
+            if (parts.length < 3 || parts.some((p) => p === null || p === undefined)) {
+                return false;
+            }
+            const [t, r, sc] = parts.map((p) => read3D(p));
+            data(this).set(compose3D(t, r, sc, how));
+            return true;
+        }
+        interpolateTo(to, percent) {
+            const target = data(nonNull(to, "toMat"));
+            data(this).set(interpolate3D(data(this), target, s.rt.toNumber(percent)));
+        }
+        static interpolate(from, to, percent) {
+            const a = data(nonNull(from, "fromMat"));
+            const b = data(nonNull(to, "toMat"));
+            return matrix3D(interpolate3D(a, b, s.rt.toNumber(percent)));
+        }
+    }
+    // A display object's own Matrix3D (Transform's matrix3D) shares its matrix: one changed in place
+    // has the object take it apart again, as it moves the object in Flash.
+    const told = (o) => {
+        const owner = o?.$owner;
+        owner?.matrix3DChanged(data(o));
+    };
+    const proto = Matrix3DNatives.prototype;
+    for (const name of CHANGES) {
+        const d = Object.getOwnPropertyDescriptor(proto, name);
+        if (d.set) {
+            const set = d.set;
+            d.set = function (v) {
+                set.call(this, v);
+                told(this);
+            };
+        }
+        else {
+            const method = d.value;
+            d.value = function (...args) {
+                const result = method.apply(this, args);
+                told(this);
+                return result;
+            };
+        }
+        Object.defineProperty(proto, name, d);
+    }
+    avm2.registerNativeClass(natives, "flash.geom::Matrix3D", Matrix3DNatives);
+    return natives;
+}

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

@@ -0,0 +1,122 @@
+// flash.geom.PerspectiveProjection: a field of view and a centre, of its
+// own or, got from a Transform, of its display object, which it then
+// reads and writes. The stage and each SWF's root always have one, back to
+// their defaults when set to null. What is in a display object with one
+// is drawn through it (display/perspective.ts).
+import { avm2 } from "../../../../runtime/index.js";
+import { TRANSFORM } from "../../../display/display.js";
+import { defaultProjection, focalLengthOver as focalLength } from "../../../display/perspective.js";
+const DEGREES_TO_RADIANS = Math.PI / 180;
+/** Whether `d` has a projection whatever a script sets: the stage, or a SWF's root. */
+export function alwaysProjects(s, d) {
+    return d === s.stage || d.loaderInfo !== null;
+}
+/** The projection `d` has: its own, or the default the stage, a root, or a projection's reader falls back on. */
+function projectionOf(s, d) {
+    if (d.projection) {
+        return d.projection;
+    }
+    const root = d !== s.stage && d.loaderInfo !== null;
+    return root
+        ? defaultProjection(s.stageWidth / 2, s.stageHeight / 2)
+        : defaultProjection(250, 250);
+}
+export function perspectiveProjectionNatives(s) {
+    const natives = {};
+    /** The stage's projection and one of its own measure 500 wide; any other object's, the stage's width. */
+    const width = (d) => (d && d !== s.stage ? s.stageWidth : 500);
+    const focalOf = (o) => o.$display
+        ? focalLength(projectionOf(s, o.$display).fieldOfView, width(o.$display))
+        : focalLength(o.$fieldOfView * DEGREES_TO_RADIANS, 500);
+    class PerspectiveProjectionNatives {
+        "flash.geom:PerspectiveProjection::ctor"() {
+            this.$display = null;
+            this.$fieldOfView = 55;
+            this.$centerX = 250;
+            this.$centerY = 250;
+        }
+        get fieldOfView() {
+            if (this.$display) {
+                return (projectionOf(s, this.$display).fieldOfView * 180) / Math.PI;
+            }
+            return this.$fieldOfView;
+        }
+        set fieldOfView(v) {
+            const degrees = s.rt.toNumber(v);
+            if (!(degrees > 0 && degrees < 180)) {
+                throw s.rt.error("ArgumentError", 2182);
+            }
+            if (this.$display) {
+                update(this.$display, { fieldOfView: (degrees * Math.PI) / 180 });
+            }
+            else {
+                this.$fieldOfView = degrees;
+            }
+        }
+        get focalLength() {
+            return focalOf(this);
+        }
+        set focalLength(v) {
+            const length = s.rt.toNumber(v);
+            if (!(length > 0)) {
+                throw s.rt.error("ArgumentError", 2186, length);
+            }
+            const radians = Math.atan(width(this.$display) / 2 / length) * 2;
+            if (this.$display) {
+                update(this.$display, { fieldOfView: radians });
+            }
+            else {
+                this.$fieldOfView = (radians * 180) / Math.PI;
+            }
+        }
+        get projectionCenter() {
+            const p = this.$display ? projectionOf(s, this.$display) : null;
+            return s.rt.construct(s.rt.classNamed("flash.geom::Point"), p ? p.centerX : this.$centerX, p ? p.centerY : this.$centerY);
+        }
+        set projectionCenter(v) {
+            if (v === null || v === undefined) {
+                throw s.rt.error("TypeError", 2007, "projectionCenter");
+            }
+            const point = v;
+            const x = s.rt.toNumber(s.rt.getProperty(point, s.rt.publicName("x")));
+            const y = s.rt.toNumber(s.rt.getProperty(point, s.rt.publicName("y")));
+            if (this.$display) {
+                update(this.$display, { centerX: x, centerY: y });
+            }
+            else {
+                this.$centerX = x;
+                this.$centerY = y;
+            }
+        }
+        toMatrix3D() {
+            const length = focalOf(this);
+            const m = s.rt.construct(s.rt.classNamed("flash.geom::Matrix3D"));
+            m.$matrix3D.set([length, 0, 0, 0, 0, length, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0]);
+            return m;
+        }
+    }
+    /** A change to a display object's projection, made from its current one. */
+    const update = (d, change) => {
+        d.projection = { ...projectionOf(s, d), ...change };
+        d.invalidate(TRANSFORM);
+    };
+    avm2.registerNativeClass(natives, "flash.geom::PerspectiveProjection", PerspectiveProjectionNatives);
+    return natives;
+}
+/** A PerspectiveProjection of `d`'s, which reads and writes `d`'s. */
+export function projectionObject(s, d) {
+    const o = s.rt.construct(s.rt.classNamed("flash.geom::PerspectiveProjection"));
+    o.$display = d;
+    return o;
+}
+/** What setting `o` on a transform gives: a copy of its values, in radians. */
+export function projectionFrom(s, o) {
+    if (o.$display) {
+        return { ...projectionOf(s, o.$display) };
+    }
+    return {
+        fieldOfView: (o.$fieldOfView * Math.PI) / 180,
+        centerX: o.$centerX,
+        centerY: o.$centerY,
+    };
+}