@flighthq/scene2d-wgpu 0.2.1-next.840.857425c

package/src/wgpuTextLabel.test.ts

@@ -0,0 +1,124 @@
+import { createImageResource } from '@flighthq/image';
+import { renderWgpuBackground, submitWgpuRenderPass } from '@flighthq/render-wgpu';
+import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu';
+import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu';
+import { createTextLabel } from '@flighthq/text';
+import type { RenderProxy2D } from '@flighthq/types';
+import { BatchFormat } from '@flighthq/types';
+
+import { scopeModuleMocks } from './moduleMockTestHelper';
+import { registerDefaultWgpuMaterial } from './wgpuDefaultMaterial';
+import type * as WgpuTextLabelModule from './wgpuTextLabel';
+
+// @flighthq/textlayout.computeTextLayout is stubbed to emit one deterministic glyph group.
+// scopeModuleMocks scopes the stub to this file (registry reset before the mock applies, unmock +
+// reset after), so under a shared (isolate:false) worker it never leaks into the real text-layout
+// consumers (text package) — and a sibling that pre-evaluated ./wgpuTextLabel still picks up the stub.
+let defaultWgpuTextLabelRenderer: typeof WgpuTextLabelModule.defaultWgpuTextLabelRenderer;
+let drawWgpuTextLabel: typeof WgpuTextLabelModule.drawWgpuTextLabel;
+
+scopeModuleMocks(['@flighthq/textlayout']);
+
+beforeAll(async () => {
+  vi.doMock('@flighthq/textlayout', async (importOriginal) => {
+    const actual = (await importOriginal()) as Record<string, unknown>;
+    return {
+      ...actual,
+      computeTextLayout: vi.fn((result: { groups: object[] }) => {
+        result.groups.push({
+          offsetX: 0,
+          offsetY: 0,
+          width: 50,
+          ascent: 12,
+          descent: 4,
+          format: {},
+          startIndex: 0,
+          endIndex: 5,
+        });
+      }),
+    };
+  });
+  ({ defaultWgpuTextLabelRenderer, drawWgpuTextLabel } = await import('./wgpuTextLabel'));
+  installWgpuMock();
+});
+
+function makeTextData() {
+  const canvas = document.createElement('canvas');
+  canvas.width = 1;
+  canvas.height = 1;
+  const ctx = canvas.getContext('2d')!;
+  return {
+    canvas,
+    ctx,
+    image: createImageResource(canvas),
+    lastContentId: -1,
+    lastPixelRatio: 0,
+    logW: 0,
+    logH: 0,
+    lastPW: 0,
+    lastPH: 0,
+  };
+}
+
+function makeTextProxy(text = '', rendererData: unknown = null): RenderProxy2D {
+  const source = createTextLabel();
+  source.data.text = text;
+  source.data.textFormat = {};
+  source.data.width = 200;
+  source.data.height = 100;
+  return {
+    source,
+    blendMode: 0,
+    alpha: 1,
+    material: null,
+    materialData: null,
+    transform2D: { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 },
+    rendererData,
+  } as unknown as RenderProxy2D;
+}
+
+describe('defaultWgpuTextLabelRenderer', () => {
+  it('declares BatchFormat.Quad', () => {
+    expect(defaultWgpuTextLabelRenderer.format).toBe(BatchFormat.Quad);
+  });
+
+  it('has createData and submit functions', () => {
+    expect(typeof defaultWgpuTextLabelRenderer.createData).toBe('function');
+    expect(typeof defaultWgpuTextLabelRenderer.submit).toBe('function');
+  });
+});
+
+describe('drawWgpuTextLabel', () => {
+  it('returns early when text is empty', async () => {
+    const state = await createWgpuRenderStateForTest();
+    renderWgpuBackground(state);
+    registerDefaultWgpuMaterial(state);
+    expect(() => drawWgpuTextLabel(state, makeTextProxy('', makeTextData()))).not.toThrow();
+    expect(getWgpuRenderStateRuntime(state).spriteBatchCount).toBe(0);
+    submitWgpuRenderPass(state);
+  });
+
+  it('writes one instance to the sprite batch when text has content', async () => {
+    const state = await createWgpuRenderStateForTest();
+    renderWgpuBackground(state);
+    registerDefaultWgpuMaterial(state);
+    drawWgpuTextLabel(state, makeTextProxy('hello', makeTextData()));
+    expect(getWgpuRenderStateRuntime(state).spriteBatchCount).toBe(1);
+    submitWgpuRenderPass(state);
+  });
+
+  it('does not re-rasterize when only alpha changes (content version unchanged)', async () => {
+    const state = await createWgpuRenderStateForTest();
+    renderWgpuBackground(state);
+    registerDefaultWgpuMaterial(state);
+    const proxy = makeTextProxy('hello', makeTextData());
+    drawWgpuTextLabel(state, proxy);
+    const updateSpy = vi.spyOn(getWgpuRenderStateRuntime(state).textureCache, 'get');
+    proxy.alpha = 0.5;
+    drawWgpuTextLabel(state, proxy);
+    // Version is unchanged, so the rasterization block is skipped entirely on the second draw.
+    expect((proxy.rendererData as any).lastContentId).toBe(0);
+    submitWgpuRenderPass(state);
+    updateSpy.mockRestore();
+  });
+});

