@solidtv/renderer 1.2.10 → 1.3.0

package/src/core/textures/ImageTexture.ts

@@ -192,6 +192,18 @@ export class ImageTexture extends Texture {
     const hasAlphaChannel = premultiplyAlpha ?? blob.type.includes('image/png');
     const imageBitmapSupported = this.txManager.imageBitmapSupported;
 
+    // When the device does NOT honor the createImageBitmap premultiply option
+    // (e.g. older Safari), request a straight ('none') bitmap and let WebGL
+    // premultiply on upload instead. `premultiplyAlpha` in the returned
+    // TextureData means "WebGL should premultiply this source on upload".
+    const useGlPremultiply =
+      hasAlphaChannel === true &&
+      imageBitmapSupported.premultiplyHonored === false;
+    const bitmapMode: 'premultiply' | 'none' =
+      hasAlphaChannel === true && useGlPremultiply === false
+        ? 'premultiply'
+        : 'none';
+
     if (imageBitmapSupported.full === true && sw !== null && sh !== null) {
       // createImageBitmap with crop
       const bitmap = await this.platform.createImageBitmap(
@@ -201,28 +213,29 @@ export class ImageTexture extends Texture {
         sw,
         sh,
         {
-          premultiplyAlpha: hasAlphaChannel ? 'premultiply' : 'none',
+          premultiplyAlpha: bitmapMode,
           colorSpaceConversion: 'none',
           imageOrientation: 'none',
         },
       );
-      return { data: bitmap, premultiplyAlpha: hasAlphaChannel };
+      return { data: bitmap, premultiplyAlpha: useGlPremultiply };
     } else if (imageBitmapSupported.basic === true) {
       // basic createImageBitmap without options or crop
-      // this is supported for Chrome v50 to v52/54 that doesn't support options
+      // this is supported for Chrome v50 to v52/54 that doesn't support options.
+      // The browser default premultiplies, so WebGL must not premultiply again.
       return {
         data: await this.platform.createImageBitmap(blob),
-        premultiplyAlpha: hasAlphaChannel,
+        premultiplyAlpha: false,
       };
     }
 
     // default createImageBitmap without crop but with options
     const bitmap = await this.platform.createImageBitmap(blob, {
-      premultiplyAlpha: hasAlphaChannel ? 'premultiply' : 'none',
+      premultiplyAlpha: bitmapMode,
       colorSpaceConversion: 'none',
       imageOrientation: 'none',
     });
-    return { data: bitmap, premultiplyAlpha: hasAlphaChannel };
+    return { data: bitmap, premultiplyAlpha: useGlPremultiply };
   }
 
   async loadImage(src: string) {
@@ -274,9 +287,14 @@ export class ImageTexture extends Texture {
       };
     }
 
+    // The loader computes whether WebGL should premultiply this source on
+    // upload (it depends on the source type and on whether createImageBitmap
+    // honored the premultiply option). Preserve it; fall back to the prop only
+    // when the loader didn't decide.
     return {
       data: resp.data,
-      premultiplyAlpha: this.props.premultiplyAlpha ?? true,
+      premultiplyAlpha:
+        resp.premultiplyAlpha ?? this.props.premultiplyAlpha ?? true,
     };
   }
 

package/src/main-api/Renderer.ts

@@ -458,6 +458,25 @@ export type RendererMainSettings = RendererRuntimeSettings & {
    */
   createImageBitmapSupport: 'auto' | 'basic' | 'options' | 'full';
 
+  /**
+   * Override for whether `createImageBitmap(..., { premultiplyAlpha: 'premultiply' })`
+   * is actually honored by the target device.
+   *
+   * @remarks
+   * Some older browsers (notably older Safari/WebKit) accept the
+   * `premultiplyAlpha: 'premultiply'` option without throwing but silently
+   * ignore it, returning straight (non-premultiplied) alpha. This causes edge
+   * "ghosting" on images with transparency.
+   *
+   * Set to `'auto'` to detect via a cheap startup probe (one 1×1 texture
+   * upload + framebuffer readback). Set to a boolean to force the value. Leave
+   * unset to assume the option is honored — the default, which preserves
+   * existing behavior with no probe overhead.
+   *
+   * @defaultValue `true` (assume honored; no probe)
+   */
+  premultiplyAlphaHonored?: boolean | 'auto';
+
   /**
    * Provide an alternative platform abstraction layer
    *
@@ -586,6 +605,12 @@ export class RendererMain extends EventEmitter {
       textureProcessingTimeLimit: settings.textureProcessingTimeLimit || 10,
       canvas: settings.canvas,
       createImageBitmapSupport: settings.createImageBitmapSupport || 'full',
+      // undefined -> true (assume honored, no probe); 'auto' -> probe;
+      // explicit boolean -> force the value.
+      premultiplyAlphaHonored:
+        settings.premultiplyAlphaHonored === undefined
+          ? true
+          : settings.premultiplyAlphaHonored,
       platform: settings.platform || null,
       maxRetryCount: settings.maxRetryCount ?? 5,
     };
@@ -646,6 +671,7 @@ export class RendererMain extends EventEmitter {
       targetFPS: settings.targetFPS!,
       textureProcessingTimeLimit: settings.textureProcessingTimeLimit!,
       createImageBitmapSupport: settings.createImageBitmapSupport!,
+      premultiplyAlphaHonored: settings.premultiplyAlphaHonored,
       platform,
       maxRetryCount: settings.maxRetryCount ?? 5,
     });