@swf2es/player 0.0.0-stage → 0.1.1

package/dist/display/displayobject.js

@@ -0,0 +1,665 @@
+// The display object every kind extends: its place in its parent, its
+// transform, 2D and 3D, its look, and the flags and counts by which the
+// renderer, the pointer's pick and the frame's walks learn of its changes.
+import { IDENTITY, readFilters, } from "@swf2es/format";
+import { filterOfSwf } from "./filters.js";
+import { shifted } from "./geometry.js";
+import { compose3D, decompose3D, identity3D } from "./matrix3d.js";
+import { placedInPerspective } from "./perspective.js";
+/** Nothing changed since the renderer last looked, or what did. */
+export const CLEAN = 0;
+export const TRANSFORM = 1;
+export const CHILDREN = 2;
+export const CONTENT = 4;
+/** A Bitmap's pixels changed in place: the texture uploads again, nothing is rebuilt. */
+export const PIXELS = 8;
+/**
+ * A count that moves whenever something changes that a round of frame
+ * scripts (Scripting.runFrameScripts) reads to find a script to run: a
+ * clip's frame, frame scripts, makingChildren or timelineChild, a children
+ * list, a button's states, and, as Scripting and Lifecycle move it, an
+ * object made alive, a button's first scripts, the scripts' phase, the
+ * orphans and what scripts made. While it stands still, a round finds
+ * nothing the one before it left. One for every player: another's moving
+ * it costs a round, never a script.
+ */
+export const scriptWork = { changes: 0 };
+/**
+ * A count that moves whenever something changes that may change what is
+ * under a pointer that stands still: any change a renderer would sync
+ * (DisplayObject.invalidate), and the pick's own fields, mouseEnabled,
+ * mouseChildren, a hitArea, a button's enabled. While it stands still,
+ * the pointer has no need to pick again at a frame's end. One for every
+ * player: another's moving it costs a pick, never an event. `picks`
+ * counts the pointer's picks, which an object's pickChangedAt is told in.
+ */
+export const pickWork = { changes: 0, picks: 0 };
+/**
+ * How many times a SWF's content was let go of, a Loader's unloaded or
+ * replaced or a player destroyed: a renderer lets go then of what it kept
+ * of objects off the list for others to take, which holds their SWF's
+ * characters.
+ */
+export const unloads = { count: 0 };
+/** DisplayObject.kind's. */
+export const OTHER = 0;
+export const CLIP = 1;
+export const BUTTON = 2;
+const NO_FILTERS = Object.freeze([]);
+/** What a leaf has to walk: one for all, as the frame's walks visit every object once or more a frame. */
+export const NO_CHILDREN = Object.freeze([]);
+/** The blend modes by the number PlaceObject3 gives them: 0 and 1 are normal. */
+export const BLEND_MODES = [
+    "normal",
+    "normal",
+    "layer",
+    "multiply",
+    "screen",
+    "lighten",
+    "darken",
+    "difference",
+    "add",
+    "subtract",
+    "invert",
+    "alpha",
+    "erase",
+    "overlay",
+    "hardlight",
+];
+/** Display objects are numbered as they are made: Flash runs orphans' scripts newest first. */
+let made = 0;
+const DEGREES = 180 / Math.PI;
+/** A matrix column of scale `from` stretched to scale `to`; zeroed for a NaN, and null where there is no proportion to keep. */
+function scaled(to, from, x, y) {
+    if (Number.isNaN(to)) {
+        return [0, 0];
+    }
+    const f = to / from;
+    return Number.isFinite(f) ? [x * f, y * f] : null;
+}
+/** The sine and cosine of `degrees`, exact at the quarter turns, where Flash's matrix has 0s and 1s and not the doubles' rounding (`replaces`). */
+function sinCos(degrees) {
+    const quarters = degrees / 90;
+    if (Number.isInteger(quarters)) {
+        const k = ((quarters % 4) + 4) % 4;
+        return [[0, 1, 0, -1][k], [1, 0, -1, 0][k]];
+    }
+    const r = degrees / DEGREES;
+    return [Math.sin(r), Math.cos(r)];
+}
+/** Degrees into Flash's range, -180 to 180 with both ends kept as given; a NaN stays NaN. */
+export function normalizeDegrees(degrees) {
+    let d = degrees % 360;
+    if (d > 180) {
+        d -= 360;
+    }
+    else if (d < -180) {
+        d += 360;
+    }
+    return d;
+}
+/**
+ * The least a 3D scale goes to, as Flash's: a smaller one, 0 or NaN is
+ * this, so the matrix stays invertible and the scale can come back.
+ */
+export const LEAST_SCALE_3D = 1.175494351e-36;
+/**
+ * The records of a place's filters, read once for each list of them: an
+ * animated character's timeline places the same glowing children again on
+ * each frame, and each read the list anew. Shared by every object placed
+ * with the list, as nothing changes a record in place: a script reads
+ * copies and sets new ones.
+ */
+const placedLists = new WeakMap();
+function placedFilters(bytes) {
+    let filters = placedLists.get(bytes);
+    if (!filters) {
+        filters = readFilters(bytes).map(filterOfSwf);
+        placedLists.set(bytes, filters);
+    }
+    return filters;
+}
+export class DisplayObject {
+    serial = made++;
+    parent = null;
+    /** The timeline depth it was placed at, or null for one a script added. */
+    depth = null;
+    /** The frame of its parent's timeline that placed it, 1 the first; 0 for one a script added. */
+    placeFrame = 0;
+    /**
+     * The ratio its placements gave, 0 for none: a rewind keeps the child
+     * only where the frames replayed give it the same (gotoFrame).
+     */
+    ratio = 0;
+    name = "";
+    /** Whether its name is one the timeline gave it, which its parent has a property of; not a default instanceN. */
+    timelineNamed = false;
+    /**
+     * Its transform in its parent, translation in pixels: made from the
+     * scales, rotation and skew below, which are the object's own, as Flash
+     * keeps them apart from the matrix; set whole, it is taken apart into them.
+     */
+    matrix = { ...IDENTITY };
+    scaleX = 1;
+    scaleY = 1;
+    /** In degrees, -180 to 180, as Flash reports it. */
+    rotation = 0;
+    /** The second column's turn beyond the first's, in degrees: 0 but for a matrix that skews. */
+    skew = 0;
+    /**
+     * Whether the matrix is not the one the scales, rotation and skew make:
+     * the identity matrix3D set to null leaves, which a scale set then makes
+     * again from all of them, as Flash's does, not in proportion.
+     */
+    unmade = false;
+    colorTransform = null;
+    visible = true;
+    /**
+     * Where it has the keyboard's focus, how to drop it: Flash takes focus
+     * from an object taken off its parent or hidden (input/keyboard.ts).
+     */
+    focusDrop = null;
+    /** The character it was made from, or null. */
+    character = null;
+    /** Whether a script set a property of it; from then on the timeline swaps no shape under it, as Flash's does not. */
+    scripted = false;
+    /** Whether a script or a place set its cacheAsBitmap: Flash then draws it from a bitmap it keeps (`swap`). */
+    cachedAsBitmap = false;
+    /**
+     * Whether a script set its transform or another property a place gives:
+     * from then on the timeline's places, moves and a rewind's alike, leave
+     * its matrix, colour, ratio, visibility, blend mode and filters as they
+     * are, all of them whichever was set, as Flash's do (`scripted-moves`).
+     * Setting visible, mask or cacheAsBitmap is no such touch.
+     */
+    transformed = false;
+    /** Its other face, the AS3 object a script sees; null in an AVM1 movie. */
+    object = null;
+    /** A placed AMF3 value, consumed when the timeline constructs the object. */
+    metaData = null;
+    /** In an AVM1 movie, its AS2 face, a clip's, a button's or a text field's (avm1/avm1.ts); null otherwise. */
+    avm1 = null;
+    /** The root of an AVM1 movie an AS3 Loader loaded: its other face, an AVM1Movie, is no InteractiveObject. */
+    avm1Root = false;
+    /** Set on the main root, each loaded SWF's root and each loaded Bitmap; null below. */
+    loaderInfo = null;
+    /** What its Graphics drew, for a Shape or Sprite a script draws in; null until one does. */
+    drawing = null;
+    /** What changed since the renderer last synced it: TRANSFORM, CHILDREN, CONTENT. */
+    dirty = TRANSFORM | CONTENT;
+    /**
+     * Where anything under it may take the pointer, in its own space, as the
+     * pointer's pick last worked it out (input/pointer.ts), and whether a
+     * change under it since has made that stale: the renderer's flags are
+     * cleared as it syncs, these as the pick reads them. A move alone marks
+     * its ancestors, not it: its bounds in its own space stand.
+     */
+    pickBounds = null;
+    pickStale = true;
+    /** The scroll its pick bounds were worked out for: a scroll's change marks it only moved. */
+    pickScroll = null;
+    /**
+     * The pick (pickWork.picks) before which it or something under it last
+     * changed, or it was made: one that changes between every two picks is
+     * not worth its bounds, and the pick goes through it instead.
+     */
+    pickChangedAt = pickWork.picks;
+    /**
+     * The display objects whose frames its frames run: a container's own
+     * children array, a button's states (ButtonObject), none for the rest.
+     * A field every object has, so that the walks each frame, which visit
+     * every object, read it without asking its class.
+     */
+    frameChildren = NO_CHILDREN;
+    /** Whether it is a MovieClip (CLIP) or a ButtonObject (BUTTON), for those walks likewise: OTHER for the rest. */
+    kind = OTHER;
+    weakRef = null;
+    /**
+     * This object, weakly, as a store it shows or fills with holds it: the
+     * same each time, made as it is first asked for, which most never are,
+     * though timelines make thousands of objects a second.
+     */
+    get ref() {
+        this.weakRef ??= new WeakRef(this);
+        return this.weakRef;
+    }
+    /**
+     * The last depth this clips, as a timeline's mask, or 0: a mask is not
+     * drawn, and clips the children after it until one placed deeper.
+     */
+    clipDepth = 0;
+    /** The object `mask` set clips this one to; and the one it clips, for such a mask. */
+    mask = null;
+    maskOf = null;
+    /**
+     * scrollRect as set, its edges whole pixels, and as the last render took
+     * it, which the drawing, bounds and points go by: Flash's takes effect
+     * when it next draws.
+     */
+    scrollRect = null;
+    scrollTaken = null;
+    /** The scroll a 3D object has none of: Flash draws, bounds and hits all of it whatever its scrollRect. */
+    get scroll() {
+        return this.space ? null : this.scrollTaken;
+    }
+    set scroll(r) {
+        this.scrollTaken = r;
+    }
+    /**
+     * Its 9-slice grid, in its own space, in pixels (display/scale9.ts): its
+     * symbol's DefineScalingGrid's, or what a script set; null for none.
+     */
+    scale9Grid = null;
+    /** Its blend mode, as BlendMode names it. */
+    blendMode = "normal";
+    /**
+     * Its blend shader's kernel as it was when set, with its parameters and
+     * images then, which "shader" blends it with; kept through other modes.
+     */
+    blendShader = null;
+    /** Its filters' values, which its `filters` reads copies of. */
+    filters = NO_FILTERS;
+    /**
+     * Its 3D transform, from when a script first sets a 3D property, its
+     * matrix3D, or its 2D matrix to null, until it sets matrix3D to null: in
+     * place of the 2D matrix to a script, and drawn, bounded and hit in
+     * perspective (`placed`).
+     */
+    space = null;
+    /** The perspective projection a script set on its transform, or null. */
+    projection = null;
+    /** A store it shows or fills with changed its pixels, or was disposed. */
+    pixelsChanged(disposed) {
+        this.invalidate(disposed ? CONTENT : PIXELS);
+    }
+    /** Mark a change, and that its ancestors have a changed descendant. */
+    invalidate(what) {
+        this.dirty |= what;
+        pickWork.changes++;
+        for (let p = this.parent; p && !p.descendantsDirty; p = p.parent) {
+            p.descendantsDirty = true;
+        }
+        // Its own pick bounds stand when it only moves; its ancestors' do not.
+        this.pickChanged(what !== TRANSFORM);
+    }
+    /**
+     * Mark the pick bounds above it stale, and its own unless `own` is false
+     * (input/pointer.ts): an ancestor of one changed since the last pick is
+     * marked already.
+     */
+    pickChanged(own) {
+        const picks = pickWork.picks;
+        if (own) {
+            this.pickStale = true;
+            this.pickChangedAt = picks;
+        }
+        for (let p = this.parent; p && p.pickChangedAt !== picks; p = p.parent) {
+            p.pickStale = true;
+            p.pickChangedAt = picks;
+        }
+    }
+    /**
+     * Its matrix after its scroll's shift: from what it draws to its parent's
+     * space. A 3D object's is its plane in perspective (display/perspective.ts),
+     * kept until anything is invalidated, as an ancestor's move changes it.
+     */
+    get placed() {
+        if (this.space) {
+            return this.perspective();
+        }
+        return this.scroll ? shifted(this.matrix, this.scroll) : this.matrix;
+    }
+    perspective() {
+        return this.planes().placed;
+    }
+    /**
+     * A 3D object's planes (display/perspective.ts): in its parent's space,
+     * in its projector's, and the way back from the projector's to its
+     * parent's, kept as `placed` is.
+     */
+    planes() {
+        const space = this.space;
+        if (space.planeAt !== pickWork.changes || !space.planes) {
+            space.planes = placedInPerspective(this);
+            space.planeAt = pickWork.changes;
+        }
+        return space.planes;
+    }
+    /** Its 2D matrix after its scroll's shift, a 3D object's its matrix3D's x and y rows: what a mask draws by. */
+    get flatPlaced() {
+        return this.scroll ? shifted(this.matrix, this.scroll) : this.matrix;
+    }
+    /** Whether `o` is this or under it. */
+    encloses(o) {
+        for (let p = o; p; p = p.parent) {
+            if (p === this) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Clip this to `mask`'s fills, or to nothing for null. A mask clips one
+     * object: set on another it leaves the one before, as Flash's does.
+     */
+    setMask(mask) {
+        if (this.mask === mask) {
+            return;
+        }
+        if (this.mask) {
+            this.mask.maskOf = null;
+            this.mask.invalidate(TRANSFORM);
+        }
+        if (mask?.maskOf) {
+            mask.maskOf.mask = null;
+            mask.maskOf.invalidate(TRANSFORM);
+        }
+        this.mask = mask;
+        if (mask) {
+            mask.maskOf = this;
+            mask.invalidate(TRANSFORM);
+        }
+        this.invalidate(TRANSFORM);
+    }
+    setCachedAsBitmap(cached) {
+        this.cachedAsBitmap = cached;
+        this.invalidate(TRANSFORM);
+    }
+    /** A script set a property a place gives (`transformed`), which is also a touch (`scripted`). */
+    touch() {
+        this.scripted = true;
+        this.transformed = true;
+    }
+    /**
+     * The matrix set whole, and taken apart: the scales are its columns'
+     * lengths, the rotation the first column's angle, the skew the second's
+     * beyond that. A negative scale set as such is not recovered: a half
+     * turn is what the matrix says. It leaves 3D.
+     */
+    setMatrix(m) {
+        this.adoptMatrix({ ...m });
+    }
+    /** As setMatrix, with a matrix made for it, which it keeps: a place's, on each move of each frame. */
+    adoptMatrix(m) {
+        this.space = null;
+        this.unmade = false;
+        this.matrix = m;
+        this.scaleX = Math.hypot(m.a, m.b);
+        this.scaleY = Math.hypot(m.c, m.d);
+        this.rotation = Math.atan2(m.b, m.a) * DEGREES;
+        this.skew = normalizeDegrees(Math.atan2(-m.c, m.d) * DEGREES - this.rotation);
+        this.invalidate(TRANSFORM);
+    }
+    /**
+     * A scale set stretches its column of the matrix in proportion, so the
+     * other column stays exactly as it was, as Flash's does (the corpus's
+     * `displayobject_invalid_floats`); from a scale of 0 or NaN, where there
+     * is no proportion, the column is made anew from the angles. A NaN is
+     * reported back as set, as Flash reports it: a NaN scale zeroes its
+     * column, a NaN rotation leaves the matrix as it was and counts as none
+     * from then on.
+     */
+    setScaleX(v) {
+        if (this.space) {
+            this.set3D("scaleX", v);
+            return;
+        }
+        if (this.unmade) {
+            this.scaleX = v;
+            this.remake();
+            return;
+        }
+        const column = scaled(v, this.scaleX, this.matrix.a, this.matrix.b);
+        this.scaleX = v;
+        if (column) {
+            this.matrix = { ...this.matrix, a: column[0], b: column[1] };
+            this.invalidate(TRANSFORM);
+        }
+        else {
+            this.remake();
+        }
+    }
+    setScaleY(v) {
+        if (this.space) {
+            this.set3D("scaleY", v);
+            return;
+        }
+        if (this.unmade) {
+            this.scaleY = v;
+            this.remake();
+            return;
+        }
+        const column = scaled(v, this.scaleY, this.matrix.c, this.matrix.d);
+        this.scaleY = v;
+        if (column) {
+            this.matrix = { ...this.matrix, c: column[0], d: column[1] };
+            this.invalidate(TRANSFORM);
+        }
+        else {
+            this.remake();
+        }
+    }
+    setRotation(degrees) {
+        if (this.space) {
+            this.set3D("rotationZ", degrees);
+            return;
+        }
+        this.rotation = normalizeDegrees(degrees);
+        if (!Number.isNaN(degrees)) {
+            this.remake();
+        }
+    }
+    remake() {
+        this.unmade = false;
+        const [sinR, cosR] = sinCos(this.rotation || 0);
+        const [sinQ, cosQ] = sinCos((this.rotation || 0) + this.skew);
+        this.matrix = {
+            a: (this.scaleX || 0) * cosR,
+            b: (this.scaleX || 0) * sinR,
+            c: -(this.scaleY || 0) * sinQ,
+            d: (this.scaleY || 0) * cosQ,
+            tx: this.matrix.tx,
+            ty: this.matrix.ty,
+        };
+        this.invalidate(TRANSFORM);
+    }
+    /** Its 3D transform, made from the 2D matrix the first time, a -0 in it taken as 0. */
+    enter3D() {
+        if (!this.space) {
+            const m = this.matrix;
+            this.setMatrix3D(Float32Array.of(m.a, m.b, 0, 0, m.c, m.d, 0, 0, 0, 0, 1, 0, m.tx, m.ty, 0, 1).map((v) => v + 0), true);
+        }
+        return this.space;
+    }
+    /**
+     * One 3D property set, as Flash's: a position moves the matrix3D, as set
+     * whole or not; a scale or rotation makes it again from all of them, a
+     * rotation as set, not brought within ±180, a scale no nearer 0 than
+     * LEAST_SCALE_3D, and a float32 if the matrix was set whole since the
+     * last such set. A NaN position or rotation is 0. A scale or rotation
+     * set where the 2D matrix could not be taken apart makes it the
+     * identity, at the origin, and is lost, as in Flash.
+     */
+    set3D(key, v) {
+        const space = this.enter3D();
+        const at = ["x", "y", "z"].indexOf(key);
+        if (at >= 0) {
+            space[key] = Number.isNaN(v) ? 0 : v;
+            space.shown[12 + at] = space[key];
+            space.raw.set(space.shown);
+            this.flatten();
+            return;
+        }
+        if (space.singular) {
+            this.setMatrix3D(identity3D());
+            return;
+        }
+        if (!key.startsWith("scale")) {
+            space[key] = Number.isNaN(v) ? 0 : v;
+        }
+        else {
+            const kept = Math.abs(v) >= LEAST_SCALE_3D ? v : LEAST_SCALE_3D;
+            space[key] = space.composed ? kept : Math.fround(kept);
+        }
+        // In float32 radians, as adl's sines and cosines of them are, to the last bit.
+        const radians = [space.rotationX, space.rotationY, space.rotationZ].map((r) => Math.fround((r * Math.PI) / 180));
+        space.shown.set(compose3D([space.x, space.y, space.z], radians, [space.scaleX, space.scaleY, space.scaleZ], "eulerAngles"));
+        // In place: a Matrix3D a script holds of it shows the change (transform.matrix3D).
+        space.raw.set(space.shown);
+        space.composed = true;
+        this.flatten();
+    }
+    /**
+     * The matrix3D set whole, and taken apart into the properties as
+     * Matrix3D.decompose would; null back to 2D, at the identity, with the
+     * scales and rotation it had before it went 3D. Null in 2D changes
+     * nothing. One made from the 2D matrix (`flat`) with a column of no
+     * length reads as the identity at its position, as in Flash, where a
+     * matrix3D set so reads as NaN. The values go into the matrix it has,
+     * which a script's Matrix3D may share (transform.matrix3D), unless it
+     * `adopt`s `raw` itself, a Matrix3D's that a script set.
+     */
+    setMatrix3D(raw, flat = false, adopt = false) {
+        const before = this.space?.flat ?? [this.scaleX, this.scaleY, this.rotation, this.skew];
+        if (!raw) {
+            if (this.space) {
+                this.setMatrix(IDENTITY);
+                [this.scaleX, this.scaleY, this.rotation, this.skew] = before;
+                this.unmade = true;
+            }
+            return;
+        }
+        const kept = this.space?.raw;
+        const [[x, y, z], rotation, [scaleX, scaleY, scaleZ]] = decompose3D(raw, "eulerAngles");
+        const singular = flat && (scaleX === 0 || scaleY === 0);
+        const [rotationX, rotationY, rotationZ] = singular
+            ? [0, 0, 0]
+            : rotation.map((r) => r * DEGREES);
+        let held = raw;
+        if (!adopt && kept) {
+            kept.set(raw);
+            held = kept;
+        }
+        else if (!adopt) {
+            held = new Float32Array(raw);
+        }
+        this.space = {
+            x,
+            y,
+            z,
+            scaleX: singular ? 1 : scaleX,
+            scaleY: singular ? 1 : scaleY,
+            scaleZ: singular ? 1 : scaleZ,
+            rotationX,
+            rotationY,
+            rotationZ,
+            raw: held,
+            shown: new Float32Array(held),
+            singular,
+            composed: false,
+            flat: before,
+        };
+        this.flatten();
+    }
+    /**
+     * Its matrix, `raw`, changed in place through a Matrix3D a script holds of
+     * it, which Flash's getter hands out live: taken apart again, as adl reads
+     * the properties after; nothing if it is no longer its matrix.
+     */
+    matrix3DChanged(raw) {
+        if (this.space?.raw === raw) {
+            this.touch();
+            this.setMatrix3D(raw);
+        }
+    }
+    /** The 2D fields from the 3D transform: the matrix its x and y rows, which a mask draws by (`flatPlaced`). */
+    flatten() {
+        const space = this.space;
+        const m = space.shown;
+        this.matrix = { a: m[0], b: m[1], c: m[4], d: m[5], tx: m[12], ty: m[13] };
+        this.scaleX = space.scaleX;
+        this.scaleY = space.scaleY;
+        this.rotation = space.rotationZ;
+        this.skew = 0;
+        this.invalidate(TRANSFORM);
+    }
+    /** Apply a place's transform, colour, name and visibility; to one a script transformed, its name and clip depth only. */
+    applyPlace(place) {
+        if (place.name !== null) {
+            this.name = place.name;
+            this.timelineNamed = true;
+        }
+        if (this.transformed) {
+            if (place.clipDepth !== null) {
+                this.applyRare({ ...place, blendMode: null, filters: null });
+            }
+            return;
+        }
+        if (place.matrix) {
+            const m = place.matrix;
+            this.adoptMatrix({ a: m.a, b: m.b, c: m.c, d: m.d, tx: m.tx / 20, ty: m.ty / 20 });
+        }
+        if (place.colorTransform) {
+            this.colorTransform = place.colorTransform;
+            this.invalidate(TRANSFORM);
+        }
+        if (place.ratio !== null) {
+            this.ratio = place.ratio;
+        }
+        if (place.visible !== null) {
+            this.visible = place.visible;
+            this.invalidate(TRANSFORM);
+            if (!place.visible) {
+                this.focusDrop?.(this);
+            }
+        }
+        // Apart, and once tested: applyPlace runs for each move of each frame, and grown it is no longer inlined.
+        if (place.clipDepth !== null ||
+            place.blendMode !== null ||
+            place.filters !== null ||
+            place.cacheAsBitmap !== null) {
+            this.applyRare(place);
+        }
+    }
+    /** What a place sets that few do: a clip depth, a blend mode, filters, cacheAsBitmap. */
+    applyRare(place) {
+        if (place.cacheAsBitmap !== null) {
+            this.setCachedAsBitmap(place.cacheAsBitmap);
+        }
+        if (place.filters !== null) {
+            this.filters = placedFilters(place.filters);
+            this.invalidate(TRANSFORM);
+        }
+        if (place.clipDepth !== null && place.clipDepth !== this.clipDepth) {
+            this.clipDepth = place.clipDepth;
+            this.invalidate(TRANSFORM);
+            this.parent?.invalidate(CHILDREN);
+        }
+        if (place.blendMode !== null) {
+            this.setBlendMode(BLEND_MODES[place.blendMode] ?? "normal");
+        }
+    }
+    /** Its blend shader set: blended by it from now on, in the "shader" mode. */
+    setBlendShader(use) {
+        this.blendShader = use;
+        this.blendMode = "shader";
+        this.invalidate(TRANSFORM);
+    }
+    /** How it is composited with what is below it (BLEND_MODES). */
+    setBlendMode(mode) {
+        if (mode !== this.blendMode) {
+            this.blendMode = mode;
+            this.invalidate(TRANSFORM);
+        }
+    }
+}
+/** The root `d` is under, or is: the nearest display object up from it that carries a LoaderInfo; null under none, as for one a script made and did not add. */
+export function rootOf(d) {
+    for (let o = d; o; o = o.parent) {
+        if (o.loaderInfo) {
+            return o;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=displayobject.js.map