@flighthq/render-wgpu 0.2.1-next.841.373388f → 0.3.0-next.1032.e2b99fc

package/src/wgpuShaderBinding.test.ts

@@ -1,6 +1,6 @@
-import { getOrCreateRenderProxy2D } from '@flighthq/render';
-import { createBitmap } from '@flighthq/scene2d';
-import type { WgpuBitmapShader } from '@flighthq/types';
+import { getOrCreateRenderProxy2D } from '@flighthq/render/contract';
+import { createSprite } from '@flighthq/scene2d/contract';
+import type { WgpuBitmapShader } from '@flighthq/types/contract';
 
 import { getWgpuRenderStateRuntime } from './wgpuRenderState';
 import { getWgpuShader, resolveWgpuShader, setWgpuShader } from './wgpuShaderBinding';
@@ -13,7 +13,7 @@ beforeAll(() => {
 describe('getWgpuShader', () => {
   it('returns undefined when no shader is bound', async () => {
     const state = await createWgpuRenderStateForTest();
-    const bitmap = createBitmap();
+    const bitmap = createSprite();
     const renderProxy = getOrCreateRenderProxy2D(state, bitmap);
     expect(getWgpuShader(renderProxy)).toBeUndefined();
   });
@@ -22,7 +22,7 @@ describe('getWgpuShader', () => {
 describe('resolveWgpuShader', () => {
   it('returns null when no shader feature is enabled', async () => {
     const state = await createWgpuRenderStateForTest();
-    const bitmap = createBitmap();
+    const bitmap = createSprite();
     const renderProxy = getOrCreateRenderProxy2D(state, bitmap);
     expect(resolveWgpuShader(state, renderProxy)).toBeNull();
   });
@@ -31,7 +31,7 @@ describe('resolveWgpuShader', () => {
 describe('setWgpuShader', () => {
   it('binds a shader to a display object', async () => {
     const state = await createWgpuRenderStateForTest();
-    const bitmap = createBitmap();
+    const bitmap = createSprite();
     const fakeShader: WgpuBitmapShader = { pipeline: {} as never, bind: () => {} };
 
     setWgpuShader(state, bitmap, fakeShader);
@@ -43,7 +43,7 @@ describe('setWgpuShader', () => {
   it('installs the per-node shader binding resolver', async () => {
     const state = await createWgpuRenderStateForTest();
     const runtime = getWgpuRenderStateRuntime(state);
-    const bitmap = createBitmap();
+    const bitmap = createSprite();
     const fakeShader: WgpuBitmapShader = { pipeline: {} as never, bind: () => {} };
     expect(runtime.webgpuShaderBindingResolver).toBeUndefined();
     setWgpuShader(state, bitmap, fakeShader);
@@ -52,7 +52,7 @@ describe('setWgpuShader', () => {
 
   it('removes the binding when shader is null', async () => {
     const state = await createWgpuRenderStateForTest();
-    const bitmap = createBitmap();
+    const bitmap = createSprite();
     const fakeShader: WgpuBitmapShader = { pipeline: {} as never, bind: () => {} };
     setWgpuShader(state, bitmap, fakeShader);
     setWgpuShader(state, bitmap, null);

package/src/wgpuShaderRegistry.test.ts

@@ -1,4 +1,4 @@
-import type { WgpuBitmapShader } from '@flighthq/types';
+import type { WgpuBitmapShader } from '@flighthq/types/contract';
 
 import { getWgpuRenderStateRuntime } from './wgpuRenderState';
 import { registerWgpuBitmapShader } from './wgpuShaderRegistry';

package/src/wgpuSurface.test.ts

@@ -3,7 +3,7 @@ import { beforeAll, describe, expect, it } from 'vitest';
 import { getWgpuRenderStateRuntime } from './wgpuRenderState';
 import {
   acquireWgpuFrameCaptureTexture,
-  createSurfaceFromWgpuRenderState,
+  createBitmapFromWgpuRenderState,
   enableWgpuFrameCapture,
   encodeWgpuFrameCapture,
 } from './wgpuSurface';
@@ -22,10 +22,10 @@ describe('acquireWgpuFrameCaptureTexture', () => {
   });
 });
 
-describe('createSurfaceFromWgpuRenderState', () => {
+describe('createBitmapFromWgpuRenderState', () => {
   it('throws when frame capture was never enabled (no buffer to read)', async () => {
     const state = await createWgpuRenderStateForTest();
-    await expect(createSurfaceFromWgpuRenderState(state)).rejects.toThrow(/enableWgpuFrameCapture/);
+    await expect(createBitmapFromWgpuRenderState(state)).rejects.toThrow(/enableWgpuFrameCapture/);
   });
 });
 

package/src/wgpuTextureResolver.test.ts

@@ -0,0 +1,156 @@
+import type { ImageResource, RenderTexture, Texture } from '@flighthq/types/contract';
+import {
+  BitmapTextureBackingKind,
+  CompressedImageTextureBackingKind,
+  ImageTextureBackingKind,
+  RenderTextureBackingKind,
+  VideoTextureBackingKind,
+} from '@flighthq/types/contract';
+
+import { renderWgpuBackground, submitWgpuRenderPass } from './wgpuBackground';
+import { getWgpuRenderStateRuntime } from './wgpuRenderState';
+import { renderIntoWgpuRenderTexture } from './wgpuRenderTexture';
+import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
+import {
+  registerWgpuImageTextureResolver,
+  registerWgpuBitmapTextureResolver,
+  registerWgpuCompressedImageTextureResolver,
+  registerWgpuRenderTextureResolver,
+  registerWgpuTextureResolver,
+  registerWgpuVideoTextureResolver,
+  resolveWgpuTexture,
+} from './wgpuTextureResolver';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+function imageResource(
+  kind = ImageTextureBackingKind,
+  source: CanvasImageSource = document.createElement('canvas'),
+): ImageResource {
+  return {
+    height: 4,
+    kind,
+    source,
+    version: 0,
+    width: 4,
+  } as unknown as ImageResource;
+}
+
+function textureWithImage(image: ImageResource | null): Texture {
+  return {
+    colorSpace: 'srgb',
+    flipX: false,
+    flipY: false,
+    sampler: {
+      anisotropy: 1,
+      magFilter: 'linear',
+      minFilter: 'linear',
+      mipmaps: false,
+      wrapU: 'clamp-to-edge',
+      wrapV: 'clamp-to-edge',
+    },
+    storage: { dimension: '2d', image },
+    uvOffset: { x: 0, y: 0 },
+    uvRotation: 0,
+    uvScale: { x: 1, y: 1 },
+    version: 0,
+  } as Texture;
+}
+
+function renderTexture(): RenderTexture {
+  const texture = textureWithImage(null);
+  texture.colorSpace = 'linear';
+  texture.storage.target = { height: 8, kind: RenderTextureBackingKind, width: 8 };
+  return texture as RenderTexture;
+}
+
+describe('registerWgpuBitmapTextureResolver', () => {
+  it('registers only the Bitmap backing key', async () => {
+    const state = await createWgpuRenderStateForTest();
+    registerWgpuBitmapTextureResolver(state);
+    expect([...getWgpuRenderStateRuntime(state).wgpuTextureResolverRegistry!.keys()]).toEqual([
+      BitmapTextureBackingKind,
+    ]);
+  });
+});
+
+describe('registerWgpuCompressedImageTextureResolver', () => {
+  it('registers only the CompressedImage backing key', async () => {
+    const state = await createWgpuRenderStateForTest();
+    registerWgpuCompressedImageTextureResolver(state);
+    expect([...getWgpuRenderStateRuntime(state).wgpuTextureResolverRegistry!.keys()]).toEqual([
+      CompressedImageTextureBackingKind,
+    ]);
+  });
+});
+
+describe('registerWgpuImageTextureResolver', () => {
+  it('resolves and caches a declared still-image backing', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const texture = textureWithImage(imageResource());
+    registerWgpuImageTextureResolver(state);
+
+    const first = resolveWgpuTexture(state, texture);
+    expect(first).not.toBeNull();
+    expect(resolveWgpuTexture(state, texture)).toBe(first);
+  });
+});
+
+describe('registerWgpuRenderTextureResolver', () => {
+  it('returns a render target only after it has been rendered', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const texture = renderTexture();
+    registerWgpuRenderTextureResolver(state);
+    expect(resolveWgpuTexture(state, texture)).toBeNull();
+
+    renderWgpuBackground(state);
+    renderIntoWgpuRenderTexture(state, texture, () => {});
+    expect(resolveWgpuTexture(state, texture)).not.toBeNull();
+    submitWgpuRenderPass(state);
+  });
+});
+
+describe('registerWgpuTextureResolver', () => {
+  it('is state-scoped, last-write-wins by string kind, and removable', async () => {
+    const a = await createWgpuRenderStateForTest();
+    const b = await createWgpuRenderStateForTest();
+    const image = imageResource();
+    image.kind = 'acme.generated';
+    const texture = textureWithImage(image);
+    const first = vi.fn(() => ({ first: true }) as never);
+    const second = vi.fn(() => ({ second: true }) as never);
+
+    registerWgpuTextureResolver(a, image.kind, first);
+    expect(resolveWgpuTexture(a, texture)).toEqual({ first: true });
+    expect(resolveWgpuTexture(b, texture)).toBeNull();
+
+    registerWgpuTextureResolver(a, image.kind, second);
+    expect(resolveWgpuTexture(a, texture)).toEqual({ second: true });
+
+    registerWgpuTextureResolver(a, image.kind, null);
+    expect(resolveWgpuTexture(a, texture)).toBeNull();
+  });
+});
+
+describe('registerWgpuVideoTextureResolver', () => {
+  it('resolves a ready declared video backing without structural dispatch', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const image = imageResource(VideoTextureBackingKind, {
+      readyState: 4,
+      videoHeight: 8,
+      videoWidth: 8,
+    } as HTMLVideoElement);
+    const texture = textureWithImage(image);
+    registerWgpuVideoTextureResolver(state);
+    expect(resolveWgpuTexture(state, texture)).not.toBeNull();
+  });
+});
+
+describe('resolveWgpuTexture', () => {
+  it('returns null without an exact registered backing kind', async () => {
+    const state = await createWgpuRenderStateForTest();
+    expect(resolveWgpuTexture(state, textureWithImage(null))).toBeNull();
+  });
+});

package/src/wgpuTextureUpload.test.ts

@@ -1,4 +1,4 @@
-import type { ImageResource } from '@flighthq/types';
+import type { ImageResource } from '@flighthq/types/contract';
 
 import { uploadWgpuTextureData, uploadWgpuTextureElement, uploadWgpuTextureImageResource } from './wgpuTextureUpload';
 
@@ -42,19 +42,9 @@ describe('uploadWgpuTextureImageResource', () => {
   it('takes the element path when the resource carries a source', () => {
     const device = makeDevice();
     const texture = {} as GPUTexture;
-    const image = { source: {} as CanvasImageSource, data: null, width: 4, height: 4 } as ImageResource;
+    const image = { source: {} as CanvasImageSource, width: 4, height: 4 } as unknown as ImageResource;
     uploadWgpuTextureImageResource(device, texture, [0, 0, 0], image);
     expect(device.queue.copyExternalImageToTexture).toHaveBeenCalledTimes(1);
     expect(device.queue.writeTexture).not.toHaveBeenCalled();
   });
-
-  it('takes the raw-pixel path when the resource is data-only', () => {
-    const device = makeDevice();
-    const texture = {} as GPUTexture;
-    const data = new Uint8ClampedArray(4 * 4 * 4);
-    const image = { source: null, data, width: 4, height: 4 } as ImageResource;
-    uploadWgpuTextureImageResource(device, texture, [0, 0, 0], image);
-    expect(device.queue.writeTexture).toHaveBeenCalledTimes(1);
-    expect(device.queue.copyExternalImageToTexture).not.toHaveBeenCalled();
-  });
 });