package/src/wgpuTilemap.test.ts

@@ -0,0 +1,47 @@
+import { getRenderProxy2D, prepareScene2DRender } from '@flighthq/render';
+import { renderWgpuBackground, submitWgpuRenderPass } from '@flighthq/render-wgpu';
+import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu';
+import { createTilemap } from '@flighthq/sprite';
+
+import { flushWgpuSpriteBatch } from './wgpuSpriteBatch';
+import { defaultWgpuTilemapRenderer } from './wgpuTilemap';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+describe('defaultWgpuTilemapRenderer', () => {
+  it('has a createData function', () => {
+    expect(typeof defaultWgpuTilemapRenderer.createData).toBe('function');
+  });
+
+  it('has a submit function', () => {
+    expect(typeof defaultWgpuTilemapRenderer.submit).toBe('function');
+  });
+});
+
+describe('defaultWgpuTilemapRenderer.submit', () => {
+  it('does not throw when tileset is null', async () => {
+    const state = await createWgpuRenderStateForTest();
+    renderWgpuBackground(state);
+
+    const tilemap = createTilemap();
+    prepareScene2DRender(state, tilemap);
+    const renderProxy = getRenderProxy2D(state, tilemap)!;
+
+    expect(() => {
+      defaultWgpuTilemapRenderer.submit(state, renderProxy);
+      flushWgpuSpriteBatch(state as any);
+    }).not.toThrow();
+    submitWgpuRenderPass(state);
+  });
+
+  it('does not throw when renderPass is null', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const tilemap = createTilemap();
+    prepareScene2DRender(state, tilemap);
+    const renderProxy = getRenderProxy2D(state, tilemap)!;
+
+    expect(() => defaultWgpuTilemapRenderer.submit(state, renderProxy)).not.toThrow();
+  });
+});

package/src/wgpuVelocity.test.ts

