@flighthq/render-wgpu 0.3.0-next.1220.6982c21 → 0.3.0-next.1272.222de94
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.
- package/dist/contract.d.ts +2 -1
- package/dist/contract.d.ts.map +1 -1
- package/dist/contract.js +2 -1
- package/dist/contract.js.map +1 -1
- package/dist/index.d.ts +1 -1
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +1 -1
- package/dist/index.js.map +1 -1
- package/dist/wgpuDraw.d.ts +3 -3
- package/dist/wgpuDraw.d.ts.map +1 -1
- package/dist/wgpuDraw.js +10 -1
- package/dist/wgpuDraw.js.map +1 -1
- package/dist/wgpuExternalImageSource.d.ts +2 -0
- package/dist/wgpuExternalImageSource.d.ts.map +1 -0
- package/dist/wgpuExternalImageSource.js +34 -0
- package/dist/wgpuExternalImageSource.js.map +1 -0
- package/dist/wgpuRenderState.d.ts +10 -1
- package/dist/wgpuRenderState.d.ts.map +1 -1
- package/dist/wgpuRenderState.js +182 -3
- package/dist/wgpuRenderState.js.map +1 -1
- package/dist/wgpuRenderTexture.d.ts +6 -1
- package/dist/wgpuRenderTexture.d.ts.map +1 -1
- package/dist/wgpuRenderTexture.js +70 -13
- package/dist/wgpuRenderTexture.js.map +1 -1
- package/dist/wgpuRenderTexturePool.d.ts +7 -0
- package/dist/wgpuRenderTexturePool.d.ts.map +1 -0
- package/dist/wgpuRenderTexturePool.js +85 -0
- package/dist/wgpuRenderTexturePool.js.map +1 -0
- package/dist/wgpuTestHelper.d.ts +1 -0
- package/dist/wgpuTestHelper.d.ts.map +1 -1
- package/dist/wgpuTestHelper.js +15 -1
- package/dist/wgpuTestHelper.js.map +1 -1
- package/dist/wgpuTextureUpload.d.ts.map +1 -1
- package/dist/wgpuTextureUpload.js +3 -0
- package/dist/wgpuTextureUpload.js.map +1 -1
- package/package.json +11 -11
- package/src/wgpuDraw.test.ts +53 -8
- package/src/wgpuExternalImageSource.test.ts +40 -0
- package/src/wgpuRenderState.test.ts +123 -0
- package/src/wgpuRenderTexture.test.ts +69 -0
- package/src/wgpuRenderTexturePool.test.ts +121 -0
- package/src/wgpuTextureUpload.test.ts +19 -0
|
@@ -1,4 +1,17 @@
|
|
|
1
|
+
import { createEntity } from '@flighthq/entity/contract';
|
|
1
2
|
import {
|
|
3
|
+
copyAllRenderersFromRenderState,
|
|
4
|
+
getRenderStateRuntime,
|
|
5
|
+
prepareScene2DRender,
|
|
6
|
+
registerRenderer,
|
|
7
|
+
} from '@flighthq/render/contract';
|
|
8
|
+
import { createDisplayObject } from '@flighthq/scene2d/contract';
|
|
9
|
+
|
|
10
|
+
import { beginWgpuFrame } from './wgpuBackground';
|
|
11
|
+
import { registerWgpuMaterialRenderer } from './wgpuMaterialRegistry';
|
|
12
|
+
import {
|
|
13
|
+
copyWgpuRenderStateRegistrations,
|
|
14
|
+
createWgpuOffscreenRenderState,
|
|
2
15
|
createWgpuRenderStateRuntime,
|
|
3
16
|
destroyWgpuRenderState,
|
|
4
17
|
getWgpuRenderStateRuntime,
|
|
@@ -6,11 +19,121 @@ import {
|
|
|
6
19
|
isWgpuSupported,
|
|
7
20
|
} from './wgpuRenderState';
|
|
8
21
|
import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
|
|
22
|
+
import { registerWgpuTextureResolver } from './wgpuTextureResolver';
|
|
9
23
|
|
|
10
24
|
beforeAll(() => {
|
|
11
25
|
installWgpuMock();
|
|
12
26
|
});
|
|
13
27
|
|
|
28
|
+
describe('copyWgpuRenderStateRegistrations', () => {
|
|
29
|
+
it('copies late Wgpu registrations only when explicitly requested', async () => {
|
|
30
|
+
const screen = await createWgpuRenderStateForTest();
|
|
31
|
+
const offscreen = createWgpuOffscreenRenderState(screen);
|
|
32
|
+
const resolver = vi.fn(() => null);
|
|
33
|
+
registerWgpuTextureResolver(screen, 'acme.LateTexture', resolver);
|
|
34
|
+
|
|
35
|
+
expect(getWgpuRenderStateRuntime(offscreen).wgpuTextureResolverRegistry?.has('acme.LateTexture')).not.toBe(true);
|
|
36
|
+
copyWgpuRenderStateRegistrations(offscreen, screen);
|
|
37
|
+
expect(getWgpuRenderStateRuntime(offscreen).wgpuTextureResolverRegistry?.get('acme.LateTexture')).toBe(resolver);
|
|
38
|
+
});
|
|
39
|
+
});
|
|
40
|
+
|
|
41
|
+
describe('createWgpuOffscreenRenderState', () => {
|
|
42
|
+
it('shares device resources while snapshotting independent registration policy', async () => {
|
|
43
|
+
const screen = await createWgpuRenderStateForTest();
|
|
44
|
+
const renderer = { createData: () => null, submit: vi.fn() };
|
|
45
|
+
const materialRenderer = { instanceFloatCount: 0, getShaderModule: vi.fn() } as never;
|
|
46
|
+
const paddingResolver = vi.fn(() => ({ bottom: 1, left: 1, right: 1, top: 1 }));
|
|
47
|
+
const textureResolver = vi.fn(() => null);
|
|
48
|
+
const effectRunner = vi.fn();
|
|
49
|
+
registerRenderer(screen, 'acme.Node', renderer);
|
|
50
|
+
registerWgpuMaterialRenderer(screen, 'acme.Material', materialRenderer);
|
|
51
|
+
registerWgpuTextureResolver(screen, 'acme.Texture', textureResolver);
|
|
52
|
+
getRenderStateRuntime(screen).renderEffectPaddingResolverRegistry = new Map([['acme.Effect', paddingResolver]]);
|
|
53
|
+
getWgpuRenderStateRuntime(screen).wgpuRenderEffectRegistry = new Map([['acme.Effect', effectRunner]]);
|
|
54
|
+
getWgpuRenderStateRuntime(screen).wgpuRenderTextureCache = new WeakMap();
|
|
55
|
+
|
|
56
|
+
const offscreen = createWgpuOffscreenRenderState(screen);
|
|
57
|
+
const screenRuntime = getWgpuRenderStateRuntime(screen);
|
|
58
|
+
const offscreenRuntime = getWgpuRenderStateRuntime(offscreen);
|
|
59
|
+
|
|
60
|
+
expect(offscreen.device).toBe(screen.device);
|
|
61
|
+
expect(offscreen.canvas).toBe(screen.canvas);
|
|
62
|
+
expect(offscreenRuntime.pipelineCache).toBe(screenRuntime.pipelineCache);
|
|
63
|
+
expect(offscreenRuntime.textureCache).toBe(screenRuntime.textureCache);
|
|
64
|
+
expect(offscreenRuntime.wgpuRenderTextureCache).toBe(screenRuntime.wgpuRenderTextureCache);
|
|
65
|
+
expect(offscreenRuntime.uniformBindGroupLayout).toBe(screenRuntime.uniformBindGroupLayout);
|
|
66
|
+
expect(offscreenRuntime.uniformBuffer).not.toBe(screenRuntime.uniformBuffer);
|
|
67
|
+
expect(offscreenRuntime.rendererMap).not.toBe(screenRuntime.rendererMap);
|
|
68
|
+
expect(offscreenRuntime.materialRendererMap).not.toBe(screenRuntime.materialRendererMap);
|
|
69
|
+
expect(offscreenRuntime.wgpuTextureResolverRegistry).not.toBe(screenRuntime.wgpuTextureResolverRegistry);
|
|
70
|
+
expect(offscreenRuntime.wgpuRenderEffectRegistry).not.toBe(screenRuntime.wgpuRenderEffectRegistry);
|
|
71
|
+
expect(offscreenRuntime.renderEffectPaddingResolverRegistry).not.toBe(
|
|
72
|
+
screenRuntime.renderEffectPaddingResolverRegistry,
|
|
73
|
+
);
|
|
74
|
+
expect(offscreenRuntime.rendererMap.get('acme.Node')).toBe(renderer);
|
|
75
|
+
expect(offscreenRuntime.materialRendererMap?.get('acme.Material')).toBe(materialRenderer);
|
|
76
|
+
expect(offscreenRuntime.wgpuTextureResolverRegistry?.get('acme.Texture')).toBe(textureResolver);
|
|
77
|
+
expect(offscreenRuntime.wgpuRenderEffectRegistry?.get('acme.Effect')).toBe(effectRunner);
|
|
78
|
+
expect(offscreenRuntime.renderEffectPaddingResolverRegistry?.get('acme.Effect')).toBe(paddingResolver);
|
|
79
|
+
});
|
|
80
|
+
|
|
81
|
+
it('owns an independent encoder and proxy tree', async () => {
|
|
82
|
+
const screen = await createWgpuRenderStateForTest();
|
|
83
|
+
const offscreen = createWgpuOffscreenRenderState(screen);
|
|
84
|
+
const root = createDisplayObject();
|
|
85
|
+
registerRenderer(offscreen, root.kind, { createData: () => createEntity({}), submit: vi.fn() });
|
|
86
|
+
prepareScene2DRender(offscreen, root);
|
|
87
|
+
beginWgpuFrame(screen);
|
|
88
|
+
beginWgpuFrame(offscreen);
|
|
89
|
+
|
|
90
|
+
expect(getRenderStateRuntime(offscreen).renderProxyMap).not.toBe(getRenderStateRuntime(screen).renderProxyMap);
|
|
91
|
+
expect(getWgpuRenderStateRuntime(offscreen).commandEncoder).not.toBe(
|
|
92
|
+
getWgpuRenderStateRuntime(screen).commandEncoder,
|
|
93
|
+
);
|
|
94
|
+
});
|
|
95
|
+
|
|
96
|
+
it('destroys derived renderer data and its own uniform ring without freeing the screen ring', async () => {
|
|
97
|
+
const screen = await createWgpuRenderStateForTest();
|
|
98
|
+
const root = createDisplayObject();
|
|
99
|
+
const destroyData = vi.fn();
|
|
100
|
+
registerRenderer(screen, root.kind, {
|
|
101
|
+
createData: () => createEntity({}),
|
|
102
|
+
destroyData,
|
|
103
|
+
submit: vi.fn(),
|
|
104
|
+
});
|
|
105
|
+
const offscreen = createWgpuOffscreenRenderState(screen);
|
|
106
|
+
prepareScene2DRender(offscreen, root);
|
|
107
|
+
const screenDestroy = vi.spyOn(getWgpuRenderStateRuntime(screen).uniformBuffer, 'destroy');
|
|
108
|
+
const offscreenDestroy = vi.spyOn(getWgpuRenderStateRuntime(offscreen).uniformBuffer, 'destroy');
|
|
109
|
+
|
|
110
|
+
destroyWgpuRenderState(offscreen);
|
|
111
|
+
|
|
112
|
+
expect(destroyData).toHaveBeenCalledOnce();
|
|
113
|
+
expect(offscreenDestroy).toHaveBeenCalledOnce();
|
|
114
|
+
expect(screenDestroy).not.toHaveBeenCalled();
|
|
115
|
+
});
|
|
116
|
+
|
|
117
|
+
it('requires explicit re-copy for renderers and padding registered after derivation', async () => {
|
|
118
|
+
const screen = await createWgpuRenderStateForTest();
|
|
119
|
+
const offscreen = createWgpuOffscreenRenderState(screen);
|
|
120
|
+
const renderer = { createData: () => null, submit: vi.fn() };
|
|
121
|
+
const paddingResolver = vi.fn(() => ({ bottom: 2, left: 2, right: 2, top: 2 }));
|
|
122
|
+
registerRenderer(screen, 'acme.LateNode', renderer);
|
|
123
|
+
getRenderStateRuntime(screen).renderEffectPaddingResolverRegistry = new Map([['acme.LateEffect', paddingResolver]]);
|
|
124
|
+
|
|
125
|
+
expect(getRenderStateRuntime(offscreen).rendererMap.has('acme.LateNode')).toBe(false);
|
|
126
|
+
expect(getRenderStateRuntime(offscreen).renderEffectPaddingResolverRegistry?.has('acme.LateEffect')).not.toBe(true);
|
|
127
|
+
|
|
128
|
+
copyAllRenderersFromRenderState(offscreen, screen);
|
|
129
|
+
copyWgpuRenderStateRegistrations(offscreen, screen);
|
|
130
|
+
expect(getRenderStateRuntime(offscreen).rendererMap.get('acme.LateNode')).toBe(renderer);
|
|
131
|
+
expect(getRenderStateRuntime(offscreen).renderEffectPaddingResolverRegistry?.get('acme.LateEffect')).toBe(
|
|
132
|
+
paddingResolver,
|
|
133
|
+
);
|
|
134
|
+
});
|
|
135
|
+
});
|
|
136
|
+
|
|
14
137
|
describe('createWgpuRenderState', () => {
|
|
15
138
|
it('returns a render state with device and context', async () => {
|
|
16
139
|
const state = await createWgpuRenderStateForTest();
|
|
@@ -6,8 +6,13 @@ import { getWgpuRenderStateRuntime } from './wgpuRenderState';
|
|
|
6
6
|
import {
|
|
7
7
|
bindWgpuRenderTexture,
|
|
8
8
|
destroyWgpuRenderTexture,
|
|
9
|
+
explainWgpuRenderTexture,
|
|
10
|
+
getWgpuRenderTextureTarget,
|
|
11
|
+
invalidateWgpuRenderTexture,
|
|
9
12
|
isWgpuRenderTextureReady,
|
|
10
13
|
renderIntoWgpuRenderTexture,
|
|
14
|
+
setWgpuRenderTextureGuard,
|
|
15
|
+
writeWgpuRenderTextureTarget,
|
|
11
16
|
} from './wgpuRenderTexture';
|
|
12
17
|
import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
|
|
13
18
|
|
|
@@ -66,6 +71,39 @@ describe('destroyWgpuRenderTexture', () => {
|
|
|
66
71
|
});
|
|
67
72
|
});
|
|
68
73
|
|
|
74
|
+
describe('explainWgpuRenderTexture', () => {
|
|
75
|
+
it('reports source dimensions and lifecycle status before allocation', async () => {
|
|
76
|
+
const state = await createWgpuRenderStateForTest();
|
|
77
|
+
expect(explainWgpuRenderTexture(state, texture())).toEqual({ height: 8, status: 'unrendered', width: 8 });
|
|
78
|
+
});
|
|
79
|
+
});
|
|
80
|
+
|
|
81
|
+
describe('getWgpuRenderTextureTarget', () => {
|
|
82
|
+
it('returns the hidden target only after a completed write', async () => {
|
|
83
|
+
const state = await createWgpuRenderStateForTest();
|
|
84
|
+
const renderTexture = texture();
|
|
85
|
+
|
|
86
|
+
expect(getWgpuRenderTextureTarget(state, renderTexture)).toBeNull();
|
|
87
|
+
writeWgpuRenderTextureTarget(state, renderTexture, () => {});
|
|
88
|
+
expect(getWgpuRenderTextureTarget(state, renderTexture)).not.toBeNull();
|
|
89
|
+
});
|
|
90
|
+
});
|
|
91
|
+
|
|
92
|
+
describe('invalidateWgpuRenderTexture', () => {
|
|
93
|
+
it('makes published content unavailable without destroying its target', async () => {
|
|
94
|
+
const state = await createWgpuRenderStateForTest();
|
|
95
|
+
const renderTexture = texture();
|
|
96
|
+
writeWgpuRenderTextureTarget(state, renderTexture, () => {});
|
|
97
|
+
const target = getWgpuRenderTextureTarget(state, renderTexture)!;
|
|
98
|
+
const destroy = vi.spyOn(target.texture, 'destroy');
|
|
99
|
+
|
|
100
|
+
invalidateWgpuRenderTexture(state, renderTexture);
|
|
101
|
+
|
|
102
|
+
expect(getWgpuRenderTextureTarget(state, renderTexture)).toBeNull();
|
|
103
|
+
expect(destroy).not.toHaveBeenCalled();
|
|
104
|
+
});
|
|
105
|
+
});
|
|
106
|
+
|
|
69
107
|
describe('isWgpuRenderTextureReady', () => {
|
|
70
108
|
it('tracks the successful rendered-content transition', async () => {
|
|
71
109
|
const state = await createWgpuRenderStateForTest();
|
|
@@ -94,3 +132,34 @@ describe('renderIntoWgpuRenderTexture', () => {
|
|
|
94
132
|
submitWgpuRenderPass(state);
|
|
95
133
|
});
|
|
96
134
|
});
|
|
135
|
+
|
|
136
|
+
describe('setWgpuRenderTextureGuard', () => {
|
|
137
|
+
it('installs and removes the lifecycle diagnostic callback', async () => {
|
|
138
|
+
const state = await createWgpuRenderStateForTest();
|
|
139
|
+
const renderTexture = texture();
|
|
140
|
+
const guard = vi.fn();
|
|
141
|
+
|
|
142
|
+
setWgpuRenderTextureGuard(state, guard);
|
|
143
|
+
bindWgpuRenderTexture(state, renderTexture);
|
|
144
|
+
expect(guard).toHaveBeenCalledOnce();
|
|
145
|
+
|
|
146
|
+
setWgpuRenderTextureGuard(state, null);
|
|
147
|
+
bindWgpuRenderTexture(state, renderTexture);
|
|
148
|
+
expect(guard).toHaveBeenCalledOnce();
|
|
149
|
+
});
|
|
150
|
+
});
|
|
151
|
+
|
|
152
|
+
describe('writeWgpuRenderTextureTarget', () => {
|
|
153
|
+
it('passes the hidden target to the producer and publishes the completed write', async () => {
|
|
154
|
+
const state = await createWgpuRenderStateForTest();
|
|
155
|
+
const renderTexture = texture();
|
|
156
|
+
const producer = vi.fn();
|
|
157
|
+
|
|
158
|
+
writeWgpuRenderTextureTarget(state, renderTexture, producer);
|
|
159
|
+
|
|
160
|
+
expect(producer).toHaveBeenCalledOnce();
|
|
161
|
+
expect(producer.mock.calls[0][0]).toBe(getWgpuRenderTextureTarget(state, renderTexture));
|
|
162
|
+
expect(renderTexture.version).toBe(1);
|
|
163
|
+
expect(isWgpuRenderTextureReady(state, renderTexture)).toBe(true);
|
|
164
|
+
});
|
|
165
|
+
});
|
|
@@ -0,0 +1,121 @@
|
|
|
1
|
+
import {
|
|
2
|
+
explainWgpuRenderTexture,
|
|
3
|
+
getWgpuRenderTextureTarget,
|
|
4
|
+
isWgpuRenderTextureReady,
|
|
5
|
+
writeWgpuRenderTextureTarget,
|
|
6
|
+
} from './wgpuRenderTexture';
|
|
7
|
+
import {
|
|
8
|
+
acquireWgpuRenderTexture,
|
|
9
|
+
createWgpuRenderTexturePool,
|
|
10
|
+
destroyWgpuRenderTexturePool,
|
|
11
|
+
releaseWgpuRenderTexture,
|
|
12
|
+
withWgpuRenderTextures,
|
|
13
|
+
} from './wgpuRenderTexturePool';
|
|
14
|
+
import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
|
|
15
|
+
|
|
16
|
+
beforeAll(() => installWgpuMock());
|
|
17
|
+
|
|
18
|
+
describe('acquireWgpuRenderTexture', () => {
|
|
19
|
+
it('reuses a released handle and reapplies dimensions before the next write', async () => {
|
|
20
|
+
const state = await createWgpuRenderStateForTest();
|
|
21
|
+
const pool = createWgpuRenderTexturePool();
|
|
22
|
+
const first = acquireWgpuRenderTexture(state, pool, { width: 32, height: 16 });
|
|
23
|
+
writeWgpuRenderTextureTarget(state, first, () => {});
|
|
24
|
+
releaseWgpuRenderTexture(state, pool, first);
|
|
25
|
+
|
|
26
|
+
expect(explainWgpuRenderTexture(state, first).status).toBe('released');
|
|
27
|
+
expect(isWgpuRenderTextureReady(state, first)).toBe(false);
|
|
28
|
+
|
|
29
|
+
const second = acquireWgpuRenderTexture(state, pool, { width: 80, height: 48 });
|
|
30
|
+
expect(second).toBe(first);
|
|
31
|
+
expect(second.source.width).toBe(80);
|
|
32
|
+
expect(second.source.height).toBe(48);
|
|
33
|
+
expect(explainWgpuRenderTexture(state, second).status).toBe('unrendered');
|
|
34
|
+
|
|
35
|
+
writeWgpuRenderTextureTarget(state, second, () => {});
|
|
36
|
+
expect(explainWgpuRenderTexture(state, second)).toEqual({ width: 80, height: 48, status: 'ready' });
|
|
37
|
+
});
|
|
38
|
+
|
|
39
|
+
it('does not allow a pool to cross GPU devices', async () => {
|
|
40
|
+
const a = await createWgpuRenderStateForTest();
|
|
41
|
+
const b = await createWgpuRenderStateForTest();
|
|
42
|
+
const pool = createWgpuRenderTexturePool();
|
|
43
|
+
acquireWgpuRenderTexture(a, pool, { width: 8, height: 8 });
|
|
44
|
+
|
|
45
|
+
expect(() => acquireWgpuRenderTexture(b, pool, { width: 8, height: 8 })).toThrow('cannot cross GPU devices');
|
|
46
|
+
});
|
|
47
|
+
});
|
|
48
|
+
|
|
49
|
+
describe('createWgpuRenderTexturePool', () => {
|
|
50
|
+
it('creates an empty device-unbound pool', () => {
|
|
51
|
+
const pool = createWgpuRenderTexturePool();
|
|
52
|
+
expect(pool.device).toBeNull();
|
|
53
|
+
expect(pool.destroyed).toBe(false);
|
|
54
|
+
expect(pool.free).toEqual([]);
|
|
55
|
+
expect(pool.leased.size).toBe(0);
|
|
56
|
+
});
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
describe('destroyWgpuRenderTexturePool', () => {
|
|
60
|
+
it('destroys hidden targets for free and outstanding leases', async () => {
|
|
61
|
+
const state = await createWgpuRenderStateForTest();
|
|
62
|
+
const pool = createWgpuRenderTexturePool();
|
|
63
|
+
const free = acquireWgpuRenderTexture(state, pool, { width: 8, height: 8 });
|
|
64
|
+
const leased = acquireWgpuRenderTexture(state, pool, { width: 16, height: 16 });
|
|
65
|
+
writeWgpuRenderTextureTarget(state, free, () => {});
|
|
66
|
+
writeWgpuRenderTextureTarget(state, leased, () => {});
|
|
67
|
+
const destroyFree = vi.spyOn(getWgpuRenderTextureTarget(state, free)!.texture, 'destroy');
|
|
68
|
+
const destroyLeased = vi.spyOn(getWgpuRenderTextureTarget(state, leased)!.texture, 'destroy');
|
|
69
|
+
releaseWgpuRenderTexture(state, pool, free);
|
|
70
|
+
|
|
71
|
+
destroyWgpuRenderTexturePool(state, pool);
|
|
72
|
+
|
|
73
|
+
expect(destroyFree).toHaveBeenCalledOnce();
|
|
74
|
+
expect(destroyLeased).toHaveBeenCalledOnce();
|
|
75
|
+
expect(pool.free).toHaveLength(0);
|
|
76
|
+
expect(pool.leased.size).toBe(0);
|
|
77
|
+
});
|
|
78
|
+
|
|
79
|
+
it('rejects acquisition after destruction', async () => {
|
|
80
|
+
const state = await createWgpuRenderStateForTest();
|
|
81
|
+
const pool = createWgpuRenderTexturePool();
|
|
82
|
+
destroyWgpuRenderTexturePool(state, pool);
|
|
83
|
+
expect(() => acquireWgpuRenderTexture(state, pool, { width: 8, height: 8 })).toThrow('has been destroyed');
|
|
84
|
+
});
|
|
85
|
+
});
|
|
86
|
+
|
|
87
|
+
describe('releaseWgpuRenderTexture', () => {
|
|
88
|
+
it('rejects a double release', async () => {
|
|
89
|
+
const state = await createWgpuRenderStateForTest();
|
|
90
|
+
const pool = createWgpuRenderTexturePool();
|
|
91
|
+
const texture = acquireWgpuRenderTexture(state, pool, { width: 8, height: 8 });
|
|
92
|
+
releaseWgpuRenderTexture(state, pool, texture);
|
|
93
|
+
|
|
94
|
+
expect(() => releaseWgpuRenderTexture(state, pool, texture)).toThrow('texture is not leased');
|
|
95
|
+
});
|
|
96
|
+
});
|
|
97
|
+
|
|
98
|
+
describe('withWgpuRenderTextures', () => {
|
|
99
|
+
it('releases every lease when the bracket callback throws', async () => {
|
|
100
|
+
const state = await createWgpuRenderStateForTest();
|
|
101
|
+
const pool = createWgpuRenderTexturePool();
|
|
102
|
+
|
|
103
|
+
expect(() =>
|
|
104
|
+
withWgpuRenderTextures(
|
|
105
|
+
state,
|
|
106
|
+
pool,
|
|
107
|
+
[
|
|
108
|
+
{ width: 8, height: 8 },
|
|
109
|
+
{ width: 8, height: 8 },
|
|
110
|
+
{ width: 8, height: 8 },
|
|
111
|
+
],
|
|
112
|
+
() => {
|
|
113
|
+
throw new Error('capture failed');
|
|
114
|
+
},
|
|
115
|
+
),
|
|
116
|
+
).toThrow('capture failed');
|
|
117
|
+
|
|
118
|
+
expect(pool.leased.size).toBe(0);
|
|
119
|
+
expect(pool.free).toHaveLength(3);
|
|
120
|
+
});
|
|
121
|
+
});
|
|
@@ -36,6 +36,25 @@ describe('uploadWgpuTextureElement', () => {
|
|
|
36
36
|
[4, 4, 1],
|
|
37
37
|
);
|
|
38
38
|
});
|
|
39
|
+
|
|
40
|
+
it('skips a copy with a zero-sized extent', () => {
|
|
41
|
+
const device = makeDevice();
|
|
42
|
+
uploadWgpuTextureElement(device, {} as GPUTexture, [0, 0, 0], 0, 4, {} as GPUCopyExternalImageSource);
|
|
43
|
+
expect(device.queue.copyExternalImageToTexture).not.toHaveBeenCalled();
|
|
44
|
+
});
|
|
45
|
+
|
|
46
|
+
it('skips a copy while a 2D canvas context is lost', () => {
|
|
47
|
+
const device = makeDevice();
|
|
48
|
+
const canvas = document.createElement('canvas');
|
|
49
|
+
canvas.width = 4;
|
|
50
|
+
canvas.height = 4;
|
|
51
|
+
const getContext = vi
|
|
52
|
+
.spyOn(canvas, 'getContext')
|
|
53
|
+
.mockReturnValue({ isContextLost: () => true } as unknown as GPUCanvasContext);
|
|
54
|
+
uploadWgpuTextureElement(device, {} as GPUTexture, [0, 0, 0], 4, 4, canvas);
|
|
55
|
+
expect(device.queue.copyExternalImageToTexture).not.toHaveBeenCalled();
|
|
56
|
+
getContext.mockRestore();
|
|
57
|
+
});
|
|
39
58
|
});
|
|
40
59
|
|
|
41
60
|
describe('uploadWgpuTextureImageResource', () => {
|