@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/player/avm1/globals/filters.js

@@ -0,0 +1,635 @@
+// flash.filters' AS2 classes, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/avm1/globals/bitmap_filter.rs, blur_filter.rs, glow_filter.rs,
+// drop_shadow_filter.rs, bevel_filter.rs, gradient_filter.rs,
+// color_matrix_filter.rs, convolution_filter.rs and
+// displacement_map_filter.rs have them: MIT OR Apache-2.0, Copyright (c)
+// 2018-2022 Ruffle LLC and Ruffle contributors. Each object holds the
+// record a display object's filters keep (display/filters.ts), its values
+// as Flash keeps them: an alpha in a byte, a strength in 256ths, a matrix
+// in floats, a gradient in sixteen slots whose alphas and ratios outlast a
+// shorter list. Its properties are getters and setters on the prototype,
+// listed, from SWF 8; read of anything else they are undefined.
+import { avm1 } from "../../../runtime/index.js";
+import { TRANSFORM } from "../../display/display.js";
+import { copyFilter, filterDefaults } from "../../display/filters.js";
+import { makeGeom } from "./geom.js";
+const MAX_COLORS = 16;
+/**
+ * A list's length is read up to this, as Function.apply's is: Flash keeps a
+ * kernel of 100,000 elements and walks a filters list as long (adl), but a
+ * script's length of 2^31 - 1 would hang the page or run it out of memory.
+ */
+const MAX_LIST = 1 << 20;
+/** The angle a new shadow, bevel or gradient filter has: 0.785398163 radians, nearly 45°. */
+const ANGLE = 0.785398163 * (180 / Math.PI);
+const states = new WeakMap();
+/** The class names by kind, as `flash.filters` has them. */
+const NAMES = {
+    blur: "BlurFilter",
+    glow: "GlowFilter",
+    dropShadow: "DropShadowFilter",
+    bevel: "BevelFilter",
+    gradientGlow: "GradientGlowFilter",
+    gradientBevel: "GradientBevelFilter",
+    colorMatrix: "ColorMatrixFilter",
+    convolution: "ConvolutionFilter",
+    displacementMap: "DisplacementMapFilter",
+};
+/** A double as a byte as Rust casts it: truncated, saturating, NaN 0. */
+const byte = (x) => (Number.isNaN(x) ? 0 : Math.max(0, Math.min(255, Math.trunc(x))));
+/** A double as a u16 as Rust casts it. */
+const u16 = (x) => (Number.isNaN(x) ? 0 : Math.max(0, Math.min(65535, Math.trunc(x))));
+/** A double as an i32 as Rust casts it: saturating, NaN 0. */
+const i32 = (x) => Number.isNaN(x) ? 0 : Math.max(-0x80000000, Math.min(0x7fffffff, Math.trunc(x)));
+const clamp = (x, lo, hi) => (x < lo ? lo : x > hi ? hi : x);
+/** A clamp that takes NaN to its low end. */
+const clampNaN = (x, lo, hi) => (Number.isNaN(x) ? lo : clamp(x, lo, hi));
+function newState(kind) {
+    const f = filterDefaults(kind);
+    if ("angle" in f) {
+        f.angle = ANGLE;
+    }
+    const gradient = kind === "gradientGlow" || kind === "gradientBevel";
+    return {
+        f,
+        slots: gradient
+            ? {
+                count: 0,
+                colors: new Array(MAX_COLORS).fill(0),
+                alphas: new Array(MAX_COLORS).fill(0),
+                ratios: new Array(MAX_COLORS).fill(0),
+            }
+            : null,
+        map: null,
+    };
+}
+/** A filter object's record, or null for anything else: what a display object or applyFilter takes. */
+export function filterRecordOf(o) {
+    const state = o instanceof avm1.Avm1Object ? states.get(o) : undefined;
+    if (state === undefined) {
+        return null;
+    }
+    // NaN and all, as AS3's records may hold them: the renderer and applyFilter take them so.
+    const f = copyFilter(state.f);
+    const slots = state.slots;
+    if (slots) {
+        f.colors = slots.colors.slice(0, slots.count);
+        f.alphas = slots.alphas.slice(0, slots.count).map((a) => a / 255);
+        f.ratios = slots.ratios.slice(0, slots.count);
+    }
+    if (f.kind === "convolution") {
+        const n = f.matrixX * f.matrixY;
+        f.matrix = Array.from({ length: n }, (_, i) => f.matrix[i] ?? 0);
+    }
+    if (f.kind === "displacementMap") {
+        f.mapBitmap = state.map && !state.map.disposed ? { $store: state.map } : null;
+    }
+    return f;
+}
+/**
+ * A display object's `filters` set from a list: the records of its filter
+ * objects up to its length, in order, anything else left out, so an object
+ * without a length sets none (adl).
+ */
+function filtersOf(value, version) {
+    const out = [];
+    const length = value instanceof avm1.Avm1Object ? lengthOf(value, version) : 0;
+    for (let i = 0; i < length; i++) {
+        const f = filterRecordOf(element(value, i, version));
+        if (f !== null) {
+            out.push(f);
+        }
+    }
+    return out;
+}
+/** An object's `length` as Flash reads it for a list: a string's its length, 0 for no int. */
+function lengthOf(value, version) {
+    if (typeof value === "string") {
+        return Math.min(value.length, MAX_LIST);
+    }
+    if (!(value instanceof avm1.Avm1Object)) {
+        return 0;
+    }
+    const n = avm1.toNumber(avm1.get(value, "length", version), version) | 0;
+    return n < 0 ? 0 : Math.min(n, MAX_LIST);
+}
+function element(value, i, version) {
+    return value instanceof avm1.Avm1Object ? avm1.get(value, String(i), version) : undefined;
+}
+const num = (v, version) => avm1.toNumber(v, version);
+function plain(name, convert) {
+    return {
+        name,
+        get: (s) => s.f[name],
+        set: (s, v, version) => {
+            s.f[name] = convert(v, version);
+        },
+    };
+}
+const distance = plain("distance", num);
+const angle = {
+    name: "angle",
+    get: (s) => s.f.angle,
+    set: (s, v, version) => {
+        s.f.angle = (num(v, version) % 360) * (Math.PI / 180) * (180 / Math.PI);
+    },
+};
+const quality = plain("quality", (v, version) => clamp(num(v, version) | 0, 0, 15));
+const strength = plain("strength", (v, version) => Math.min(u16(num(v, version) * 256), 0xff00) / 256);
+const flag = (name) => plain(name, (v, version) => avm1.toBoolean(v, version));
+const blur = (name, nanToZero = false) => plain(name, (v, version) => nanToZero ? clampNaN(num(v, version), 0, 255) : clamp(num(v, version), 0, 255));
+const rgb = (name) => plain(name, (v, version) => (num(v, version) >>> 0) & 0xffffff);
+/** An alpha kept in a byte; `unit` clamps it to 0 to 1 first, NaN 0. */
+const alpha = (name, unit = false) => plain(name, (v, version) => {
+    const a = num(v, version);
+    return byte((unit ? clampNaN(a, 0, 1) : a) * 255) / 255;
+});
+/** A bevel's type: inner, outer, or anything else full. */
+const type = plain("type", (v, version) => {
+    const t = avm1.stringOf(v, version);
+    return t === "inner" || t === "outer" ? t : "full";
+});
+/** A gradient's lists: colors set the count, ratios may lower it, alphas never change it. */
+const colors = {
+    name: "colors",
+    get: (s, version, make) => s.slots && make.list(s.slots.colors.slice(0, s.slots.count), version),
+    set: (s, v, version) => {
+        const slots = s.slots;
+        if (!slots) {
+            return;
+        }
+        slots.count = Math.min(lengthOf(v, version), MAX_COLORS);
+        for (let i = 0; i < slots.count; i++) {
+            slots.colors[i] = (num(element(v, i, version), version) | 0) & 0xffffff;
+        }
+    },
+};
+const alphas = {
+    name: "alphas",
+    get: (s, version, make) => s.slots &&
+        make.list(s.slots.alphas.slice(0, s.slots.count).map((a) => a / 255), version),
+    set: (s, v, version) => {
+        const slots = s.slots;
+        if (!slots || !(v instanceof avm1.Avm1Object)) {
+            return;
+        }
+        const length = lengthOf(v, version);
+        for (let i = 0; i < slots.count; i++) {
+            const a = i < length ? num(element(v, i, version), version) : Number.NaN;
+            slots.alphas[i] = Number.isFinite(a) ? byte(255 * a + 0.5) : 255;
+        }
+    },
+};
+const ratios = {
+    name: "ratios",
+    get: (s, version, make) => s.slots && make.list(s.slots.ratios.slice(0, s.slots.count), version),
+    set: (s, v, version) => {
+        const slots = s.slots;
+        if (!slots || !(v instanceof avm1.Avm1Object)) {
+            return;
+        }
+        slots.count = Math.min(lengthOf(v, version), slots.count);
+        for (let i = 0; i < slots.count; i++) {
+            slots.ratios[i] = clamp(num(element(v, i, version), version) | 0, 0, 255);
+        }
+    },
+};
+/** A convolution's kernel grown, never shrunk, to its size. */
+function fitKernel(f) {
+    const n = f.matrixX * f.matrixY;
+    while (f.matrix.length < n) {
+        f.matrix.push(0);
+    }
+}
+const matrixSide = (name) => ({
+    name,
+    get: (s) => s.f[name],
+    set: (s, v, version) => {
+        s.f[name] = clamp(num(v, version) | 0, 0, 15);
+        fitKernel(s.f);
+    },
+});
+const kernel = {
+    name: "matrix",
+    get: (s, version, make) => make.list(s.f.matrix, version),
+    set: (s, v, version) => {
+        const length = lengthOf(v, version);
+        const matrix = [];
+        for (let i = 0; i < length; i++) {
+            matrix.push(Math.fround(num(element(v, i, version), version)));
+        }
+        s.f.matrix = matrix;
+        fitKernel(s.f);
+    },
+};
+const float = (name) => plain(name, (v, version) => Math.fround(num(v, version)));
+/** A colour matrix's twenty floats: an object's elements, NaN past them; anything else all NaN. */
+const colorMatrix = {
+    name: "matrix",
+    get: (s, version, make) => make.list(s.f.matrix, version),
+    set: (s, v, version) => {
+        if (v === undefined || v === null) {
+            return;
+        }
+        const matrix = new Array(20).fill(Number.NaN);
+        if (v instanceof avm1.Avm1Object) {
+            for (let i = 0; i < 20; i++) {
+                if (i < lengthOf(v, version)) {
+                    matrix[i] = Math.fround(num(element(v, i, version), version));
+                }
+            }
+        }
+        s.f.matrix = matrix;
+    },
+};
+const mapBitmap = {
+    name: "mapBitmap",
+    get: (s, _, make) => (s.map ? make.bitmap(s.map) : undefined),
+    set: (s, v, _, make) => {
+        const store = make.store(v);
+        if (store !== null) {
+            s.map = store;
+        }
+    },
+};
+/**
+ * The map's point, own x and y converted both before either error is
+ * thrown, x's first; a point with only one of them, or no object, is (0, 0);
+ * one that fails to convert is int's least.
+ */
+const mapPoint = {
+    name: "mapPoint",
+    get: (s, version, make) => make.point(s.f.mapPoint[0], s.f.mapPoint[1], version),
+    set: (s, v, version) => {
+        if (!(v instanceof avm1.Avm1Object)) {
+            s.f.mapPoint = [0, 0];
+            return;
+        }
+        const convert = (name) => {
+            const p = v.own(name, version);
+            if (p === undefined) {
+                return null;
+            }
+            try {
+                return { n: i32(num(p.value, version)), error: null };
+            }
+            catch (error) {
+                return { n: -0x80000000, error };
+            }
+        };
+        const x = convert("x");
+        const y = convert("y");
+        s.f.mapPoint = x && y ? [x.n, y.n] : [0, 0];
+        if (x?.error) {
+            throw x.error;
+        }
+        if (y?.error) {
+            throw y.error;
+        }
+    },
+};
+const component = (name) => plain(name, (v, version) => num(v, version) | 0);
+const scale = (name) => plain(name, (v, version) => Math.fround(clampNaN(num(v, version), -65535, 65535)));
+const mode = plain("mode", (v, version) => {
+    const m = avm1.stringOf(v, version);
+    return m === "clamp" || m === "ignore" || m === "color" ? m : "wrap";
+});
+/** Each class's properties in Flash's order, and its constructor's arguments in theirs. */
+const CLASSES = (() => {
+    const [blurX, blurY] = [blur("blurX"), blur("blurY")];
+    const [color, a] = [rgb("color"), alpha("alpha")];
+    const [inner, knockout] = [flag("inner"), flag("knockout")];
+    const highlightColor = rgb("highlightColor");
+    const highlightAlpha = alpha("highlightAlpha");
+    const shadowColor = rgb("shadowColor");
+    const shadowAlpha = alpha("shadowAlpha");
+    const [gBlurX, gBlurY] = [blur("blurX", true), blur("blurY", true)];
+    const gradient = {
+        props: [
+            distance,
+            angle,
+            colors,
+            alphas,
+            ratios,
+            gBlurX,
+            gBlurY,
+            quality,
+            strength,
+            knockout,
+            type,
+        ],
+        args: [
+            distance,
+            angle,
+            colors,
+            alphas,
+            ratios,
+            gBlurX,
+            gBlurY,
+            strength,
+            quality,
+            type,
+            knockout,
+        ],
+    };
+    const [divisor, bias] = [float("divisor"), float("bias")];
+    const unitAlpha = alpha("alpha", true);
+    return {
+        blur: { props: [blurX, blurY, quality], args: [blurX, blurY, quality] },
+        glow: {
+            props: [color, a, quality, inner, knockout, blurX, blurY, strength],
+            args: [color, a, blurX, blurY, strength, quality, inner, knockout],
+        },
+        dropShadow: {
+            props: [
+                distance,
+                angle,
+                color,
+                a,
+                quality,
+                inner,
+                knockout,
+                blurX,
+                blurY,
+                strength,
+                flag("hideObject"),
+            ],
+            args: [
+                distance,
+                angle,
+                color,
+                a,
+                blurX,
+                blurY,
+                strength,
+                quality,
+                inner,
+                knockout,
+                flag("hideObject"),
+            ],
+        },
+        bevel: {
+            props: [
+                distance,
+                angle,
+                highlightColor,
+                highlightAlpha,
+                shadowColor,
+                shadowAlpha,
+                quality,
+                strength,
+                knockout,
+                blurX,
+                blurY,
+                type,
+            ],
+            args: [
+                distance,
+                angle,
+                highlightColor,
+                highlightAlpha,
+                shadowColor,
+                shadowAlpha,
+                blurX,
+                blurY,
+                strength,
+                quality,
+                type,
+                knockout,
+            ],
+        },
+        gradientGlow: gradient,
+        gradientBevel: gradient,
+        colorMatrix: { props: [colorMatrix], args: [colorMatrix] },
+        convolution: {
+            props: [
+                matrixSide("matrixX"),
+                matrixSide("matrixY"),
+                kernel,
+                divisor,
+                bias,
+                flag("preserveAlpha"),
+                flag("clamp"),
+                rgb("color"),
+                unitAlpha,
+            ],
+            // Its divisor and colour are the constructor's own (see below).
+            args: [matrixSide("matrixX"), matrixSide("matrixY"), kernel],
+        },
+        displacementMap: {
+            props: [
+                mapBitmap,
+                mapPoint,
+                component("componentX"),
+                component("componentY"),
+                scale("scaleX"),
+                scale("scaleY"),
+                mode,
+                rgb("color"),
+                unitAlpha,
+            ],
+            args: [
+                mapBitmap,
+                mapPoint,
+                component("componentX"),
+                component("componentY"),
+                scale("scaleX"),
+                scale("scaleY"),
+                mode,
+                rgb("color"),
+                unitAlpha,
+            ],
+        },
+    };
+})();
+/**
+ * A convolution's constructor past its kernel: a divisor not given is the
+ * kernel's sum where any argument is; a colour given makes its alpha 1,
+ * the documentation aside (Ruffle).
+ */
+function constructConvolution(s, args, version) {
+    const f = s.f;
+    if (args.length > 3) {
+        f.divisor = Math.fround(num(args[3], version));
+    }
+    else if (args.length > 0) {
+        f.divisor = Math.fround(f.matrix.reduce((sum, x) => Math.fround(sum + x), 0));
+    }
+    if (args.length > 4) {
+        f.bias = Math.fround(num(args[4], version));
+    }
+    if (args.length > 5) {
+        f.preserveAlpha = avm1.toBoolean(args[5], version);
+    }
+    if (args.length > 6) {
+        f.clamp = avm1.toBoolean(args[6], version);
+    }
+    if (args.length > 7) {
+        f.color = (num(args[7], version) >>> 0) & 0xffffff;
+        f.alpha = 1;
+    }
+    if (args.length > 8) {
+        f.alpha = byte(clampNaN(num(args[8], version), 0, 1) * 255) / 255;
+    }
+}
+/** `flash.filters`, its classes on `filters`; what reads a display object's filters back. */
+export function filtersPackage(host, filters) {
+    const realm = host.realm;
+    const make = {
+        list: (values, version) => realm.newArray([...values], version),
+        bitmap: (store) => host.bitmapObject(store),
+        point: (x, y, version) => makeGeom(realm, "Point", [x, y], version),
+        store: (value) => host.storeOf(value),
+    };
+    /** A native function as a class's constructor, `prototype` and `constructor` its own. */
+    const classOf = (proto, construct) => {
+        const constr = new avm1.Avm1Function(undefined, realm, () => undefined, construct);
+        constr.define("prototype", proto, avm1.DONT_ENUM | avm1.DONT_DELETE);
+        constr.define("constructor", realm.Function, avm1.DONT_ENUM | avm1.DONT_DELETE);
+        constr.define("__proto__", realm.functionProto, avm1.DONT_ENUM | avm1.DONT_DELETE | avm1.VERSION_6);
+        return constr;
+    };
+    // BitmapFilter: no state of its own, a clone that copies a filter's.
+    const base = new avm1.Avm1Object(realm.objectProto);
+    const baseClass = classOf(base, (self) => self);
+    base.define("constructor", baseClass, avm1.DONT_ENUM | avm1.DONT_DELETE);
+    base.define("clone", realm.method((self) => {
+        const state = states.get(self);
+        if (state === undefined) {
+            return undefined;
+        }
+        const copy = new avm1.Avm1Object(self.proto);
+        states.set(copy, cloneState(state));
+        return copy;
+    }), 0);
+    filters.define("BitmapFilter", baseClass, 0);
+    const protos = new Map();
+    // Defined in Flash's order, for..in lists them the other way round.
+    const order = [
+        "dropShadow",
+        "blur",
+        "glow",
+        "bevel",
+        "gradientGlow",
+        "gradientBevel",
+        "convolution",
+        "colorMatrix",
+        "displacementMap",
+    ];
+    for (const kind of order) {
+        const { props, args } = CLASSES[kind];
+        // As a class that extends BitmapFilter: its __constructor__, no constructor.
+        const proto = new avm1.Avm1Object(base);
+        proto.define("__constructor__", baseClass, avm1.DONT_ENUM);
+        const constr = classOf(proto, (self, given, version) => {
+            const state = newState(kind);
+            for (let i = 0; i < args.length && i < given.length; i++) {
+                args[i].set(state, given[i], version, make);
+            }
+            if (kind === "convolution") {
+                constructConvolution(state, given, version);
+            }
+            states.set(self, state);
+            return self;
+        });
+        for (const prop of props) {
+            const p = proto.add(prop.name, undefined, avm1.VERSION_8);
+            p.get = realm.method((self, _, version) => {
+                const state = states.get(self);
+                return state === undefined ? undefined : prop.get(state, version, make);
+            });
+            p.set = realm.method((self, values, version) => {
+                const state = states.get(self);
+                if (state !== undefined) {
+                    prop.set(state, values[0], version, make);
+                }
+                return undefined;
+            });
+        }
+        protos.set(kind, proto);
+        filters.define(NAMES[kind], constr, 0);
+    }
+    return {
+        objectOf(f) {
+            const o = new avm1.Avm1Object(protos.get(f.kind));
+            states.set(o, stateOf(f));
+            return o;
+        },
+    };
+}
+/** A state of a display object's record, as its `filters` reads it. */
+function stateOf(record) {
+    const f = copyFilter(record);
+    const state = { f, slots: null, map: null };
+    if (f.kind === "gradientGlow" || f.kind === "gradientBevel") {
+        const count = Math.min(f.colors.length, MAX_COLORS);
+        const fill = (values) => [
+            ...values.slice(0, count),
+            ...new Array(MAX_COLORS - count).fill(0),
+        ];
+        state.slots = {
+            count,
+            colors: fill(f.colors),
+            alphas: fill(f.alphas.map((a) => Math.round(a * 255))),
+            ratios: fill(f.ratios),
+        };
+    }
+    if (f.kind === "displacementMap") {
+        state.map = f.mapBitmap?.$store ?? null;
+        f.mapSnapshot = undefined;
+    }
+    return state;
+}
+function cloneState(s) {
+    const slots = s.slots;
+    return {
+        f: copyFilter(s.f),
+        slots: slots
+            ? {
+                count: slots.count,
+                colors: [...slots.colors],
+                alphas: [...slots.alphas],
+                ratios: [...slots.ratios],
+            }
+            : null,
+        map: s.map,
+    };
+}
+/**
+ * A display object's `filters` on its class's prototype, of `flags`: a new
+ * array of new filter objects each read; a list's filter objects set them.
+ */
+export function filtersProperty(realm, proto, flags, targetOf, faces) {
+    const p = proto.add("filters", undefined, flags);
+    p.get = realm.method((self, _, version) => {
+        const d = targetOf(self);
+        const made = faces();
+        return d === null || made === null
+            ? undefined
+            : realm.newArray(d.filters.map((f) => made.objectOf(f)), version);
+    });
+    p.set = realm.method((self, args, version) => {
+        const d = targetOf(self);
+        if (d !== null) {
+            setDisplayFilters(d, args[0], version);
+        }
+        return undefined;
+    });
+}
+/**
+ * A display object's `filters` set: the records of the filter objects in
+ * the array, anything else left out; a displacement map's pixels taken as
+ * they are now, as AS3's are.
+ */
+function setDisplayFilters(d, value, version) {
+    const list = filtersOf(value, version);
+    for (const f of list) {
+        const store = f.mapBitmap?.$store;
+        if (f.kind === "displacementMap" && store) {
+            f.mapSnapshot = { $store: store.clone() };
+        }
+    }
+    d.touch();
+    d.filters = list;
+    d.invalidate(TRANSFORM);
+}