@flighthq/scene2d-wgpu 0.5.1-next.1069.554a2ac → 0.5.1-next.1201.9b49dee

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (47) hide show
  1. package/README.md +2 -2
  2. package/dist/wgpuCache.d.ts +4 -4
  3. package/dist/wgpuCache.d.ts.map +1 -1
  4. package/dist/wgpuCache.js +11 -11
  5. package/dist/wgpuCache.js.map +1 -1
  6. package/dist/wgpuClipContours.d.ts.map +1 -1
  7. package/dist/wgpuClipContours.js +3 -4
  8. package/dist/wgpuClipContours.js.map +1 -1
  9. package/dist/wgpuClipRectangle.js +3 -4
  10. package/dist/wgpuClipRectangle.js.map +1 -1
  11. package/dist/wgpuNode2D.d.ts +2 -2
  12. package/dist/wgpuNode2D.d.ts.map +1 -1
  13. package/dist/wgpuNode2D.js +4 -1
  14. package/dist/wgpuNode2D.js.map +1 -1
  15. package/dist/wgpuParticleEmitter2D.js +3 -3
  16. package/dist/wgpuParticleEmitter2D.js.map +1 -1
  17. package/dist/wgpuQuadBatchWriter.js +3 -3
  18. package/dist/wgpuQuadBatchWriter.js.map +1 -1
  19. package/dist/wgpuShapeMesh.js +2 -3
  20. package/dist/wgpuShapeMesh.js.map +1 -1
  21. package/dist/wgpuVelocity.d.ts +4 -4
  22. package/dist/wgpuVelocity.d.ts.map +1 -1
  23. package/dist/wgpuVelocity.js +11 -9
  24. package/dist/wgpuVelocity.js.map +1 -1
  25. package/package.json +20 -20
  26. package/src/wgpuBitmapText.test.ts +3 -3
  27. package/src/wgpuCache.test.ts +25 -28
  28. package/src/wgpuClipContours.test.ts +9 -2
  29. package/src/wgpuClipRectangle.test.ts +7 -7
  30. package/src/wgpuColorAdjustmentMaterialFeature.test.ts +3 -3
  31. package/src/wgpuMeshShapeRenderer.test.ts +11 -7
  32. package/src/wgpuNode2D.test.ts +6 -6
  33. package/src/wgpuParticleEmitter2D.test.ts +21 -7
  34. package/src/wgpuQuadBatch.test.ts +10 -10
  35. package/src/wgpuQuadBatchWriter.test.ts +19 -19
  36. package/src/wgpuRasterShapeRenderer.test.ts +26 -8
  37. package/src/wgpuRichText.test.ts +30 -12
  38. package/src/wgpuScale9Shape.test.ts +24 -9
  39. package/src/wgpuScale9Sprite.test.ts +7 -7
  40. package/src/wgpuShape.test.ts +30 -16
  41. package/src/wgpuShapeData.test.ts +15 -1
  42. package/src/wgpuShapeMesh.test.ts +9 -2
  43. package/src/wgpuSprite.test.ts +13 -13
  44. package/src/wgpuTextInput.test.ts +3 -3
  45. package/src/wgpuTextLabel.test.ts +28 -14
  46. package/src/wgpuTilemap.test.ts +3 -3
  47. package/src/wgpuVelocity.test.ts +5 -5
@@ -1,6 +1,10 @@
1
- import { createImageResource } from '@flighthq/image/contract';
1
+ import {
2
+ createImageResource,
3
+ registerTestImageDimensionResolver,
4
+ unregisterTestImageDimensionResolver,
5
+ } from '@flighthq/image/contract';
2
6
  import * as flightNode from '@flighthq/node/contract';
3
- import { renderWgpuBackground, submitWgpuRenderPass } from '@flighthq/render-wgpu/contract';
7
+ import { beginWgpuScreenRenderPassForTest, submitWgpuFrame } from '@flighthq/render-wgpu/contract';
4
8
  import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu/contract';
5
9
  import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
