jassub 2.0.12 → 2.0.15

package/src/worker/webgpu-renderer.ts

@@ -177,123 +177,122 @@ export class WebGPURenderer {
 
   // eslint-disable-next-line no-undef
   format: GPUTextureFormat = 'bgra8unorm'
-  readonly initPromise: Promise<void> | null = null
+  _ready
 
   constructor () {
     // Start async initialization immediately
-    this.initPromise = this._initDevice()
-  }
-
-  async _initDevice (): Promise<void> {
+    this._ready = (async () => {
     // Check WebGPU support
-    if (!navigator.gpu) {
-      throw new Error('WebGPU not supported')
-    }
+      if (!navigator.gpu) {
+        throw new Error('WebGPU not supported')
+      }
 
-    const adapter = await navigator.gpu.requestAdapter({
-      powerPreference: 'high-performance'
-    })
+      const adapter = await navigator.gpu.requestAdapter({
+        powerPreference: 'high-performance'
+      })
 
-    if (!adapter) {
-      throw new Error('No WebGPU adapter found')
-    }
+      if (!adapter) {
+        throw new Error('No WebGPU adapter found')
+      }
 
-    this.device = await adapter.requestDevice()
-    this.format = navigator.gpu.getPreferredCanvasFormat()
+      this.device = await adapter.requestDevice()
+      this.format = navigator.gpu.getPreferredCanvasFormat()
 
-    // Create shader modules
-    const vertexModule = this.device.createShaderModule({
-      code: VERTEX_SHADER
-    })
+      // Create shader modules
+      const vertexModule = this.device.createShaderModule({
+        code: VERTEX_SHADER
+      })
 
-    const fragmentModule = this.device.createShaderModule({
-      code: FRAGMENT_SHADER
-    })
+      const fragmentModule = this.device.createShaderModule({
+        code: FRAGMENT_SHADER
+      })
 
-    // Create uniform buffer
-    this.uniformBuffer = this.device.createBuffer({
-      size: 16, // vec2f resolution + padding
-      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
-    })
+      // Create uniform buffer
+      this.uniformBuffer = this.device.createBuffer({
+        size: 16, // vec2f resolution + padding
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+      })
 
-    // Create color matrix buffer (mat3x3f requires 48 bytes: 3 vec3f padded to vec4f each)
-    this.colorMatrixBuffer = this.device.createBuffer({
-      size: 48, // 3 x vec4f (each column is vec3f padded to 16 bytes)
-      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
-    })
-    // Initialize with identity matrix
-    this.setColorMatrix()
+      // Create color matrix buffer (mat3x3f requires 48 bytes: 3 vec3f padded to vec4f each)
+      this.colorMatrixBuffer = this.device.createBuffer({
+        size: 48, // 3 x vec4f (each column is vec3f padded to 16 bytes)
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+      })
+      // Initialize with identity matrix
+      this.device.queue.writeBuffer(this.colorMatrixBuffer, 0, IDENTITY_MATRIX)
 
-    // Create bind group layout (no sampler needed - using textureLoad for pixel-perfect sampling)
-    this.bindGroupLayout = this.device.createBindGroupLayout({
-      entries: [
-        {
-          binding: 0,
-          visibility: GPUShaderStage.VERTEX,
-          buffer: { type: 'uniform' }
-        },
-        {
-          binding: 1,
-          visibility: GPUShaderStage.VERTEX,
-          buffer: { type: 'read-only-storage' }
-        },
-        {
-          binding: 3,
-          visibility: GPUShaderStage.FRAGMENT,
-          texture: { sampleType: 'unfilterable-float' } // textureLoad requires unfilterable
-        },
-        {
-          binding: 4,
-          visibility: GPUShaderStage.FRAGMENT,
-          buffer: { type: 'uniform' }
-        }
-      ]
-    })
+      // Create bind group layout (no sampler needed - using textureLoad for pixel-perfect sampling)
+      this.bindGroupLayout = this.device.createBindGroupLayout({
+        entries: [
+          {
+            binding: 0,
+            visibility: GPUShaderStage.VERTEX,
+            buffer: { type: 'uniform' }
+          },
+          {
+            binding: 1,
+            visibility: GPUShaderStage.VERTEX,
+            buffer: { type: 'read-only-storage' }
+          },
+          {
+            binding: 3,
+            visibility: GPUShaderStage.FRAGMENT,
+            texture: { sampleType: 'unfilterable-float' } // textureLoad requires unfilterable
+          },
+          {
+            binding: 4,
+            visibility: GPUShaderStage.FRAGMENT,
+            buffer: { type: 'uniform' }
+          }
+        ]
+      })
 
-    // Create pipeline layout
-    const pipelineLayout = this.device.createPipelineLayout({
-      bindGroupLayouts: [this.bindGroupLayout]
-    })
+      // Create pipeline layout
+      const pipelineLayout = this.device.createPipelineLayout({
+        bindGroupLayouts: [this.bindGroupLayout]
+      })
 
-    // Create render pipeline
-    this.pipeline = this.device.createRenderPipeline({
-      layout: pipelineLayout,
-      vertex: {
-        module: vertexModule,
-        entryPoint: 'vertexMain'
-      },
-      fragment: {
-        module: fragmentModule,
-        entryPoint: 'fragmentMain',
-        targets: [
-          {
-            format: this.format,
-            blend: {
-              color: {
-                srcFactor: 'one',
-                dstFactor: 'one-minus-src-alpha',
-                operation: 'add'
-              },
-              alpha: {
-                srcFactor: 'one',
-                dstFactor: 'one-minus-src-alpha',
-                operation: 'add'
+      // Create render pipeline
+      this.pipeline = this.device.createRenderPipeline({
+        layout: pipelineLayout,
+        vertex: {
+          module: vertexModule,
+          entryPoint: 'vertexMain'
+        },
+        fragment: {
+          module: fragmentModule,
+          entryPoint: 'fragmentMain',
+          targets: [
+            {
+              format: this.format,
+              blend: {
+                color: {
+                  srcFactor: 'one',
+                  dstFactor: 'one-minus-src-alpha',
+                  operation: 'add'
+                },
+                alpha: {
+                  srcFactor: 'one',
+                  dstFactor: 'one-minus-src-alpha',
+                  operation: 'add'
+                }
               }
             }
-          }
-        ]
-      },
-      primitive: {
-        topology: 'triangle-list'
-      }
-    })
+          ]
+        },
+        primitive: {
+          topology: 'triangle-list'
+        }
+      })
+    })()
   }
 
   async setCanvas (canvas: OffscreenCanvas, width: number, height: number) {
-    await this.initPromise
-    if (!this.device) {
-      throw new Error('WebGPU device not initialized. Did you await the constructor promise?')
-    }
+    await this._ready
+    if (!this.device) return
+
+    // WebGPU doesn't allow 0-sized textures/swapchains
+    if (width <= 0 || height <= 0) return
 
     canvas.width = width
     canvas.height = height
@@ -325,9 +324,10 @@ export class WebGPURenderer {
    * Pass null or undefined to use identity (no conversion).
    * Matrix should be a pre-padded Float32Array with 12 values (3 columns × 4 floats each).
    */
-  setColorMatrix (matrix?: Float32Array<ArrayBuffer>): void {
-    if (!this.device || !this.colorMatrixBuffer) return
-    this.device.queue.writeBuffer(this.colorMatrixBuffer, 0, matrix ?? IDENTITY_MATRIX)
+  async setColorMatrix (matrix?: Float32Array<ArrayBuffer>) {
+    await this._ready
+    if (!this.device) return
+    this.device.queue.writeBuffer(this.colorMatrixBuffer!, 0, matrix ?? IDENTITY_MATRIX)
   }
 
   private createTextureInfo (width: number, height: number): TextureInfo {
@@ -348,9 +348,13 @@ export class WebGPURenderer {
   render (images: ASSImage[], heap: Uint8Array): void {
     if (!this.device || !this.context || !this.pipeline) return
 
+    // getCurrentTexture fails if canvas has 0 dimensions
+    const currentTexture = this.context.getCurrentTexture()
+    if (currentTexture.width === 0 || currentTexture.height === 0) return
+
     const commandEncoder = this.device.createCommandEncoder()
 
-    const textureView = this.context.getCurrentTexture().createView()
+    const textureView = currentTexture.createView()
 
     // Begin render pass
     const renderPass = commandEncoder.beginRenderPass({
@@ -378,13 +382,13 @@ export class WebGPURenderer {
     }
 
     // Render each image
-    for (let i = 0, texIndex = 0; i < images.length; i++, texIndex++) {
+    for (let i = 0, texIndex = -1; i < images.length; i++) {
       const img = images[i]!
 
       // Skip images with invalid dimensions (WebGPU doesn't allow 0-sized textures)
       if (img.w <= 0 || img.h <= 0) continue
 
-      let texInfo = this.textures[texIndex]!
+      let texInfo = this.textures[++texIndex]!
 
       // Recreate texture if size changed (use actual w, not stride)
       if (texInfo.width !== img.w || texInfo.height !== img.h) {
@@ -456,28 +460,7 @@ export class WebGPURenderer {
     this.pendingDestroyTextures = []
   }
 
-  clear (): void {
-    if (!this.device || !this.context) return
-
-    const commandEncoder = this.device.createCommandEncoder()
-    const textureView = this.context.getCurrentTexture().createView()
-
-    const renderPass = commandEncoder.beginRenderPass({
-      colorAttachments: [
-        {
-          view: textureView,
-          clearValue: { r: 0, g: 0, b: 0, a: 0 },
-          loadOp: 'clear',
-          storeOp: 'store'
-        }
-      ]
-    })
-
-    renderPass.end()
-    this.device.queue.submit([commandEncoder.finish()])
-  }
-
-  destroy (): void {
+  destroy () {
     for (const tex of this.textures) {
       tex.texture.destroy()
     }

package/src/worker/worker.ts

@@ -28,7 +28,6 @@ interface opts {
   libassMemoryLimit: number
   libassGlyphLimit: number
   useLocalFonts: boolean
-  supportsSIMD: boolean
 }
 
 export class ASSRenderer {
@@ -68,7 +67,7 @@ export class ASSRenderer {
     }
     addEventListener('message', handleMessage)
 
-    this._ready = (WASM({ __supportsSIMD: data.supportsSIMD, __url: data.wasmUrl }) as Promise<MainModule>).then(Module => {
+    this._ready = (WASM({ __url: data.wasmUrl }) as Promise<MainModule>).then(Module => {
       // eslint-disable-next-line @typescript-eslint/unbound-method
       this._malloc = Module._malloc