@solidtv/renderer 1.1.0 → 1.1.2

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;

package/src/core/textures/ColorTexture.ts

@@ -70,7 +70,9 @@ export class ColorTexture extends Texture {
   }
 
   static override makeCacheKey(props: ColorTextureProps): string {
-    return `ColorTexture,${props.color}`;
+    // Mirror the default from resolveDefaults so the key is stable whether
+    // or not the caller has run defaults first.
+    return `ColorTexture,${props.color || 0xffffffff}`;
   }
 
   static override resolveDefaults(

package/src/core/textures/ImageTexture.ts

@@ -147,11 +147,22 @@ export class ImageTexture extends Texture {
       data: HTMLImageElement | null;
       premultiplyAlpha: boolean;
     }>((resolve, reject) => {
+      let objectUrl: string | null = null;
+
+      const cleanup = () => {
+        if (objectUrl !== null) {
+          URL.revokeObjectURL(objectUrl);
+          objectUrl = null;
+        }
+      };
+
       img.onload = () => {
+        cleanup();
         resolve({ data: img, premultiplyAlpha: hasAlpha });
       };
 
       img.onerror = (err) => {
+        cleanup();
         const errorMessage =
           err instanceof Error
             ? err.message
@@ -162,7 +173,8 @@ export class ImageTexture extends Texture {
       };
 
       if (src instanceof Blob) {
-        img.src = URL.createObjectURL(src);
+        objectUrl = URL.createObjectURL(src);
+        img.src = objectUrl;
       } else {
         img.src = src;
       }
@@ -218,10 +230,11 @@ export class ImageTexture extends Texture {
 
   async loadImage(src: string) {
     const { premultiplyAlpha, sx, sy, sw, sh } = this.props;
+    const isBase64 = isBase64Image(src);
 
     if (this.txManager.hasCreateImageBitmap === true) {
       if (
-        isBase64Image(src) === false &&
+        isBase64 === false &&
         this.txManager.hasWorker === true &&
         this.txManager.imageWorkerManager !== null
       ) {
@@ -235,15 +248,9 @@ export class ImageTexture extends Texture {
         );
       }
 
-      let blob;
-
-      if (isBase64Image(src) === true) {
-        blob = dataURIToBlob(src);
-      } else {
-        blob = await fetchJson(src, 'blob').then(
-          (response) => response as Blob,
-        );
-      }
+      const blob = isBase64
+        ? dataURIToBlob(src)
+        : ((await fetchJson(src, 'blob')) as Blob);
 
       return this.createImageBitmap(blob, premultiplyAlpha, sx, sy, sw, sh);
     }
@@ -357,16 +364,18 @@ export class ImageTexture extends Texture {
       return false;
     }
 
-    let cacheKey = `ImageTexture,${key},${props.premultiplyAlpha ?? 'true'},${
-      props.maxRetryCount
-    }`;
+    // Inline default values so the key is stable whether or not the caller
+    // has run them through resolveDefaults first. Must mirror the defaults
+    // in resolveDefaults below.
+    const premultiplyAlpha = props.premultiplyAlpha ?? true;
+    const maxRetryCount = props.maxRetryCount ?? 5;
+
+    let cacheKey = `ImageTexture,${key},${premultiplyAlpha},${maxRetryCount}`;
 
-    if (props.sh !== null && props.sw !== null) {
-      cacheKey += ',';
-      cacheKey += props.sx ?? '';
-      cacheKey += props.sy ?? '';
-      cacheKey += props.sw || '';
-      cacheKey += props.sh || '';
+    if (props.sh != null && props.sw != null) {
+      cacheKey += `,${props.sx ?? ''},${props.sy ?? ''},${props.sw || ''},${
+        props.sh || ''
+      }`;
     }
 
     return cacheKey;