@solidtv/renderer 1.1.1 → 1.1.2

package/src/core/CoreNode.ts

@@ -811,6 +811,28 @@ export class CoreNode extends EventEmitter {
   public isRenderable = false;
   public renderState: CoreNodeRenderState = CoreNodeRenderState.Init;
   public isSimple = true;
+  /**
+   * `true` when `localTransform` is in identity-shape (ta=1, tb=0, tc=0, td=1)
+   * — i.e. a pure translation. Lets the simple-path `updateLocalTransform`
+   * skip redundant ta/tb/tc/td writes between frames. Defaults to `true`
+   * because the matrix is eagerly allocated as an identity in the constructor.
+   */
+  public _localIsTranslate = true;
+  /**
+   * Cached result of the texture `contain` resizeMode check used by
+   * `updateLocalTransform` and `updateIsSimple`. Updated whenever the
+   * texture or textureOptions change (via `updateIsSimple`), so the hot
+   * paths can avoid the optional-chain + string compare on every frame.
+   */
+  public _hasContainResize = false;
+  /**
+   * `true` when `globalTransform` is in identity-shape (ta=1, tb=0, tc=0, td=1).
+   * Propagates from parent: a node's global is translate-only iff the parent's
+   * global is translate-only AND the node itself is `isSimple`. Default `true`
+   * because freshly-constructed nodes have no transform applied yet, and the
+   * Stage root is configured with an identity-shape global.
+   */
+  public _globalIsTranslate = true;
 
   public worldAlpha = 1;
   public premultipliedColorTl = 0;
@@ -835,6 +857,13 @@ export class CoreNode extends EventEmitter {
   constructor(readonly stage: Stage, props: CoreNodeProps) {
     super();
 
+    // Eagerly allocate the local/global transform matrices as identity.
+    // This keeps the field's hidden class monomorphic (Matrix3d, not
+    // Matrix3d|undefined) from construction onward and lets the simple
+    // / translate-only fast paths take effect on the very first update.
+    this.localTransform = Matrix3d.identity();
+    this.globalTransform = Matrix3d.identity();
+
     //inital update type
     let initialUpdateType =
       UpdateType.Local | UpdateType.RenderBounds | UpdateType.RenderState;
@@ -1089,7 +1118,18 @@ export class CoreNode extends EventEmitter {
     const { x, y } = p;
 
     if (this.isSimple) {
+      // Fast path: when localTransform is already in identity-shape
+      // (ta=1, tb=0, tc=0, td=1), only tx/ty change between frames, so we
+      // skip the 4 redundant field writes Matrix3d.translate would do.
+      // _localIsTranslate becomes stale when a node was non-simple (had
+      // rotation/scale/mount) on a previous frame — in that case do a
+      // full reset to identity-translate.
+      if (this._localIsTranslate === true) {
+        this.localTransform!.setTranslate(x, y);
+        return;
+      }
       this.localTransform = Matrix3d.translate(x, y, this.localTransform);
+      this._localIsTranslate = true;
       return;
     }
 
@@ -1097,10 +1137,15 @@ export class CoreNode extends EventEmitter {
     const mountTranslateX = p.mountX * w;
     const mountTranslateY = p.mountY * h;
 
-    if (p.rotation !== 0 || p.scaleX !== 1 || p.scaleY !== 1) {
-      const scaleRotate = Matrix3d.rotate(p.rotation, Matrix3d.temp).scale(
-        p.scaleX,
-        p.scaleY,
+    const rotation = p.rotation;
+    const scaleX = p.scaleX;
+    const scaleY = p.scaleY;
+
+    if (rotation !== 0) {
+      // Full rotation (+ optional scale + pivot)
+      const scaleRotate = Matrix3d.rotate(rotation, Matrix3d.temp).scale(
+        scaleX,
+        scaleY,
       );
       const pivotTranslateX = p.pivotX * w;
       const pivotTranslateY = p.pivotY * h;
@@ -1112,7 +1157,21 @@ export class CoreNode extends EventEmitter {
       )
         .multiply(scaleRotate)
         .translate(-pivotTranslateX, -pivotTranslateY);
+    } else if (scaleX !== 1 || scaleY !== 1) {
+      // Scale (+ optional pivot) without rotation — skip the rotate matrix
+      // and the 8-mul multiply; `.scale()` is a 4-mul in-place op.
+      const pivotTranslateX = p.pivotX * w;
+      const pivotTranslateY = p.pivotY * h;
+
+      this.localTransform = Matrix3d.translate(
+        x - mountTranslateX + pivotTranslateX,
+        y - mountTranslateY + pivotTranslateY,
+        this.localTransform,
+      )
+        .scale(scaleX, scaleY)
+        .translate(-pivotTranslateX, -pivotTranslateY);
     } else {
+      // Mount (or texture-contain) only — pure translation.
       this.localTransform = Matrix3d.translate(
         x - mountTranslateX,
         y - mountTranslateY,
@@ -1120,12 +1179,13 @@ export class CoreNode extends EventEmitter {
       );
     }
 
-    // Handle 'contain' resize mode
+    // Handle 'contain' resize mode (cached check; dimensions still need
+    // a runtime null-check because they're populated asynchronously).
     const texture = p.texture;
     if (
-      texture &&
-      texture.dimensions &&
-      p.textureOptions.resizeMode?.type === 'contain'
+      this._hasContainResize === true &&
+      texture !== null &&
+      texture.dimensions !== null
     ) {
       let resizeModeScaleX = 1;
       let resizeModeScaleY = 1;
@@ -1157,17 +1217,23 @@ export class CoreNode extends EventEmitter {
         .translate(extraX, extraY)
         .scale(resizeModeScaleX, resizeModeScaleY);
     }
+
+    this._localIsTranslate = false;
   }
 
   updateIsSimple() {
     const p = this.props;
+    // Cache the texture-contain check so updateLocalTransform doesn't have to
+    // run the optional-chain + string compare on every Local update.
+    this._hasContainResize =
+      p.texture !== null && p.textureOptions?.resizeMode?.type === 'contain';
     this.isSimple =
       p.rotation === 0 &&
       p.scaleX === 1 &&
       p.scaleY === 1 &&
       p.mountX === 0 &&
       p.mountY === 0 &&
-      !(p.texture && p.textureOptions.resizeMode?.type === 'contain');
+      this._hasContainResize === false;
   }
 
   /**
@@ -1209,6 +1275,10 @@ export class CoreNode extends EventEmitter {
     }
 
     if (updateType & UpdateType.Global) {
+      const lt = this.localTransform!;
+      const gt = this.globalTransform!;
+      let fastPathApplied = false;
+
       if (
         USE_RTT &&
         this.parentHasRenderTexture === true &&
@@ -1216,7 +1286,7 @@ export class CoreNode extends EventEmitter {
       ) {
         // we are at the start of the RTT chain, so we need to reset the globalTransform
         // for correct RTT rendering
-        this.globalTransform = Matrix3d.identity(this.globalTransform);
+        Matrix3d.identity(gt);
 
         // Maintain a full scene global transform for bounds detection
         const parentTransform =
@@ -1225,7 +1295,10 @@ export class CoreNode extends EventEmitter {
         this.sceneGlobalTransform = Matrix3d.copy(
           parentTransform,
           this.sceneGlobalTransform,
-        ).translateOrMultiply(this.localTransform!);
+        ).translateOrMultiply(lt);
+
+        // identity * local => translate-only iff this node is simple
+        this._globalIsTranslate = this.isSimple;
       } else if (
         USE_RTT &&
         this.parentHasRenderTexture === true &&
@@ -1234,32 +1307,48 @@ export class CoreNode extends EventEmitter {
         // we're part of an RTT chain but our parent is not the main RTT node
         // so we need to propogate the sceneGlobalTransform of the parent
         // to maintain a full scene global transform for bounds detection
-        const parentSceneTransform =
-          parent.sceneGlobalTransform || this.localTransform!;
+        const parentSceneTransform = parent.sceneGlobalTransform || lt;
 
         this.sceneGlobalTransform = Matrix3d.copy(
           parentSceneTransform,
           this.sceneGlobalTransform,
-        ).translateOrMultiply(this.localTransform!);
+        ).translateOrMultiply(lt);
 
-        this.globalTransform = Matrix3d.copy(
-          parent.globalTransform || this.localTransform!,
-          this.globalTransform,
-        );
+        Matrix3d.copy(parent.globalTransform!, gt);
+
+        // Conservative: RTT chains rarely hit the translate fast path
+        this._globalIsTranslate = false;
       } else {
-        this.globalTransform = Matrix3d.copy(
-          parent.globalTransform || this.localTransform!,
-          this.globalTransform,
-        );
+        // Common non-RTT path
+        const parentGT = parent.globalTransform!;
+        if (this.isSimple === true && parent._globalIsTranslate === true) {
+          // Translate-only fast path: parent global and local are both pure
+          // translations, so the resulting global is also a pure translation
+          // and collapses to 2 adds on tx/ty.
+          if (this._globalIsTranslate === false) {
+            // Transitioning back into translate-only — reset ta/tb/tc/td
+            // that may have been left non-identity by a prior frame.
+            gt.ta = 1;
+            gt.tb = 0;
+            gt.tc = 0;
+            gt.td = 1;
+          }
+          gt.setTranslate(parentGT.tx + lt.tx, parentGT.ty + lt.ty);
+          this._globalIsTranslate = true;
+          fastPathApplied = true;
+        } else {
+          Matrix3d.copy(parentGT, gt);
+          this._globalIsTranslate =
+            this.isSimple === true && parent._globalIsTranslate === true;
+        }
       }
 
-      if (this.isSimple) {
-        this.globalTransform.translate(
-          this.localTransform!.tx,
-          this.localTransform!.ty,
-        );
-      } else {
-        this.globalTransform.translateOrMultiply(this.localTransform!);
+      if (fastPathApplied === false) {
+        if (this.isSimple) {
+          gt.translate(lt.tx, lt.ty);
+        } else {
+          gt.translateOrMultiply(lt);
+        }
       }
       this.calculateRenderCoords();
       this.updateBoundingRect();
@@ -1380,18 +1469,30 @@ export class CoreNode extends EventEmitter {
         childClippingRect = NO_CLIPPING_RECT;
       }
 
-      for (let i = 0, length = this.children.length; i < length; i++) {
-        const child = this.children[i] as CoreNode;
-
-        if (childUpdateType !== 0) {
+      const children = this.children;
+      const length = children.length;
+      if (childUpdateType !== 0) {
+        // Specialized loop: OR-in the inherited update bits for every child,
+        // then update if non-zero. Avoids the per-iter `childUpdateType !== 0`
+        // compare.
+        for (let i = 0; i < length; i++) {
+          const child = children[i] as CoreNode;
           child.updateType |= childUpdateType;
+          if (child.updateType === 0) {
+            continue;
+          }
+          child.update(delta, childClippingRect);
         }
-
-        if (child.updateType === 0) {
-          continue;
+      } else {
+        // Specialized loop: nothing to inherit, so only walk children that
+        // already have pending work of their own.
+        for (let i = 0; i < length; i++) {
+          const child = children[i] as CoreNode;
+          if (child.updateType === 0) {
+            continue;
+          }
+          child.update(delta, childClippingRect);
         }
-
-        child.update(delta, childClippingRect);
       }
     }
 
@@ -1503,7 +1604,7 @@ export class CoreNode extends EventEmitter {
     const renderCoords = (this.sceneRenderCoords ||
       this.renderCoords) as RenderCoords;
 
-    if (transform.tb === 0 || transform.tc === 0) {
+    if (transform.tb === 0 && transform.tc === 0) {
       this.renderBound = createBound(
         renderCoords.x1,
         renderCoords.y1,

package/src/core/Stage.ts

@@ -359,9 +359,10 @@ export class Stage {
 
     this.root = rootNode;
 
-    // Initialize root node properties
+    // Initialize root node properties. Copy in place into the eagerly-allocated
+    // matrices so the hidden class for these fields stays stable.
     rootNode.updateLocalTransform();
-    rootNode.globalTransform = Matrix3d.copy(rootNode.localTransform!);
+    Matrix3d.copy(rootNode.localTransform!, rootNode.globalTransform);
     rootNode.sceneGlobalTransform = Matrix3d.copy(rootNode.localTransform!);
     rootNode.calculateRenderCoords();
     rootNode.updateBoundingRect();

package/src/core/lib/Matrix3d.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+import { Matrix3d } from './Matrix3d.js';
+
+describe('Matrix3d.setTranslate', () => {
+  it('writes tx/ty without touching ta/tb/tc/td', () => {
+    const m = Matrix3d.identity();
+    m.setTranslate(10, 20);
+    expect(m.tx).toBe(10);
+    expect(m.ty).toBe(20);
+    expect(m.ta).toBe(1);
+    expect(m.tb).toBe(0);
+    expect(m.tc).toBe(0);
+    expect(m.td).toBe(1);
+  });
+
+  it('updates the float array on subsequent getFloatArr() calls', () => {
+    const m = Matrix3d.identity();
+    m.setTranslate(5, 7);
+    // First read populates the array
+    const arr = m.getFloatArr();
+    expect(arr[6]).toBe(5);
+    expect(arr[7]).toBe(7);
+
+    // Mutate, then expect getFloatArr() to pick up the change.
+    m.setTranslate(9, 11);
+    const arr2 = m.getFloatArr();
+    expect(arr2[6]).toBe(9);
+    expect(arr2[7]).toBe(11);
+    // Same array reference reused (no GC pressure).
+    expect(arr2).toBe(arr);
+  });
+
+  it('overwrites prior tx/ty values', () => {
+    const m = Matrix3d.translate(100, 200);
+    m.setTranslate(0, 0);
+    expect(m.tx).toBe(0);
+    expect(m.ty).toBe(0);
+  });
+});
+
+describe('Matrix3d.rotate(0) fast path', () => {
+  it('produces an identity matrix for angle=0', () => {
+    const m = Matrix3d.rotate(0);
+    expect(m.ta).toBe(1);
+    expect(m.tb).toBe(0);
+    expect(m.tc).toBe(0);
+    expect(m.td).toBe(1);
+    expect(m.tx).toBe(0);
+    expect(m.ty).toBe(0);
+  });
+
+  it('resets a pre-populated out matrix to identity on angle=0', () => {
+    const m = Matrix3d.rotate(Math.PI / 4);
+    // Now reuse `m` with angle=0; should overwrite to identity.
+    Matrix3d.rotate(0, m);
+    expect(m.ta).toBe(1);
+    expect(m.tb).toBe(0);
+    expect(m.tc).toBe(0);
+    expect(m.td).toBe(1);
+    expect(m.tx).toBe(0);
+    expect(m.ty).toBe(0);
+  });
+
+  it('still produces a real rotation when angle != 0', () => {
+    const m = Matrix3d.rotate(Math.PI / 2);
+    // cos(pi/2) ~ 0, sin(pi/2) = 1
+    expect(Math.abs(m.ta)).toBeLessThan(1e-10);
+    expect(m.tb).toBeCloseTo(-1, 10);
+    expect(m.tc).toBeCloseTo(1, 10);
+    expect(Math.abs(m.td)).toBeLessThan(1e-10);
+  });
+});

package/src/core/lib/Matrix3d.ts

@@ -124,11 +124,24 @@ export class Matrix3d {
   }
 
   public static rotate(angle: number, out?: Matrix3d): Matrix3d {
-    const cos = Math.cos(angle);
-    const sin = Math.sin(angle);
-    if (!out) {
+    if (out === undefined) {
       out = new Matrix3d();
     }
+    if (angle === 0) {
+      // Skip Math.cos(0) / Math.sin(0) — neither V8 nor JSC constant-folds
+      // these calls. Identity rotation is the common case when callers
+      // combine rotate().scale() and only the scale is non-default.
+      out.ta = 1;
+      out.tb = 0;
+      out.tx = 0;
+      out.tc = 0;
+      out.td = 1;
+      out.ty = 0;
+      out.mutation = true;
+      return out;
+    }
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
     out.ta = cos;
     out.tb = -sin;
     out.tx = 0;
@@ -160,6 +173,20 @@ export class Matrix3d {
     return this;
   }
 
+  /**
+   * Writes `tx`/`ty` directly and marks the matrix mutated.
+   *
+   * Caller is responsible for ensuring `ta`/`tb`/`tc`/`td` are already the
+   * desired values — typically the identity rotation/scale (1, 0, 0, 1).
+   * Used by hot paths that know the matrix is in identity-shape so the
+   * 4 redundant field writes performed by `Matrix3d.translate` can be skipped.
+   */
+  public setTranslate(x: number, y: number): void {
+    this.tx = x;
+    this.ty = y;
+    this.mutation = true;
+  }
+
   public scale(sx: number, sy: number): Matrix3d {
     this.ta = this.ta * sx;
     this.tb = this.tb * sy;