6
10
  import {
@@ -21,6 +25,16 @@ import { defaultWgpuMorphShapeRenderer, defaultWgpuShapeRenderer, drawWgpuShape
21
25
  import { registerWgpuShapeRasterizer } from './wgpuShapeRasterizer';
22
26
  import { registerWgpuStandardMaterial } from './wgpuStandardMaterial';
23
27
 
28
+ // A test that wraps a host handle supplies the host: the resource measures through the registered
29
+ // resolver, and clearing after each test keeps this file from covering for another's missing one.
30
+ beforeEach(() => {
31
+ registerTestImageDimensionResolver();
32
+ });
33
+
34
+ afterEach(() => {
35
+ unregisterTestImageDimensionResolver();
36
+ });
37
+
24
38
  const noopRasterizer = (): void => {};
25
39
 
26
40
  beforeAll(() => installWgpuMock());
@@ -142,7 +156,7 @@ describe('drawWgpuShape', () => {
142
156
  const state = await createWgpuRenderStateForTest();
143
157
  state.raster2DSurfaceProvider = createTestRaster2DSurfaceProvider();
144
158
  registerWgpuShapeRasterizer(state, noopRasterizer);
145
- renderWgpuBackground(state);
159
+ beginWgpuScreenRenderPassForTest(state);
146
160
  getWgpuRenderStateRuntime(state).renderPass = makeMeshPassSpy();
147
161
  const shape = createShape();
148
162
  appendShapeBeginFill(shape, 0x00cc00ff);
@@ -160,7 +174,7 @@ describe('drawWgpuShape', () => {
160
174
  };
161
175
  expect(pass.drawIndexed).toHaveBeenCalledTimes(2);
162
176
  expect(getWgpuRenderStateRuntime(state).quadBatchWriterCount).toBe(0);
163
- submitWgpuRenderPass(state);
177
+ submitWgpuFrame(state);
164
178
  });
165
179
 
166
180
  it('draws a closed solid stroke ring as one GPU mesh', async () => {
@@ -168,7 +182,7 @@ describe('drawWgpuShape', () => {
168
182
  state.raster2DSurfaceProvider = createTestRaster2DSurfaceProvider();
169
183
  registerWgpuShapeRasterizer(state, noopRasterizer);
170
184
  enableWgpuStrokePathTessellation(state);
171
- renderWgpuBackground(state);
185
+ beginWgpuScreenRenderPassForTest(state);
172
186
  getWgpuRenderStateRuntime(state).renderPass = makeMeshPassSpy();
173
187
  const shape = createShape();
174
188
  appendShapeLineStyle(shape, 8, 0xff0000ff);
@@ -182,14 +196,14 @@ describe('drawWgpuShape', () => {
182
196
  };
183
197
  expect(pass.drawIndexed).toHaveBeenCalledTimes(1);
184
198
  expect(getWgpuRenderStateRuntime(state).quadBatchWriterCount).toBe(0);
185
- submitWgpuRenderPass(state);
199
+ submitWgpuFrame(state);
186
200
  });
187
201
 
188
202
  it('keeps a closed stroke on the raster lane until stroke-path tessellation is enabled', async () => {
189
203
  const state = await createWgpuRenderStateForTest();
190
204
  state.raster2DSurfaceProvider = createTestRaster2DSurfaceProvider();
191
205
  registerWgpuShapeRasterizer(state, noopRasterizer);
192
- renderWgpuBackground(state);
206
+ beginWgpuScreenRenderPassForTest(state);
193
207
  registerWgpuStandardMaterial(state);
194
208
  const pass = makeMeshPassSpy();
195
209
  getWgpuRenderStateRuntime(state).renderPass = pass;
@@ -202,7 +216,7 @@ describe('drawWgpuShape', () => {
202
216
 
203
217
  expect(pass.drawIndexed).not.toHaveBeenCalled();
204
218
  expect(getWgpuRenderStateRuntime(state).quadBatchWriterCount).toBe(1);
205
- submitWgpuRenderPass(state);
219
+ submitWgpuFrame(state);
206
220
  });
207
221
 
208
222
  it('falls back to the raster quad for a self-intersecting stroke centerline', async () => {
@@ -210,7 +224,7 @@ describe('drawWgpuShape', () => {
210
224
  state.raster2DSurfaceProvider = createTestRaster2DSurfaceProvider();
211
225
  registerWgpuShapeRasterizer(state, noopRasterizer);
212
226
  enableWgpuStrokePathTessellation(state);
213
- renderWgpuBackground(state);
227
+ beginWgpuScreenRenderPassForTest(state);
214
228
  registerWgpuStandardMaterial(state);
215
229
  const pass = makeMeshPassSpy();
216
230
  getWgpuRenderStateRuntime(state).renderPass = pass;
@@ -241,29 +255,29 @@ describe('drawWgpuShape', () => {
241
255
  expect(getWgpuRenderStateRuntime(state).quadBatchWriterCount).toBe(2);
242
256
  expect(setWidth).not.toHaveBeenCalled();
243
257
  expect(setHeight).not.toHaveBeenCalled();
244
- submitWgpuRenderPass(state);
258
+ submitWgpuFrame(state);
245
259
  });
246
260
 
247
261
  it('returns early without writing to batch when commands are empty', async () => {
248
262
  const state = await createWgpuRenderStateForTest();
249
263
  state.raster2DSurfaceProvider = createTestRaster2DSurfaceProvider();
250
264
  registerWgpuShapeRasterizer(state, noopRasterizer);
251
- renderWgpuBackground(state);
265
+ beginWgpuScreenRenderPassForTest(state);
252
266
  registerWgpuStandardMaterial(state);
253
267
  drawWgpuShape(state, makeShapeProxy({ commands: [] }, makeShapeData()));
254
268
  expect(getWgpuRenderStateRuntime(state).quadBatchWriterCount).toBe(0);
255
- submitWgpuRenderPass(state);
269
+ submitWgpuFrame(state);
256
270
  });
257
271
 
258
272
  it('returns early without writing to batch when rendererData is null', async () => {
259
273
  const state = await createWgpuRenderStateForTest();
260
274
  state.raster2DSurfaceProvider = createTestRaster2DSurfaceProvider();
261
275
  registerWgpuShapeRasterizer(state, noopRasterizer);
262
- renderWgpuBackground(state);
276
+ beginWgpuScreenRenderPassForTest(state);
263
277
  registerWgpuStandardMaterial(state);
264
278
  drawWgpuShape(state, makeShapeProxy({ commands: [{}] }, null));
265
279
  expect(getWgpuRenderStateRuntime(state).quadBatchWriterCount).toBe(0);
266
- submitWgpuRenderPass(state);
280
+ submitWgpuFrame(state);
267
281
  });
268
282
 
269
283
  it('does not throw when renderPass is null', async () => {
@@ -277,10 +291,10 @@ describe('drawWgpuShape', () => {
277
291
  const state = await createWgpuRenderStateForTest();
278
292
  state.raster2DSurfaceProvider = createTestRaster2DSurfaceProvider();
279
293
  registerWgpuShapeRasterizer(state, noopRasterizer);
280
- renderWgpuBackground(state);
294
+ beginWgpuScreenRenderPassForTest(state);
281
295
  registerWgpuStandardMaterial(state);
282
296
  drawWgpuShape(state, makeShapeProxy({ commands: [{}], version: 1 }, makeShapeData()));
283
297
  expect(getWgpuRenderStateRuntime(state).quadBatchWriterCount).toBe(1);
284
- submitWgpuRenderPass(state);
298
+ submitWgpuFrame(state);
285
299
  });
286
300
  });
@@ -1,5 +1,9 @@
1
1
  import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
2
- import { createImageResource } from '@flighthq/image/contract';
2
+ import {
3
+ createImageResource,
4
+ registerTestImageDimensionResolver,
5
+ unregisterTestImageDimensionResolver,
6
+ } from '@flighthq/image/contract';
3
7
  import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu/contract';
4
8
  import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
5
9
  import type { WgpuShapeRendererData } from '@flighthq/types/contract';
@@ -12,6 +16,16 @@ import {
12
16
  getWgpuShapeData,
13
17
  } from './wgpuShapeData';
14
18
 
19
+ // A test that wraps a host handle supplies the host: the resource measures through the registered
20
+ // resolver, and clearing after each test keeps this file from covering for another's missing one.
21
+ beforeEach(() => {
22
+ registerTestImageDimensionResolver();
23
+ });
24
+
25
+ afterEach(() => {
26
+ unregisterTestImageDimensionResolver();
27
+ });
28
+
15
29
  const destroySurface = vi.fn();
16
30
 
17
31
  beforeAll(() => {
@@ -1,6 +1,10 @@
1
1
  import { createMatrix } from '@flighthq/geometry/contract';
2
- import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu/contract';
3
- import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
2
+ import {
3
+ beginWgpuScreenRenderPassForTest,
4
+ createWgpuRenderStateForTest,
5
+ getWgpuRenderStateRuntime,
6
+ installWgpuMock,
7
+ } from '@flighthq/render-wgpu/contract';
4
8
  import type {
5
9
  ColorScaleBias,
6
10
  RenderProxy2D,
@@ -83,8 +87,11 @@ function ct(
83
87
  } as ColorScaleBias;
84
88
  }
85
89
 
90
+ // A real screen pass, with its encoder swapped for a spy: the draw path reads the pass viewport for its
91
+ // projection, so a state with only a fake encoder attached has no coordinate space to draw into.
86
92
  async function makeState(): Promise<WgpuRenderState> {
87
93
  const state = await createWgpuRenderStateForTest();
94
+ beginWgpuScreenRenderPassForTest(state);
88
95
  getWgpuRenderStateRuntime(state).renderPass = makePassSpy();
89
96
  return state;
90
97
  }
@@ -1,11 +1,11 @@
1
1
  import {
2
+ beginWgpuScreenRenderPassForTest,
2
3
  createWgpuRenderStateForTest,
3
4
  getWgpuRenderStateRuntime,
4
5
  installWgpuMock,
5
6
  registerWgpuRenderTextureResolver,
6
7
  renderIntoWgpuRenderTexture,
7
- renderWgpuBackground,
8
- submitWgpuRenderPass,
8
+ submitWgpuFrame,
9
9
  } from '@flighthq/render-wgpu/contract';
10
10
  import { getOrCreateRenderProxy2D, prepareScene2DRender } from '@flighthq/render/contract';
11
11
  import { createSprite } from '@flighthq/scene2d/contract';
@@ -36,7 +36,7 @@ async function drawSpriteOverNewTexture(
36
36
  colorScaleBias: unknown,
37
37
  ): Promise<void> {
38
38
  const texture = createRenderTexture({ height: size, width: size });
39
- renderIntoWgpuRenderTexture(state, texture, () => {});
39
+ renderIntoWgpuRenderTexture(state, texture, () => {}, { color: [0, 0, 0, 0], depth: 1.0, stencil: 0 });
40
40
  const sprite = createSprite({ data: { texture } });
41
41
  prepareScene2DRender(state, sprite);
42
42
  const proxy = getOrCreateRenderProxy2D(state, sprite);
@@ -57,16 +57,16 @@ describe('defaultWgpuSpriteRenderer', () => {
57
57
  describe('drawWgpuSprite', () => {
58
58
  it('accepts an unbound sprite', async () => {
59
59
  const state = await createWgpuRenderStateForTest();
60
- renderWgpuBackground(state);
60
+ beginWgpuScreenRenderPassForTest(state);
61
61
  const sprite = createSprite();
62
62
  prepareScene2DRender(state, sprite);
63
63
  expect(() => drawWgpuSprite(state, getOrCreateRenderProxy2D(state, sprite))).not.toThrow();
64
- submitWgpuRenderPass(state);
64
+ submitWgpuFrame(state);
65
65
  });
66
66
 
67
67
  it('records a tint against the instance the flush uploads when a new texture breaks the batch', async () => {
68
68
  const state = await createWgpuRenderStateForTest();
69
- renderWgpuBackground(state);
69
+ beginWgpuScreenRenderPassForTest(state);
70
70
  registerWgpuRenderTextureResolver(state);
71
71
  registerWgpuStandardMaterial(state);
72
72
  registerWgpuColorAdjustmentMaterialFeature(state);
@@ -79,17 +79,17 @@ describe('drawWgpuSprite', () => {
79
79
 
80
80
  expect(runtime.quadBatchWriterCount).toBe(1);
81
81
  expect(runtime.quadBatchWriterColorScaleBiasMode).toBe(CT_MODE_UNIFORM);
82
- submitWgpuRenderPass(state);
82
+ submitWgpuFrame(state);
83
83
  });
84
84
 
85
85
  it('uses the physical slab once and preserves a top-origin render-target sub-view', async () => {
86
86
  const state = await createWgpuRenderStateForTest();
87
- renderWgpuBackground(state);
87
+ beginWgpuScreenRenderPassForTest(state);
88
88
  registerWgpuRenderTextureResolver(state);
89
89
  registerWgpuStandardMaterial(state);
90
90
  const renderTexture = createRenderTexture({ height: 480, width: 720 });
91
91
  setTextureUvFromPixelRect(renderTexture, 140, 160, 100, 80);
92
- renderIntoWgpuRenderTexture(state, renderTexture, () => {});
92
+ renderIntoWgpuRenderTexture(state, renderTexture, () => {}, { color: [0, 0, 0, 0], depth: 1.0, stencil: 0 });
93
93
  const sprite = createSprite({ data: { texture: renderTexture } });
94
94
  prepareScene2DRender(state, sprite);
95
95
 
@@ -102,16 +102,16 @@ describe('drawWgpuSprite', () => {
102
102
  expect(data[7]).toBeCloseTo(160 / 480);
103
103
  expect(data[8]).toBeCloseTo(100 / 720);
104
104
  expect(data[11]).toBeCloseTo(80 / 480);
105
- submitWgpuRenderPass(state);
105
+ submitWgpuFrame(state);
106
106
  });
107
107
 
108
108
  it('packs a quarter-turned Texture view as affine UV axes', async () => {
109
109
  const state = await createWgpuRenderStateForTest();
110
- renderWgpuBackground(state);
110
+ beginWgpuScreenRenderPassForTest(state);
111
111
  registerWgpuRenderTextureResolver(state);
112
112
  registerWgpuStandardMaterial(state);
113
113
  const texture = createRenderTexture({ height: 50, width: 100 });
114
- renderIntoWgpuRenderTexture(state, texture, () => {});
114
+ renderIntoWgpuRenderTexture(state, texture, () => {}, { color: [0, 0, 0, 0], depth: 1.0, stencil: 0 });
115
115
  texture.uvOffset.x = 0.1;
116
116
  texture.uvOffset.y = 0.4;
117
117
  texture.uvScale.x = 0.3;
@@ -131,6 +131,6 @@ describe('drawWgpuSprite', () => {
131
131
  expect(data[9]).toBeCloseTo(-0.3);
132
132
  expect(data[10]).toBeCloseTo(0.2);
133
133
  expect(data[11]).toBeCloseTo(0);
134
- submitWgpuRenderPass(state);
134
+ submitWgpuFrame(state);
135
135
  });
136
136
  });
@@ -1,4 +1,4 @@
1
- import { renderWgpuBackground, submitWgpuRenderPass } from '@flighthq/render-wgpu/contract';
1
+ import { beginWgpuScreenRenderPassForTest, submitWgpuFrame } from '@flighthq/render-wgpu/contract';
2
2
  import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
3
3
  import { getOrCreateRenderProxy2D, prepareScene2DRender } from '@flighthq/render/contract';
4
4
  import { createRichText } from '@flighthq/text/contract';
@@ -19,14 +19,14 @@ describe('drawWgpuTextInputOverlay', () => {
19
19
  it('rasterizes a focused editable field without throwing', async () => {
20
20
  enableWgpuTextInput();
21
21
  const state = await createWgpuRenderStateForTest();
22
- renderWgpuBackground(state);
22
+ beginWgpuScreenRenderPassForTest(state);
23
23
  const input = createRichText({ data: { height: 40, text: 'hi', width: 100 } });
24
24
  enableTextInput(input).focused = true;
25
25
  prepareScene2DRender(state, input);
26
26
  const renderProxy = getOrCreateRenderProxy2D(state, input);
27
27
 
28
28
  expect(() => drawWgpuRichText(state, renderProxy)).not.toThrow();
29
- submitWgpuRenderPass(state);
29
+ submitWgpuFrame(state);
30
30
  });
31
31
  });
32
32
 
@@ -1,5 +1,9 @@
1
- import { createImageResource } from '@flighthq/image/contract';
2
- import { renderWgpuBackground, submitWgpuRenderPass } from '@flighthq/render-wgpu/contract';
1
+ import {
2
+ createImageResource,
3
+ registerTestImageDimensionResolver,
4
+ unregisterTestImageDimensionResolver,
5
+ } from '@flighthq/image/contract';
6
+ import { beginWgpuScreenRenderPassForTest, submitWgpuFrame } from '@flighthq/render-wgpu/contract';
3
7
  import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu/contract';
4
8
  import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
5
9
  import { createTextLabel } from '@flighthq/text/contract';
@@ -10,6 +14,16 @@ import { BatchFormat, EntityRuntimeKey } from '@flighthq/types/contract';
10
14
  import { registerWgpuStandardMaterial } from './wgpuStandardMaterial';
11
15
  import { defaultWgpuTextLabelRenderer, drawWgpuTextLabel } from './wgpuTextLabel';
12
16
 
17
+ // A test that wraps a host handle supplies the host: the resource measures through the registered
18
+ // resolver, and clearing after each test keeps this file from covering for another's missing one.
19
+ beforeEach(() => {
20
+ registerTestImageDimensionResolver();
21
+ });
22
+
23
+ afterEach(() => {
24
+ unregisterTestImageDimensionResolver();
25
+ });
26
+
13
27
  beforeAll(() => installWgpuMock());
14
28
 
15
29
  // @flighthq/textlayout.computeTextLayout is stubbed to emit one deterministic glyph group.
@@ -109,7 +123,7 @@ describe('defaultWgpuTextLabelRenderer', () => {
109
123
  it('removes the GPU cache entry before returning the node surface to its creator', async () => {
110
124
  const order: string[] = [];
111
125
  const state = await createWgpuRenderStateForTest();
112
- renderWgpuBackground(state);
126
+ beginWgpuScreenRenderPassForTest(state);
113
127
  const cache = getWgpuRenderStateRuntime(state).context.textureSourcePremultipliedTextureCache;
114
128
  state.raster2DSurfaceProvider = createTestRaster2DSurfaceProvider((surface) => {
115
129
  order.push('surface');
@@ -120,7 +134,7 @@ describe('defaultWgpuTextLabelRenderer', () => {
120
134
  drawWgpuTextLabel(state, makeTextProxy('owned', data));
121
135
  const surface = (data as unknown as { surface: Raster2DSurface }).surface;
122
136
  const entry = cache.get(surface.image)!;
123
- submitWgpuRenderPass(state);
137
+ submitWgpuFrame(state);
124
138
  vi.spyOn(entry.texture, 'destroy').mockImplementation(() => {
125
139
  order.push('texture');
126
140
  });
@@ -136,7 +150,7 @@ describe('drawWgpuTextLabel', () => {
136
150
  it('keeps different text nodes on distinct surfaces and GPU textures in one frame', async () => {
137
151
  const state = await createWgpuRenderStateForTest();
138
152
  state.raster2DSurfaceProvider = createTestRaster2DSurfaceProvider();
139
- renderWgpuBackground(state);
153
+ beginWgpuScreenRenderPassForTest(state);
140
154
  registerWgpuStandardMaterial(state);
141
155
  const firstData = defaultWgpuTextLabelRenderer.createData!(state, createTextLabel())!;
142
156
  const secondData = defaultWgpuTextLabelRenderer.createData!(state, createTextLabel())!;
@@ -155,32 +169,32 @@ describe('drawWgpuTextLabel', () => {
155
169
  drawWgpuTextLabel(state, makeTextProxy('first', firstData));
156
170
  expect((firstData as unknown as { surface: Raster2DSurface }).surface).toBe(firstSurface);
157
171
  expect(firstSurface.image).toBe(firstImage);
158
- submitWgpuRenderPass(state);
172
+ submitWgpuFrame(state);
159
173
  });
160
174
 
161
175
  it('returns early when text is empty', async () => {
162
176
  const state = await createWgpuRenderStateForTest();
163
- renderWgpuBackground(state);
177
+ beginWgpuScreenRenderPassForTest(state);
164
178
  registerWgpuStandardMaterial(state);
165
179
  expect(() => drawWgpuTextLabel(state, makeTextProxy('', makeTextData()))).not.toThrow();
166
180
  expect(getWgpuRenderStateRuntime(state).quadBatchWriterCount).toBe(0);
167
- submitWgpuRenderPass(state);
181
+ submitWgpuFrame(state);
168
182
  });
169
183
 
170
184
  it('writes one instance to the quad-batch writer when text has content', async () => {
171
185
  const state = await createWgpuRenderStateForTest();
172
186
  state.raster2DSurfaceProvider = createTestRaster2DSurfaceProvider();
173
- renderWgpuBackground(state);
187
+ beginWgpuScreenRenderPassForTest(state);
174
188
  registerWgpuStandardMaterial(state);
175
189
  drawWgpuTextLabel(state, makeTextProxy('hello', makeTextData()));
176
190
  expect(getWgpuRenderStateRuntime(state).quadBatchWriterCount).toBe(1);
177
- submitWgpuRenderPass(state);
191
+ submitWgpuFrame(state);
178
192
  });
179
193
 
180
194
  it('rasterizes packed run alpha into the canvas color', async () => {
181
195
  const state = await createWgpuRenderStateForTest();
182
196
  state.raster2DSurfaceProvider = createTestRaster2DSurfaceProvider();
183
- renderWgpuBackground(state);
197
+ beginWgpuScreenRenderPassForTest(state);
184
198
  registerWgpuStandardMaterial(state);
185
199
  const data = makeTextData();
186
200
  const proxy = makeTextProxy('hello', data);
@@ -191,13 +205,13 @@ describe('drawWgpuTextLabel', () => {
191
205
  drawWgpuTextLabel(state, proxy);
192
206
 
193
207
  expect(styles).toEqual(['rgba(255, 0, 0, 0.5019607843137255)']);
194
- submitWgpuRenderPass(state);
208
+ submitWgpuFrame(state);
195
209
  });
196
210
 
197
211
  it('does not re-rasterize when only alpha changes (content version unchanged)', async () => {
198
212
  const state = await createWgpuRenderStateForTest();
199
213
  state.raster2DSurfaceProvider = createTestRaster2DSurfaceProvider();
200
- renderWgpuBackground(state);
214
+ beginWgpuScreenRenderPassForTest(state);
201
215
  registerWgpuStandardMaterial(state);
202
216
  const proxy = makeTextProxy('hello', makeTextData());
203
217
  drawWgpuTextLabel(state, proxy);
@@ -206,7 +220,7 @@ describe('drawWgpuTextLabel', () => {
206
220
  drawWgpuTextLabel(state, proxy);
207
221
  // Version is unchanged, so the rasterization block is skipped entirely on the second draw.
208
222
  expect((proxy.rendererData as any).lastContentId).toBe(0);
209
- submitWgpuRenderPass(state);
223
+ submitWgpuFrame(state);
210
224
  updateSpy.mockRestore();
211
225
  });
212
226
  });
@@ -1,4 +1,4 @@
1
- import { renderWgpuBackground, submitWgpuRenderPass } from '@flighthq/render-wgpu/contract';
1
+ import { beginWgpuScreenRenderPassForTest, submitWgpuFrame } from '@flighthq/render-wgpu/contract';
2
2
  import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
3
3
  import { getRenderProxy2D, prepareScene2DRender } from '@flighthq/render/contract';
4
4
  import { createTilemap } from '@flighthq/tilemap/contract';
@@ -23,7 +23,7 @@ describe('defaultWgpuTilemapRenderer', () => {
23
23
  describe('defaultWgpuTilemapRenderer.submit', () => {
24
24
  it('does not throw when atlas is null', async () => {
25
25
  const state = await createWgpuRenderStateForTest();
26
- renderWgpuBackground(state);
26
+ beginWgpuScreenRenderPassForTest(state);
27
27
 
28
28
  const tilemap = createTilemap();
29
29
  prepareScene2DRender(state, tilemap);
@@ -33,7 +33,7 @@ describe('defaultWgpuTilemapRenderer.submit', () => {
33
33
  defaultWgpuTilemapRenderer.submit(state, renderProxy);
34
34
  flushWgpuQuadBatchWriter(state as any);
35
35
  }).not.toThrow();
36
- submitWgpuRenderPass(state);
36
+ submitWgpuFrame(state);
37
37
  });
38
38
 
39
39
  it('does not throw when renderPass is null', async () => {
@@ -1,10 +1,10 @@
1
1
  import { createParticleEmitter2D, reserveParticleEmitter2D } from '@flighthq/particleemitter/contract';
2
2
  import { createQuadBatch, getQuadBatchRuntime } from '@flighthq/quadbatch/contract';
3
3
  import {
4
+ beginWgpuScreenRenderPassForTest,
4
5
  createWgpuOffscreenRenderState,
5
6
  createWgpuPipeline,
6
7
  getWgpuRenderStateRuntime,
7
- renderWgpuBackground,
8
8
  } from '@flighthq/render-wgpu/contract';
9
9
  import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
10
10
  import { createDisplayObject } from '@flighthq/scene2d/contract';
@@ -67,7 +67,7 @@ describe('defaultWgpuParticleEmitter2DVelocityWriter', () => {
67
67
  const field = createVelocityField();
68
68
  beginVelocityFrame(field);
69
69
 
70
- renderWgpuBackground(state);
70
+ beginWgpuScreenRenderPassForTest(state);
71
71
  expect(() => renderWgpuVelocity(state, emitter, field, target)).not.toThrow();
72
72
  });
73
73
  });
@@ -97,7 +97,7 @@ describe('defaultWgpuQuadBatchVelocityWriter', () => {
97
97
  const field = createVelocityField();
98
98
  beginVelocityFrame(field);
99
99
 
100
- renderWgpuBackground(state);
100
+ beginWgpuScreenRenderPassForTest(state);
101
101
  expect(() => renderWgpuVelocity(state, batch, field, target)).not.toThrow();
102
102
  });
103
103
  });
@@ -159,11 +159,11 @@ describe('renderWgpuVelocity', () => {
159
159
  beginVelocityFrame(field);
160
160
  contributeVelocity(field, root, 3, -2);
161
161
 
162
- renderWgpuBackground(state);
162
+ beginWgpuScreenRenderPassForTest(state);
163
163
  expect(() => renderWgpuVelocity(state, root, field, target)).not.toThrow();
164
164
  });
165
165
 
166
- it('throws when no command encoder is open (renderWgpuBackground not called)', async () => {
166
+ it('throws when no command encoder is open (no pass has opened one)', async () => {
167
167
  const state = await createWgpuRenderStateForTest();
168
168
  const target = createWgpuVelocityTarget(state, 128, 64);
169
169
  const root = createDisplayObject();