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

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,4 +1,4 @@
-import { BlendMode } from '@flighthq/types';
+import { AdvancedBlendMode, BlendMode } from '@flighthq/types';
 
 import { renderWgpuBackground } from './wgpuBackground';
 import { getWgpuRenderStateRuntime } from './wgpuRenderState';
@@ -81,11 +81,8 @@ describe('getWgpuPipeline', () => {
       operation: 'add',
     });
     expect(blendOf(BlendMode.Screen)).toEqual({ srcFactor: 'one', dstFactor: 'one-minus-src', operation: 'add' });
-    expect(blendOf(BlendMode.Erase)).toEqual({ srcFactor: 'zero', dstFactor: 'one-minus-src-alpha', operation: 'add' });
-    expect(blendOf(BlendMode.None)).toEqual({ srcFactor: 'one', dstFactor: 'zero', operation: 'add' });
     expect(blendOf(BlendMode.Darken).operation).toBe('min');
     expect(blendOf(BlendMode.Lighten).operation).toBe('max');
-    expect(blendOf(BlendMode.Subtract).operation).toBe('reverse-subtract');
   });
 
   it('falls back to normal blend for shader-composited modes', async () => {
@@ -95,12 +92,12 @@ describe('getWgpuPipeline', () => {
         ...(getWgpuPipeline(state, mode, 'normal') as unknown as { __descriptor: GPURenderPipelineDescriptor })
           .__descriptor.fragment!.targets,
       ][0]!.blend!.color;
-    expect(blendOf(BlendMode.Overlay)).toEqual({
+    expect(blendOf(AdvancedBlendMode.Overlay)).toEqual({
       srcFactor: 'one',
       dstFactor: 'one-minus-src-alpha',
       operation: 'add',
     });
-    expect(blendOf(BlendMode.HardLight)).toEqual({
+    expect(blendOf(AdvancedBlendMode.HardLight)).toEqual({
       srcFactor: 'one',
       dstFactor: 'one-minus-src-alpha',
       operation: 'add',

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();
+  });
+});