@flighthq/render-wgpu 0.1.0 → 0.2.1-next.410.a23f189

package/src/wgpuRenderState.test.ts

@@ -2,6 +2,7 @@ import {
   createWgpuRenderStateRuntime,
   destroyWgpuRenderState,
   getWgpuRenderStateRuntime,
+  getWgpuSampler,
   isWgpuSupported,
 } from './wgpuRenderState';
 import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
@@ -81,6 +82,51 @@ describe('getWgpuRenderStateRuntime', () => {
   });
 });
 
+describe('getWgpuSampler', () => {
+  it('caches a sampler per filter+wrap+mip+anisotropy key and reuses it', 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);
+  });
+
+  it('returns a distinct sampler for a different wrap or filter', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const repeat = getWgpuSampler(state, 'linear', 'repeat', 'repeat');
+    const clamp = getWgpuSampler(state, 'linear', 'clamp-to-edge', 'clamp-to-edge');
+    const nearest = getWgpuSampler(state, 'nearest', 'repeat', 'repeat');
+    expect(repeat).not.toBe(clamp);
+    expect(repeat).not.toBe(nearest);
+  });
+
+  it('keys the mip filter separately so a trilinear sampler differs from a non-mip one', async () => {
+    const state = await createWgpuRenderStateForTest();
+    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);
+  });
+
+  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.
+    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);
+  });
+
+  it('floors and clamps the anisotropy level into the cache key', async () => {
+    const state = await createWgpuRenderStateForTest();
+    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);
+  });
+});
+
 describe('isWgpuSupported', () => {
   it('returns true when navigator.gpu is present', () => {
     expect(isWgpuSupported()).toBe(true);

package/src/wgpuRenderTarget.test.ts

@@ -3,12 +3,13 @@ import { createMatrix } from '@flighthq/geometry';
 import { renderWgpuBackground, submitWgpuRenderPass } from './wgpuBackground';
 import { getWgpuRenderStateRuntime } from './wgpuRenderState';
 import {
-  beginWgpuRenderTarget,
+  beginWgpuRenderPass,
   createWgpuRenderTarget,
   destroyWgpuRenderTarget,
   drawWgpuRenderTargetResult,
-  endWgpuRenderTarget,
+  endWgpuRenderPass,
   resizeWgpuRenderTarget,
+  setWgpuRenderTransform2D,
 } from './wgpuRenderTarget';
 import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
 
@@ -16,31 +17,28 @@ beforeAll(() => {
   installWgpuMock();
 });
 
-describe('beginWgpuRenderTarget', () => {
+describe('beginWgpuRenderPass', () => {
   it('sets the render target viewport', async () => {
     const state = await createWgpuRenderStateForTest();
     renderWgpuBackground(state);
     const target = createWgpuRenderTarget(state, 64, 64);
-    beginWgpuRenderTarget(state, target, createMatrix());
+    beginWgpuRenderPass(state, target);
     expect(getWgpuRenderStateRuntime(state).renderTargetViewport?.width).toBe(64);
-    endWgpuRenderTarget(state);
+    endWgpuRenderPass(state);
     submitWgpuRenderPass(state);
   });
-});
 
-describe('beginWgpuRenderTarget / endWgpuRenderTarget', () => {
-  it('switches the render target and restores it', async () => {
+  it('switches the render target and restores it on end', async () => {
     const state = await createWgpuRenderStateForTest();
     renderWgpuBackground(state);
 
     const target = createWgpuRenderTarget(state, 128, 128);
-    const transform = createMatrix();
-    beginWgpuRenderTarget(state, target, transform);
+    beginWgpuRenderPass(state, target);
 
     const runtime = getWgpuRenderStateRuntime(state);
     expect(runtime.renderTargetViewport?.width).toBe(128);
 
-    endWgpuRenderTarget(state);
+    endWgpuRenderPass(state);
     expect(runtime.renderTargetViewport).toBeNull();
 
     submitWgpuRenderPass(state);
@@ -94,13 +92,13 @@ describe('drawWgpuRenderTargetResult', () => {
   });
 });
 
-describe('endWgpuRenderTarget', () => {
+describe('endWgpuRenderPass', () => {
   it('restores null renderTargetViewport', async () => {
     const state = await createWgpuRenderStateForTest();
     renderWgpuBackground(state);
     const target = createWgpuRenderTarget(state, 32, 32);
-    beginWgpuRenderTarget(state, target, createMatrix());
-    endWgpuRenderTarget(state);
+    beginWgpuRenderPass(state, target);
+    endWgpuRenderPass(state);
     expect(getWgpuRenderStateRuntime(state).renderTargetViewport).toBeNull();
     submitWgpuRenderPass(state);
   });
@@ -118,3 +116,23 @@ describe('resizeWgpuRenderTarget', () => {
     expect(target.bindGroup).not.toBe(previousBindGroup);
   });
 });
+
+describe('setWgpuRenderTransform2D', () => {
+  it('installs a copy of the transform, restored by the enclosing pass', async () => {
+    const state = await createWgpuRenderStateForTest();
+    renderWgpuBackground(state);
+    const original = state.renderTransform2D;
+    const target = createWgpuRenderTarget(state, 32, 32);
+    const bake = createMatrix();
+    bake.tx = 42;
+
+    beginWgpuRenderPass(state, target);
+    setWgpuRenderTransform2D(state, bake);
+    expect(state.renderTransform2D?.tx).toBe(42);
+    expect(state.renderTransform2D).not.toBe(bake);
+    endWgpuRenderPass(state);
+
+    expect(state.renderTransform2D).toBe(original);
+    submitWgpuRenderPass(state);
+  });
+});

package/src/wgpuShader.test.ts

@@ -1,3 +1,5 @@
+import { AdvancedBlendMode, BlendMode } from '@flighthq/types';
+
 import { renderWgpuBackground } from './wgpuBackground';
 import { getWgpuRenderStateRuntime } from './wgpuRenderState';
 import {
@@ -63,6 +65,44 @@ describe('getWgpuPipeline', () => {
     const maskwrite = getWgpuPipeline(state, null, 'maskwrite');
     expect(normal).not.toBe(maskwrite);
   });
+
+  it('realizes each fixed-function blend mode with GL-parity factors', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const blendOf = (mode: BlendMode) =>
+      [
+        ...(getWgpuPipeline(state, mode, 'normal') as unknown as { __descriptor: GPURenderPipelineDescriptor })
+          .__descriptor.fragment!.targets,
+      ][0]!.blend!.color;
+    expect(blendOf(BlendMode.Normal)).toEqual({ srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' });
+    expect(blendOf(BlendMode.Add)).toEqual({ srcFactor: 'one', dstFactor: 'one', operation: 'add' });
+    expect(blendOf(BlendMode.Multiply)).toEqual({
+      srcFactor: 'dst',
+      dstFactor: 'one-minus-src-alpha',
+      operation: 'add',
+    });
+    expect(blendOf(BlendMode.Screen)).toEqual({ srcFactor: 'one', dstFactor: 'one-minus-src', operation: 'add' });
+    expect(blendOf(BlendMode.Darken).operation).toBe('min');
+    expect(blendOf(BlendMode.Lighten).operation).toBe('max');
+  });
+
+  it('falls back to normal blend for shader-composited modes', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const blendOf = (mode: BlendMode) =>
+      [
+        ...(getWgpuPipeline(state, mode, 'normal') as unknown as { __descriptor: GPURenderPipelineDescriptor })
+          .__descriptor.fragment!.targets,
+      ][0]!.blend!.color;
+    expect(blendOf(AdvancedBlendMode.Overlay)).toEqual({
+      srcFactor: 'one',
+      dstFactor: 'one-minus-src-alpha',
+      operation: 'add',
+    });
+    expect(blendOf(AdvancedBlendMode.HardLight)).toEqual({
+      srcFactor: 'one',
+      dstFactor: 'one-minus-src-alpha',
+      operation: 'add',
+    });
+  });
 });
 
 describe('setWgpuMatrixFromTransform', () => {

package/src/wgpuTextureUpload.test.ts

@@ -0,0 +1,60 @@
+import type { ImageResource } from '@flighthq/types';
+
+import { uploadWgpuTextureData, uploadWgpuTextureElement, uploadWgpuTextureImageResource } from './wgpuTextureUpload';
+
+// A device whose queue records the two upload calls so a test can assert which path ran and with what.
+function makeDevice(): GPUDevice {
+  return {
+    queue: { writeTexture: vi.fn(), copyExternalImageToTexture: vi.fn() },
+  } as unknown as GPUDevice;
+}
+
+describe('uploadWgpuTextureData', () => {
+  it('drives writeTexture with a tightly-packed rgba8 layout (bytesPerRow = width*4)', () => {
+    const device = makeDevice();
+    const texture = {} as GPUTexture;
+    const data = new Uint8ClampedArray(2 * 2 * 4);
+    uploadWgpuTextureData(device, texture, [0, 0, 3], 2, 2, data);
+    expect(device.queue.writeTexture).toHaveBeenCalledWith(
+      { texture, origin: [0, 0, 3] },
+      data,
+      { bytesPerRow: 8, rowsPerImage: 2 },
+      [2, 2, 1],
+    );
+  });
+});
+
+describe('uploadWgpuTextureElement', () => {
+  it('drives copyExternalImageToTexture with the external source', () => {
+    const device = makeDevice();
+    const texture = {} as GPUTexture;
+    const source = {} as GPUCopyExternalImageSource;
+    uploadWgpuTextureElement(device, texture, [0, 0, 0], 4, 4, source);
+    expect(device.queue.copyExternalImageToTexture).toHaveBeenCalledWith(
+      { source },
+      { texture, origin: [0, 0, 0] },
+      [4, 4, 1],
+    );
+  });
+});
+
+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;
+    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();
+  });
+});