@flighthq/render-wgpu 0.2.1-next.666.4af7f8b → 0.2.1-next.738.07b221d

package/src/wgpuDraw.test.ts

@@ -1,6 +1,6 @@
 import { createBitmap } from '@flighthq/displayobject';
 import { getOrCreateRenderProxy2D, prepareDisplayObjectRender } from '@flighthq/render';
-import type { ImageResource } from '@flighthq/types';
+import type { ImageResource, VideoTexture } from '@flighthq/types';
 import { BlendMode } from '@flighthq/types';
 
 import { renderWgpuBackground, submitWgpuRenderPass } from './wgpuBackground';
@@ -8,10 +8,12 @@ import {
   applyWgpuBlendMode,
   bindWgpuImageResourceTexture,
   bindWgpuTexture,
+  bindWgpuVideoTexture,
   buildWgpuRenderTargetBindGroup,
   createWgpuTextureEntry,
   drawWgpuQuad,
   drawWgpuQuadWithTransform,
+  destroyWgpuVideoTexture,
   enableWgpuBlendModeSupport,
   getWgpuRenderProxyColorTransform,
   submitWgpuQuadDraw,
@@ -125,6 +127,61 @@ describe('bindWgpuTexture', () => {
   });
 });
 
+describe('bindWgpuVideoTexture', () => {
+  function videoTexture(frameId: number, readyState = 4, width = 320, height = 240): VideoTexture {
+    return {
+      frameId,
+      sampler: {
+        anisotropy: 1,
+        magFilter: 'linear',
+        minFilter: 'linear',
+        mipmaps: false,
+        wrapU: 'clamp-to-edge',
+        wrapV: 'clamp-to-edge',
+      },
+      source: { element: { readyState, videoHeight: height, videoWidth: width } as HTMLVideoElement },
+    } as unknown as VideoTexture;
+  }
+
+  it('uploads once per frameId and caches the texture by VideoTexture identity', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const copy = vi.spyOn(state.device.queue, 'copyExternalImageToTexture');
+    const video = videoTexture(1);
+    const first = bindWgpuVideoTexture(state, video);
+    expect(first).not.toBeNull();
+    expect(copy).toHaveBeenCalledTimes(1);
+    expect(bindWgpuVideoTexture(state, video)).toBe(first);
+    expect(copy).toHaveBeenCalledTimes(1);
+    video.frameId = 2;
+    expect(bindWgpuVideoTexture(state, video)).toBe(first);
+    expect(copy).toHaveBeenCalledTimes(2);
+  });
+
+  it('waits for a decoded frame and recreates the texture after a resolution change', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const video = videoTexture(1, 1, 0, 0);
+    expect(bindWgpuVideoTexture(state, video)).toBeNull();
+    const element = video.source.element!;
+    Object.assign(element, { readyState: 4, videoHeight: 120, videoWidth: 160 });
+    const first = bindWgpuVideoTexture(state, video)!;
+    const destroy = vi.spyOn(first.texture, 'destroy');
+    Object.assign(element, { videoHeight: 240, videoWidth: 320 });
+    const second = bindWgpuVideoTexture(state, video)!;
+    expect(second).not.toBe(first);
+    expect(destroy).toHaveBeenCalled();
+  });
+
+  it('destroys and removes an uploaded video texture', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const video = videoTexture(1);
+    const entry = bindWgpuVideoTexture(state, video)!;
+    const destroy = vi.spyOn(entry.texture, 'destroy');
+    expect(destroyWgpuVideoTexture(state, video)).toBe(true);
+    expect(destroy).toHaveBeenCalled();
+    expect(destroyWgpuVideoTexture(state, video)).toBe(false);
+  });
+});
+
 describe('buildWgpuRenderTargetBindGroup', () => {
   it('returns a bind group for a view', async () => {
     const state = await createWgpuRenderStateForTest();
@@ -146,6 +203,12 @@ describe('createWgpuTextureEntry', () => {
   });
 });
 
+describe('destroyWgpuVideoTexture', () => {
+  it('is the public disposal entry point for dynamic video uploads', () => {
+    expect(typeof destroyWgpuVideoTexture).toBe('function');
+  });
+});
+
 describe('drawWgpuQuad', () => {
   it('does not throw when render pass is open', async () => {
     const state = await createWgpuRenderStateForTest();

package/src/wgpuRenderState.test.ts

@@ -83,12 +83,14 @@ describe('getWgpuRenderStateRuntime', () => {
 });
 
 describe('getWgpuSampler', () => {
-  it('caches a sampler per filter+wrap+mip+anisotropy key and reuses it', async () => {
+  it('caches a sampler per filter+wrap+mip+anisotropy config and reuses it (one createSampler)', async () => {
     const state = await createWgpuRenderStateForTest();
     const a = getWgpuSampler(state, 'linear', 'repeat', 'repeat');
     const b = getWgpuSampler(state, 'linear', 'repeat', 'repeat');
     expect(a).toBe(b);
-    expect(getWgpuRenderStateRuntime(state).samplerCache.get('linear|repeat|repeat|none|1')).toBe(a);
+    // The cache is keyed by a packed NUMBER (no per-call string allocation), and one config caches once.
+    expect([...getWgpuRenderStateRuntime(state).samplerCache.keys()].every((k) => typeof k === 'number')).toBe(true);
+    expect(getWgpuRenderStateRuntime(state).samplerCache.size).toBe(1);
   });
 
   it('returns a distinct sampler for a different wrap or filter', async () => {
@@ -105,17 +107,16 @@ describe('getWgpuSampler', () => {
     const noMip = getWgpuSampler(state, 'linear', 'repeat', 'repeat');
     const trilinear = getWgpuSampler(state, 'linear', 'repeat', 'repeat', 'linear');
     expect(noMip).not.toBe(trilinear);
-    expect(getWgpuRenderStateRuntime(state).samplerCache.has('linear|repeat|repeat|linear|1')).toBe(true);
+    expect(getWgpuRenderStateRuntime(state).samplerCache.size).toBe(2);
   });
 
   it('forces linear filtering and a linear mip filter when anisotropy exceeds 1', async () => {
     // WebGPU rejects maxAnisotropy > 1 unless min/mag/mip are all linear, so a nearest+aniso request
-    // collapses to the linear anisotropic key.
+    // collapses to the SAME sampler as the explicit linear/trilinear anisotropic request.
     const state = await createWgpuRenderStateForTest();
-    const sampler = getWgpuSampler(state, 'nearest', 'clamp-to-edge', 'clamp-to-edge', undefined, 8);
-    const cache = getWgpuRenderStateRuntime(state).samplerCache;
-    expect(cache.get('linear|clamp-to-edge|clamp-to-edge|linear|8')).toBe(sampler);
-    expect(cache.has('nearest|clamp-to-edge|clamp-to-edge|none|8')).toBe(false);
+    const collapsed = getWgpuSampler(state, 'nearest', 'clamp-to-edge', 'clamp-to-edge', undefined, 8);
+    const explicit = getWgpuSampler(state, 'linear', 'clamp-to-edge', 'clamp-to-edge', 'linear', 8);
+    expect(collapsed).toBe(explicit);
   });
 
   it('floors and clamps the anisotropy level into the cache key', async () => {
@@ -123,7 +124,7 @@ describe('getWgpuSampler', () => {
     const a = getWgpuSampler(state, 'linear', 'repeat', 'repeat', 'linear', 4.9);
     const b = getWgpuSampler(state, 'linear', 'repeat', 'repeat', 'linear', 4);
     expect(a).toBe(b);
-    expect(getWgpuRenderStateRuntime(state).samplerCache.has('linear|repeat|repeat|linear|4')).toBe(true);
+    expect(getWgpuRenderStateRuntime(state).samplerCache.size).toBe(1);
   });
 });
 

package/src/wgpuShader.test.ts

@@ -6,6 +6,7 @@ import {
   createWgpuBindGroupLayouts,
   createWgpuPipelineLayout,
   getActiveWgpuPipeline,
+  getWgpuBlendState,
   getWgpuPipeline,
   setWgpuMatrixFromTransform,
   UNIFORM_BYTE_SIZE,
@@ -51,6 +52,29 @@ describe('getActiveWgpuPipeline', () => {
   });
 });
 
+describe('getWgpuBlendState', () => {
+  it('resolves all six fixed states and falls back to Normal for null or unknown modes', () => {
+    const color = (mode: BlendMode | null) => getWgpuBlendState(mode).color;
+    const normal = { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' };
+    expect(color(null)).toEqual(normal);
+    expect(color(AdvancedBlendMode.Overlay)).toEqual(normal);
+    expect(color(BlendMode.Normal)).toEqual(normal);
+    expect(color(BlendMode.Add)).toEqual({ srcFactor: 'one', dstFactor: 'one', operation: 'add' });
+    expect(color(BlendMode.Multiply)).toEqual({
+      srcFactor: 'dst',
+      dstFactor: 'one-minus-src-alpha',
+      operation: 'add',
+    });
+    expect(color(BlendMode.Screen)).toEqual({
+      srcFactor: 'one',
+      dstFactor: 'one-minus-src',
+      operation: 'add',
+    });
+    expect(color(BlendMode.Darken).operation).toBe('min');
+    expect(color(BlendMode.Lighten).operation).toBe('max');
+  });
+});
+
 describe('getWgpuPipeline', () => {
   it('returns a cached pipeline on second call', async () => {
     const state = await createWgpuRenderStateForTest();
@@ -177,4 +201,22 @@ describe('writeWgpuQuadUniforms', () => {
     expect(runtime.uniformData[floatBase + 28]).toBeCloseTo(0.1);
     expect(runtime.uniformData[floatBase + 12]).toBeCloseTo(0.5); // alpha
   });
+
+  it('writes the native straight-alpha texture flag at u32 offset 14', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const runtime = getWgpuRenderStateRuntime(state);
+    renderWgpuBackground(state);
+    const fakeNode = {
+      alpha: 1,
+      useColorTransform: false,
+      colorTransform: null,
+      transform2D: { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 },
+    };
+
+    const straightOffset = writeWgpuQuadUniforms(state, fakeNode, null, 0, 0, 1, 1, 0, 0, 1, 1, true);
+    const premultipliedOffset = writeWgpuQuadUniforms(state, fakeNode, null, 0, 0, 1, 1, 0, 0, 1, 1);
+
+    expect(runtime.uniformDataU32[(straightOffset >> 2) + 14]).toBe(1);
+    expect(runtime.uniformDataU32[(premultipliedOffset >> 2) + 14]).toBe(0);
+  });
 });