@@ -0,0 +1,148 @@
+import { createParticleEmitter2D, reserveParticleEmitter2D } from '@flighthq/particleemitter';
+import { renderWgpuBackground } from '@flighthq/render-wgpu';
+import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu';
+import { createDisplayObject } from '@flighthq/scene2d';
+import { createQuadBatch, getQuadBatchRuntime } from '@flighthq/sprite';
+import type { QuadBatchRuntime, TextureAtlas, TextureAtlasRegion } from '@flighthq/types';
+import { QuadBatchKind } from '@flighthq/types';
+import { beginVelocityFrame, contributeVelocity, createVelocityField } from '@flighthq/velocity';
+import { beforeAll, describe, expect, it } from 'vitest';
+
+import {
+  createWgpuVelocityTarget,
+  defaultWgpuNode2DVelocityWriter,
+  defaultWgpuParticleEmitter2DVelocityWriter,
+  defaultWgpuQuadBatchVelocityWriter,
+  drawWgpuVelocityQuad,
+  getWgpuVelocityWriter,
+  registerWgpuVelocityWriter,
+  renderWgpuVelocity,
+} from './wgpuVelocity';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+describe('createWgpuVelocityTarget', () => {
+  it('allocates an rgba16float target at the requested size', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const target = createWgpuVelocityTarget(state, 128, 64);
+    expect(target.format).toBe('rgba16float');
+    expect(target.width).toBe(128);
+    expect(target.height).toBe(64);
+  });
+});
+
+describe('defaultWgpuNode2DVelocityWriter', () => {
+  it('is a velocity writer function', () => {
+    expect(typeof defaultWgpuNode2DVelocityWriter).toBe('function');
+  });
+});
+
+describe('defaultWgpuParticleEmitter2DVelocityWriter', () => {
+  it('is a velocity writer function', () => {
+    expect(typeof defaultWgpuParticleEmitter2DVelocityWriter).toBe('function');
+  });
+
+  it('emits per-particle velocity for an emitter with a velocities array without throwing', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const target = createWgpuVelocityTarget(state, 128, 64);
+    const region = { id: 0, x: 0, y: 0, width: 16, height: 16, pivotX: null, pivotY: null } as TextureAtlasRegion;
+    const atlas = { image: null, regions: [region] } as TextureAtlas;
+    const emitter = createParticleEmitter2D();
+    reserveParticleEmitter2D(emitter, 2);
+    emitter.data.atlas = atlas;
+    emitter.data.particleCount = 2;
+    emitter.data.ids[0] = 0;
+    emitter.data.ids[1] = 0;
+    emitter.data.transforms.set([10, 10, 0, 1, 40, 20, 0, 1]);
+    emitter.data.velocities.set([3, -2, -1, 4]);
+
+    registerWgpuVelocityWriter(state, emitter.kind, defaultWgpuParticleEmitter2DVelocityWriter);
+    const field = createVelocityField();
+    beginVelocityFrame(field);
+
+    renderWgpuBackground(state);
+    expect(() => renderWgpuVelocity(state, emitter, field, target)).not.toThrow();
+  });
+});
+
+describe('defaultWgpuQuadBatchVelocityWriter', () => {
+  it('is a velocity writer function', () => {
+    expect(typeof defaultWgpuQuadBatchVelocityWriter).toBe('function');
+  });
+
+  it('emits per-instance velocity for a batch with an instanceVelocities array without throwing', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const target = createWgpuVelocityTarget(state, 128, 64);
+    const region = { id: 0, x: 0, y: 0, width: 32, height: 32, pivotX: null, pivotY: null } as TextureAtlasRegion;
+    const atlas = { image: null, regions: [region] } as TextureAtlas;
+    const batch = createQuadBatch({
+      data: {
+        atlas,
+        ids: new Uint16Array([0, 0]),
+        instanceCount: 2,
+        transforms: new Float32Array([0, 0, 40, 10]),
+        transformType: 'vector2',
+      },
+    });
+    (getQuadBatchRuntime(batch) as QuadBatchRuntime).instanceVelocities = new Float32Array([3, -2, -1, 4]);
+
+    registerWgpuVelocityWriter(state, QuadBatchKind, defaultWgpuQuadBatchVelocityWriter);
+    const field = createVelocityField();
+    beginVelocityFrame(field);
+
+    renderWgpuBackground(state);
+    expect(() => renderWgpuVelocity(state, batch, field, target)).not.toThrow();
+  });
+});
+
+describe('drawWgpuVelocityQuad', () => {
+  it('is a no-op outside an active velocity pass', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const ctx = { state, field: createVelocityField(), width: 128, height: 64, pixelRatio: 1 };
+    expect(() => drawWgpuVelocityQuad(ctx, 0, 0, 10, 10, 1, 0)).not.toThrow();
+  });
+});
+
+describe('getWgpuVelocityWriter', () => {
+  it('returns null for an unregistered kind', async () => {
+    const state = await createWgpuRenderStateForTest();
+    expect(getWgpuVelocityWriter(state, 'unregistered')).toBeNull();
+  });
+});
+
+describe('registerWgpuVelocityWriter', () => {
+  it('registers a writer dispatched by kind', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const root = createDisplayObject();
+    registerWgpuVelocityWriter(state, root.kind, defaultWgpuNode2DVelocityWriter);
+    expect(getWgpuVelocityWriter(state, root.kind)).toBe(defaultWgpuNode2DVelocityWriter);
+  });
+});
+
+describe('renderWgpuVelocity', () => {
+  it('dispatches the registered writer for a moving node without throwing', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const target = createWgpuVelocityTarget(state, 128, 64);
+    const root = createDisplayObject();
+    registerWgpuVelocityWriter(state, root.kind, defaultWgpuNode2DVelocityWriter);
+
+    const field = createVelocityField();
+    beginVelocityFrame(field);
+    contributeVelocity(field, root, 3, -2);
+
+    renderWgpuBackground(state);
+    expect(() => renderWgpuVelocity(state, root, field, target)).not.toThrow();
+  });
+
+  it('throws when no command encoder is open (renderWgpuBackground not called)', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const target = createWgpuVelocityTarget(state, 128, 64);
+    const root = createDisplayObject();
+    const field = createVelocityField();
+    beginVelocityFrame(field);
+
+    expect(() => renderWgpuVelocity(state, root, field, target)).toThrow(/command encoder/);
+  });
+});

