@swf2es/player 0.0.0-stage → 0.1.0

package/src/playerglobal/flash/display/DisplayObject.ts

@@ -0,0 +1,787 @@
+// flash.display.DisplayObject: allocated with a player display object as its
+// other face, and its properties read and written through it.
+import type { Matrix } from "@swf2es/format";
+import { avm2 } from "@swf2es/runtime";
+import {
+  bounds,
+  boundsIn,
+  hitsObject,
+  hitsPoint,
+  placedRect,
+  toStage,
+} from "../../../display/bounds.js";
+import {
+  ButtonObject,
+  CONTENT,
+  type DisplayObject,
+  MovieClip,
+  rootOf,
+  scriptWork,
+  TextObject,
+  TRANSFORM,
+} from "../../../display/display.js";
+import { copyFilter } from "../../../display/filters.js";
+import { apply, invert, isProjective, type Rect } from "../../../display/geometry.js";
+import { stagePoint3D } from "../../../display/perspective.js";
+import { gridInside, sliceBounds } from "../../../display/scale9.js";
+import type { Scripting } from "../../../scripting.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";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+const MATRIX_NAME = avm2.qname(avm2.publicNs, "matrix");
+const COLOR_NAME = avm2.qname(avm2.publicNs, "colorTransform");
+const name = (n: string) => 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: number): number {
+  const r = Math.round(v);
+  return r - v === 0.5 && r % 2 !== 0 ? r - 1 : r;
+}
+
+function point(s: Scripting, x: number, y: number): Value {
+  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: Scripting, d: DisplayObject, p: Value): [number, number] {
+  const x = Number(s.rt.getProperty(p as AsObject, name("x")));
+  const y = Number(s.rt.getProperty(p as AsObject, 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: number) => 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: DisplayObject): [number, number] {
+  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: Scripting, r: Rect): Value {
+  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: DisplayObject): [number, number] {
+  if (!(d instanceof TextObject)) {
+    return [0, 0];
+  }
+
+  const twips = (v: number) => 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: number): number {
+  const twips = Math.trunc((v || 0) * 20);
+  return (twips >= -0x80000000 && twips <= 0x7fffffff ? twips : -0x80000000) / 20;
+}
+
+function withOffset(at: number, offset: number): number {
+  return offset === 0 ? at : (at * 20 + offset) / 20;
+}
+
+/** The display object `o` is the face of. */
+export function displayOf(o: avm2.AsObject): DisplayObject {
+  return o.$display;
+}
+
+export function displayObjectHooks(s: Scripting): Record<string, avm2.ClassHook> {
+  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: { name: string; base: unknown }): boolean {
+  for (let t = traits as typeof traits | null; t; t = t.base as typeof traits | null) {
+    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: DisplayObject, change: (m: Matrix) => void): void {
+  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: Scripting, d: DisplayObject): boolean {
+  for (let o: DisplayObject | null = d; o; o = o.parent) {
+    if (o === s.stage) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export function displayObjectNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.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 {
+    declare $display: DisplayObject;
+    declare $transform: AsObject | undefined;
+    declare $cacheAsBitmapMatrix: Value;
+    declare $metaData: Value;
+    declare $opaqueBackground: Value;
+    declare $accessibilityProperties: Value;
+
+    get name(): string {
+      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: Value) {
+      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 as string;
+    }
+
+    get visible(): boolean {
+      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: Value) {
+      this.$display.visible = !!v;
+      this.$display.invalidate(TRANSFORM);
+      if (!v) {
+        this.$display.focusDrop?.(this.$display);
+      }
+    }
+
+    get x(): number {
+      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: Value) {
+      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(): number {
+      return withOffset(this.$display.matrix.ty, fieldOffset(this.$display)[1]);
+    }
+
+    set y(v: Value) {
+      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(): number {
+      return this.$display.scaleX;
+    }
+
+    set scaleX(v: Value) {
+      this.$display.touch();
+      this.$display.setScaleX(Number(v));
+    }
+
+    get scaleY(): number {
+      return this.$display.scaleY;
+    }
+
+    set scaleY(v: Value) {
+      this.$display.touch();
+      this.$display.setScaleY(Number(v));
+    }
+
+    get rotation(): number {
+      return this.$display.rotation;
+    }
+
+    set rotation(v: Value) {
+      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(): number {
+      return this.$display.space?.z ?? 0;
+    }
+
+    set z(v: Value) {
+      this.$display.touch();
+      this.$display.set3D("z", Number(v));
+    }
+
+    get rotationX(): number {
+      return this.$display.space?.rotationX ?? 0;
+    }
+
+    set rotationX(v: Value) {
+      this.$display.touch();
+      this.$display.set3D("rotationX", Number(v));
+    }
+
+    get rotationY(): number {
+      return this.$display.space?.rotationY ?? 0;
+    }
+
+    set rotationY(v: Value) {
+      this.$display.touch();
+      this.$display.set3D("rotationY", Number(v));
+    }
+
+    // 0 in 2D, whatever the rotation, as Flash reads it.
+    get rotationZ(): number {
+      return this.$display.space ? this.$display.rotation : 0;
+    }
+
+    set rotationZ(v: Value) {
+      this.$display.touch();
+      this.$display.set3D("rotationZ", Number(v));
+    }
+
+    get scaleZ(): number {
+      return this.$display.space?.scaleZ ?? 1;
+    }
+
+    set scaleZ(v: Value) {
+      this.$display.touch();
+      this.$display.set3D("scaleZ", Number(v));
+    }
+
+    get alpha(): number {
+      return this.$display.colorTransform?.aMul ?? 1;
+    }
+
+    set alpha(v: Value) {
+      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(): Value {
+      const parent = this.$display.parent;
+      return parent instanceof ButtonObject ? null : (parent?.object ?? null);
+    }
+
+    get stage(): Value {
+      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(): Value {
+      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(): Value {
+      if (this.$display === s.stage) {
+        return s.root?.loaderInfo ?? null;
+      }
+
+      return rootOf(this.$display)?.loaderInfo ?? null;
+    }
+
+    get mouseX(): number {
+      const m = invert(toStage(this.$display, s.stage));
+      return m ? apply(m, s.mouseStageX, s.mouseStageY)[0] : 0;
+    }
+
+    get mouseY(): number {
+      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(): number {
+      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: Value) {
+      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(): number {
+      return size(this.$display)[1];
+    }
+
+    set height(v: Value) {
+      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: Value): Value {
+      return rectangle(
+        s,
+        boundsIn(this.$display, (target as AsObject | null)?.$display ?? null, s.stage, true),
+      );
+    }
+
+    getRect(target: Value): Value {
+      return rectangle(
+        s,
+        boundsIn(this.$display, (target as AsObject | null)?.$display ?? null, s.stage, false),
+      );
+    }
+
+    /** hitTestPoint(x, y, shapeFlag) asks with `point`; hitTestObject(other) without. */
+    "flash.display:DisplayObject::_hitTest"(
+      point: Value,
+      x: Value,
+      y: Value,
+      shape: Value,
+      other: Value,
+    ): boolean {
+      if (point) {
+        return hitsPoint(this.$display, Number(x), Number(y), !!shape, s.root);
+      }
+
+      const o = (other as AsObject | null)?.$display;
+      return o ? hitsObject(this.$display, o, s.stage) : false;
+    }
+
+    get blendMode(): string {
+      return this.$display.blendMode;
+    }
+
+    set blendMode(v: Value) {
+      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: Value) {
+      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(): boolean {
+      return this.$display.cachedAsBitmap || this.$display.filters.length > 0;
+    }
+
+    set cacheAsBitmap(v: Value) {
+      this.$display.setCachedAsBitmap(!!v);
+    }
+
+    get cacheAsBitmapMatrix(): Value {
+      return this.$cacheAsBitmapMatrix ?? null;
+    }
+
+    set cacheAsBitmapMatrix(v: Value) {
+      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(): Value {
+      return s.rt.array(
+        this.$display.filters.map((f) => {
+          const o = s.rt.construct(s.rt.classNamed(filterClassName(f.kind))) as AsObject;
+          o.$filter = copyFilter(f);
+          return o;
+        }),
+      );
+    }
+
+    // A list refused, #2005, leaves the object untouched (`scripted-moves`).
+    set filters(v: Value) {
+      const list = v ? (((v as AsObject).$a as Value[] | undefined) ?? []) : [];
+      const filters = list.map((item) => {
+        const kind = item && typeof item === "object" ? filterKindOf(s.rt, item as AsObject) : null;
+        if (!kind) {
+          throw s.rt.error("ArgumentError", 2005, 0, "Filter");
+        }
+
+        const f = copyFilter(recordOf(item as AsObject, 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(): Value {
+      return this.$display.mask?.object ?? null;
+    }
+
+    set mask(v: Value) {
+      const mask = (v as AsObject | null)?.$display ?? null;
+      this.$display.setMask(mask);
+    }
+
+    get metaData(): Value {
+      return this.$metaData ?? null;
+    }
+
+    set metaData(v: Value) {
+      this.$metaData = v;
+    }
+
+    get opaqueBackground(): Value {
+      return this.$opaqueBackground ?? null;
+    }
+
+    set opaqueBackground(v: Value) {
+      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(): Value {
+      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: Value) {
+      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 as AsObject, 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(): Value {
+      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: Value) {
+      this.$display.touch();
+      let r: Rect | null = null;
+      if (v) {
+        const [x, y, w, h] = ["x", "y", "width", "height"].map((k) =>
+          Number(s.rt.getProperty(v as AsObject, 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(): Value {
+      return this.$accessibilityProperties ?? null;
+    }
+
+    set accessibilityProperties(v: Value) {
+      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: Value): Value {
+      const m = toStage(this.$display, s.stage);
+      const x = Number(s.rt.getProperty(p as AsObject, name("x")));
+      const y = Number(s.rt.getProperty(p as AsObject, 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: Value): Value {
+      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: Value): Value {
+      const get = (key: string) => Number(s.rt.getProperty(v as AsObject, 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: Value): Value {
+      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(): Value {
+      if (!this.$transform) {
+        this.$transform = s.rt.construct(
+          s.rt.classNamed("flash.geom::Transform"),
+          this,
+        ) as AsObject;
+      }
+
+      return this.$transform;
+    }
+
+    /** Takes the given Transform's matrix, 2D or 3D, and color transform, not the object. */
+    set transform(v: Value) {
+      if (v) {
+        const t = v as AsObject;
+        const from: DisplayObject = t.$display;
+        if (from.space) {
+          this.$display.setMatrix3D(from.space.shown);
+        } else {
+          this.$display.setMatrix(matrixOf(s, s.rt.getProperty(t, MATRIX_NAME) as AsObject));
+        }
+
+        this.$display.colorTransform = colorOf(s, s.rt.getProperty(t, COLOR_NAME) as AsObject);
+        this.$display.touch();
+        this.$display.invalidate(TRANSFORM);
+      }
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.display::DisplayObject", DisplayObjectNatives);
+  return natives;
+}