package/src/wgpuVideo.test.ts

@@ -0,0 +1,59 @@
+import { getOrCreateRenderProxy2D, prepareScene2DRender } from '@flighthq/render';
+import { renderWgpuBackground, submitWgpuRenderPass } from '@flighthq/render-wgpu';
+import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu';
+import { createVideo } from '@flighthq/scene2d';
+
+import { createWgpuVideoData, defaultWgpuVideoRenderer, destroyWgpuVideoData, drawWgpuVideo } from './wgpuVideo';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+describe('createWgpuVideoData', () => {
+  it('allocates per-node data with no texture entry yet', () => {
+    const data = createWgpuVideoData({} as never, {} as never) as unknown as { entry: unknown };
+    expect(data.entry).toBeNull();
+  });
+});
+
+describe('defaultWgpuVideoRenderer', () => {
+  it('has createData and submit functions', () => {
+    expect(typeof defaultWgpuVideoRenderer.createData).toBe('function');
+    expect(typeof defaultWgpuVideoRenderer.submit).toBe('function');
+  });
+});
+
+describe('destroyWgpuVideoData', () => {
+  it('destroys the GPU texture the node owns', () => {
+    const destroy = vi.fn();
+    destroyWgpuVideoData({} as never, { entry: { texture: { destroy } } } as never);
+    expect(destroy).toHaveBeenCalled();
+  });
+
+  it('is a no-op when no texture entry was allocated', () => {
+    expect(() => destroyWgpuVideoData({} as never, { entry: null } as never)).not.toThrow();
+  });
+});
+
+describe('drawWgpuVideo', () => {
+  it('does not throw when video source is null', async () => {
+    const state = await createWgpuRenderStateForTest();
+    renderWgpuBackground(state);
+
+    const video = createVideo();
+    prepareScene2DRender(state, video);
+    const renderProxy = getOrCreateRenderProxy2D(state, video);
+
+    expect(() => drawWgpuVideo(state, renderProxy)).not.toThrow();
+    submitWgpuRenderPass(state);
+  });
+
+  it('does not throw when renderPass is null', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const video = createVideo();
+    prepareScene2DRender(state, video);
+    const renderProxy = getOrCreateRenderProxy2D(state, video);
+
+    expect(() => drawWgpuVideo(state, renderProxy)).not.toThrow();
+  });
+});