@flighthq/render-gl 0.5.1-next.1069.554a2ac → 0.5.1-next.1201.9b49dee

package/src/glRenderTarget.test.ts

@@ -6,18 +6,19 @@ import { EntityRuntimeKey } from '@flighthq/types/contract';
 import { beginGlRenderPass, endGlRenderPass } from './glRenderPass';
 import { getGlRenderStateRuntime } from './glRenderState';
 import {
-  createGlRenderTarget,
+  createGlScreenRenderTarget,
+  createGlTextureRenderTarget,
   declareGlRenderTargetColorSpace,
-  destroyGlRenderTarget,
-  drawGlRenderTargetResult,
-  explainGlRenderTarget,
-  initializeGlRenderTarget,
+  destroyGlTextureRenderTarget,
+  drawGlTextureRenderTargetResult,
+  explainGlTextureRenderTarget,
+  initializeGlTextureRenderTarget,
   isGlRenderTargetFormatSupported,
-  resizeGlRenderTarget,
-  resolveGlRenderTarget,
+  resizeGlTextureRenderTarget,
+  resolveGlTextureRenderTarget,
   resolveGlRenderTargetAxes,
 } from './glRenderTarget';
-import { createGlState } from './glTestHelper';
+import { createGlState, makeGL } from './glTestHelper';
 
 function makeState() {
   const { state: _state, gl: _gl } = createGlState();
@@ -44,38 +45,66 @@ function makeState() {
   return { state, gl };
 }
 
-describe('createGlRenderTarget', () => {
+describe('createGlScreenRenderTarget', () => {
+  it('returns a target with framebuffer null', () => {
+    const gl = makeGL(320, 240);
+    const target = createGlScreenRenderTarget(gl);
+    expect(target.framebuffer).toBeNull();
+  });
+
+  it('reads dimensions from drawingBufferWidth and drawingBufferHeight', () => {
+    const gl = makeGL(320, 240);
+    const target = createGlScreenRenderTarget(gl);
+    expect(target.width).toBe(320);
+    expect(target.height).toBe(240);
+  });
+
+  it('returns an Entity-backed target', () => {
+    const gl = makeGL();
+    const target = createGlScreenRenderTarget(gl);
+    expect(Object.hasOwn(target, EntityRuntimeKey)).toBe(true);
+  });
+
+  it('sets colorAttachments to 1 and colorSpace to srgb', () => {
+    const gl = makeGL();
+    const target = createGlScreenRenderTarget(gl);
+    expect(target.colorAttachments).toBe(1);
+    expect(target.colorSpace).toBe('srgb');
+  });
+});
+
+describe('createGlTextureRenderTarget', () => {
   it('returns a render target with the requested dimensions', () => {
     const { state } = makeState();
-    const target = createGlRenderTarget(state, { width: 128, height: 64 });
+    const target = createGlTextureRenderTarget(state, { width: 128, height: 64 });
     expect(target.width).toBe(128);
     expect(target.height).toBe(64);
   });
 
   it('returns an Entity-backed render target', () => {
     const { state } = makeState();
-    const target = createGlRenderTarget(state, { width: 128, height: 64 });
+    const target = createGlTextureRenderTarget(state, { width: 128, height: 64 });
     expect(Object.hasOwn(target, EntityRuntimeKey)).toBe(true);
     expect(target[EntityRuntimeKey]).toBeUndefined();
   });
 
   it('enforces a minimum size of 1', () => {
     const { state } = makeState();
-    const target = createGlRenderTarget(state, { width: 0, height: 0 });
+    const target = createGlTextureRenderTarget(state, { width: 0, height: 0 });
     expect(target.width).toBe(1);
     expect(target.height).toBe(1);
   });
 
   it('ceils fractional dimensions', () => {
     const { state } = makeState();
-    const target = createGlRenderTarget(state, { width: 10.3, height: 20.9 });
+    const target = createGlTextureRenderTarget(state, { width: 10.3, height: 20.9 });
     expect(target.width).toBe(11);
     expect(target.height).toBe(21);
   });
 
   it('calls createFramebuffer and createTexture', () => {
     const { state, gl } = makeState();
-    createGlRenderTarget(state, { width: 64, height: 64 });
+    createGlTextureRenderTarget(state, { width: 64, height: 64 });
     expect(vi.mocked(gl.createFramebuffer)).toHaveBeenCalled();
     expect(vi.mocked(gl.createTexture)).toHaveBeenCalled();
   });
@@ -84,26 +113,26 @@ describe('createGlRenderTarget', () => {
     const { state } = makeState();
     const runtime = getGlRenderStateRuntime(state);
     runtime.context.currentTextureRealization = { straightAlpha: false, texture: {} as WebGLTexture };
-    createGlRenderTarget(state, { width: 32, height: 32 });
+    createGlTextureRenderTarget(state, { width: 32, height: 32 });
     expect(runtime.context.currentTextureRealization).toBeNull();
   });
 
   it("defaults colorSpace to 'srgb' when the descriptor omits it", () => {
     const { state } = makeState();
-    const target = createGlRenderTarget(state, { width: 32, height: 32 });
+    const target = createGlTextureRenderTarget(state, { width: 32, height: 32 });
     expect(target.colorSpace).toBe('srgb');
   });
 
   it('honors an explicit colorSpace', () => {
     const { state } = makeState();
-    const target = createGlRenderTarget(state, { width: 32, height: 32, colorSpace: 'linear' });
+    const target = createGlTextureRenderTarget(state, { width: 32, height: 32, colorSpace: 'linear' });
     expect(target.colorSpace).toBe('linear');
   });
 
   it('retains canonical requested axes separately from effective storage', () => {
     const { state, gl } = makeState();
     vi.mocked(gl.getParameter).mockImplementation((parameter) => (parameter === gl.MAX_SAMPLES ? 4 : null));
-    const target = createGlRenderTarget(state, {
+    const target = createGlTextureRenderTarget(state, {
       width: 32,
       height: 16,
       colorAttachments: 2,
@@ -134,7 +163,7 @@ describe('createGlRenderTarget', () => {
     (gl as unknown as { getExtension: (n: string) => unknown }).getExtension = (name: string) =>
       name === 'EXT_color_buffer_float' ? null : {};
     for (const format of ['rgba16f', 'rgba32f'] as const) {
-      const target = createGlRenderTarget(state, { width: 32, height: 32, format }, 'preferred');
+      const target = createGlTextureRenderTarget(state, { width: 32, height: 32, format }, 'preferred');
       expect(target.format).toBe('rgba8');
       expect(target.colorFormats).toEqual(['rgba8']);
     }
@@ -143,7 +172,7 @@ describe('createGlRenderTarget', () => {
   it('keeps a float format when EXT_color_buffer_float is available', () => {
     const { state, gl } = makeState();
     (gl as unknown as { getExtension: (n: string) => unknown }).getExtension = () => ({});
-    const target = createGlRenderTarget(state, { width: 32, height: 32, format: 'rgba16f' });
+    const target = createGlTextureRenderTarget(state, { width: 32, height: 32, format: 'rgba16f' });
     expect(target.format).toBe('rgba16f');
   });
 
@@ -153,7 +182,7 @@ describe('createGlRenderTarget', () => {
       name === 'EXT_color_buffer_float' ? null : {};
     vi.clearAllMocks();
 
-    const target = createGlRenderTarget(state, { width: 32, height: 32, format: 'rgba32f' }, 'required');
+    const target = createGlTextureRenderTarget(state, { width: 32, height: 32, format: 'rgba32f' }, 'required');
 
     expect(target).toBeNull();
     expect(gl.createFramebuffer).not.toHaveBeenCalled();
@@ -165,7 +194,7 @@ describe('createGlRenderTarget', () => {
     (gl as unknown as { getExtension: (n: string) => unknown }).getExtension = (name: string) =>
       name === 'EXT_color_buffer_float' ? null : {};
 
-    const target = createGlRenderTarget(
+    const target = createGlTextureRenderTarget(
       state,
       {
         width: 32,
@@ -183,13 +212,13 @@ describe('createGlRenderTarget', () => {
 describe('declareGlRenderTargetColorSpace', () => {
   it('stamps the currently bound target and returns true', () => {
     const { state } = makeState();
-    const target = createGlRenderTarget(state, { width: 64, height: 48 });
+    const target = createGlTextureRenderTarget(state, { width: 64, height: 48 });
     expect(target.colorSpace).toBe('srgb');
-    beginGlRenderPass(state, target);
+    const pass = beginGlRenderPass(state, target);
     expect(declareGlRenderTargetColorSpace(state, 'linear')).toBe(true);
     expect(target.colorSpace).toBe('linear');
     expect(target.requestedAxes.colorSpace).toBe('linear');
-    endGlRenderPass(state);
+    endGlRenderPass(pass);
   });
 
   it('returns false when no target is bound (rendering to the canvas)', () => {
@@ -199,62 +228,68 @@ describe('declareGlRenderTargetColorSpace', () => {
 
   it('is restored to the outer target when a nested target ends', () => {
     const { state } = makeState();
-    const outer = createGlRenderTarget(state, { width: 64, height: 48 });
-    const inner = createGlRenderTarget(state, { width: 32, height: 32 });
-    beginGlRenderPass(state, outer);
-    beginGlRenderPass(state, inner);
+    const outer = createGlTextureRenderTarget(state, { width: 64, height: 48 });
+    const inner = createGlTextureRenderTarget(state, { width: 32, height: 32 });
+    const outerPass = beginGlRenderPass(state, outer);
+    const innerPass = beginGlRenderPass(state, inner);
     declareGlRenderTargetColorSpace(state, 'linear');
     expect(inner.colorSpace).toBe('linear');
-    endGlRenderPass(state);
+    endGlRenderPass(innerPass);
     // Back on `outer`: a declare now stamps it, not the popped inner target.
     declareGlRenderTargetColorSpace(state, 'linear');
     expect(outer.colorSpace).toBe('linear');
-    endGlRenderPass(state);
+    endGlRenderPass(outerPass);
   });
 });
 
-describe('destroyGlRenderTarget', () => {
+describe('destroyGlTextureRenderTarget', () => {
   it('deletes the framebuffer and texture', () => {
     const { state, gl } = makeState();
-    const target = createGlRenderTarget(state, { width: 32, height: 32 });
+    const target = createGlTextureRenderTarget(state, { width: 32, height: 32 });
     const { framebuffer, texture } = target;
 
-    destroyGlRenderTarget(state, target);
+    destroyGlTextureRenderTarget(target);
 
     expect(vi.mocked(gl.deleteFramebuffer)).toHaveBeenCalledWith(framebuffer);
     expect(vi.mocked(gl.deleteTexture)).toHaveBeenCalledWith(texture);
   });
 });
 
-describe('drawGlRenderTargetResult', () => {
+describe('drawGlTextureRenderTargetResult', () => {
   it('is a no-op when target dimensions are zero', () => {
     const { state, gl } = makeState();
+    const screenTarget = createGlScreenRenderTarget(gl);
+    const pass = beginGlRenderPass(state, screenTarget);
     const node = getOrCreateRenderProxy2D(state, createDisplayObject());
-    const target = createGlRenderTarget(state, { width: 1, height: 1 });
+    const target = createGlTextureRenderTarget(state, { width: 1, height: 1 });
     target.width = 0;
     vi.clearAllMocks();
 
-    drawGlRenderTargetResult(state, node, target, createMatrix());
+    drawGlTextureRenderTargetResult(pass, node, target, createMatrix());
 
     expect(vi.mocked(gl.bindTexture)).not.toHaveBeenCalled();
   });
 
   it('composites a valid target without throwing', () => {
-    const { state } = makeState();
+    const { state, gl } = makeState();
+    const screenTarget = createGlScreenRenderTarget(gl);
+    const pass = beginGlRenderPass(state, screenTarget);
     const node = getOrCreateRenderProxy2D(state, createDisplayObject());
     node.alpha = 1;
-    const target = createGlRenderTarget(state, { width: 64, height: 48 });
+    const target = createGlTextureRenderTarget(state, { width: 64, height: 48 });
 
-    expect(() => drawGlRenderTargetResult(state, node, target, createMatrix())).not.toThrow();
+    expect(() => drawGlTextureRenderTargetResult(pass, node, target, createMatrix())).not.toThrow();
   });
 
   it('binds the target texture', () => {
     const { state, gl } = makeState();
+    const screenTarget = createGlScreenRenderTarget(gl);
+    const pass = beginGlRenderPass(state, screenTarget);
     const node = getOrCreateRenderProxy2D(state, createDisplayObject());
-    const target = createGlRenderTarget(state, { width: 64, height: 48 });
+    const target = createGlTextureRenderTarget(state, { width: 64, height: 48 });
     vi.clearAllMocks();
 
-    drawGlRenderTargetResult(state, node, target, createMatrix());
+    drawGlTextureRenderTargetResult(pass, node, target, createMatrix());
 
     expect(vi.mocked(gl.bindTexture)).toHaveBeenCalledWith(
       (gl as unknown as { TEXTURE_2D: number }).TEXTURE_2D,
@@ -263,13 +298,13 @@ describe('drawGlRenderTargetResult', () => {
   });
 });
 
-describe('explainGlRenderTarget', () => {
+describe('explainGlTextureRenderTarget', () => {
   it('reports every GL capability substitution without losing the request', () => {
     const { state, gl } = makeState();
     vi.mocked(gl.getParameter).mockImplementation((parameter) => (parameter === gl.MAX_SAMPLES ? 4 : null));
     (gl as unknown as { getExtension: (name: string) => unknown }).getExtension = (name: string) =>
       name === 'EXT_color_buffer_float' ? null : {};
-    const target = createGlRenderTarget(state, {
+    const target = createGlTextureRenderTarget(state, {
       width: 32,
       height: 16,
       format: 'rgba16f',
@@ -277,7 +312,7 @@ describe('explainGlRenderTarget', () => {
       depth: 'depth-stencil-sampled',
     });
 
-    expect(explainGlRenderTarget(target).differences).toEqual([
+    expect(explainGlTextureRenderTarget(target).differences).toEqual([
       { axis: 'format', effective: 'rgba8', requested: 'rgba16f' },
       { axis: 'colorFormats', effective: ['rgba8'], requested: ['rgba16f'] },
       { axis: 'sampleCount', effective: 4, requested: 8 },
@@ -287,14 +322,14 @@ describe('explainGlRenderTarget', () => {
 
   it('reports no differences when GL realizes every requested axis', () => {
     const { state } = makeState();
-    const target = createGlRenderTarget(state, { width: 32, height: 16 });
-    expect(explainGlRenderTarget(target).differences).toEqual([]);
+    const target = createGlTextureRenderTarget(state, { width: 32, height: 16 });
+    expect(explainGlTextureRenderTarget(target).differences).toEqual([]);
   });
 });
 
-describe('initializeGlRenderTarget', () => {
-  it('is the construction initializer of createGlRenderTarget', () => {
-    expect(typeof initializeGlRenderTarget).toBe('function');
+describe('initializeGlTextureRenderTarget', () => {
+  it('is the construction initializer of createGlTextureRenderTarget', () => {
+    expect(typeof initializeGlTextureRenderTarget).toBe('function');
   });
 });
 
@@ -320,12 +355,12 @@ describe('isGlRenderTargetFormatSupported', () => {
   });
 });
 
-describe('resizeGlRenderTarget', () => {
+describe('resizeGlTextureRenderTarget', () => {
   it('updates the target dimensions', () => {
     const { state } = makeState();
-    const target = createGlRenderTarget(state, { width: 64, height: 64 });
+    const target = createGlTextureRenderTarget(state, { width: 64, height: 64 });
 
-    resizeGlRenderTarget(state, target, 256, 128);
+    resizeGlTextureRenderTarget(state, target, 256, 128);
 
     expect(target.width).toBe(256);
     expect(target.height).toBe(128);
@@ -333,9 +368,9 @@ describe('resizeGlRenderTarget', () => {
 
   it('enforces a minimum size of 1', () => {
     const { state } = makeState();
-    const target = createGlRenderTarget(state, { width: 64, height: 64 });
+    const target = createGlTextureRenderTarget(state, { width: 64, height: 64 });
 
-    resizeGlRenderTarget(state, target, 0, 0);
+    resizeGlTextureRenderTarget(state, target, 0, 0);
 
     expect(target.width).toBe(1);
     expect(target.height).toBe(1);
@@ -343,10 +378,10 @@ describe('resizeGlRenderTarget', () => {
 
   it('reallocates the texture storage', () => {
     const { state, gl } = makeState();
-    const target = createGlRenderTarget(state, { width: 64, height: 64 });
+    const target = createGlTextureRenderTarget(state, { width: 64, height: 64 });
     vi.clearAllMocks();
 
-    resizeGlRenderTarget(state, target, 128, 128);
+    resizeGlTextureRenderTarget(state, target, 128, 128);
 
     expect(vi.mocked(gl.bindTexture)).toHaveBeenCalledWith(
       (gl as unknown as { TEXTURE_2D: number }).TEXTURE_2D,
@@ -357,12 +392,12 @@ describe('resizeGlRenderTarget', () => {
 
   it('restores the tracked framebuffer after reallocating storage', () => {
     const { state, gl } = makeState();
-    const target = createGlRenderTarget(state, { width: 64, height: 64 });
+    const target = createGlTextureRenderTarget(state, { width: 64, height: 64 });
     const previous = { name: 'previous-framebuffer' } as unknown as WebGLFramebuffer;
     getGlRenderStateRuntime(state).currentFramebuffer = previous;
     vi.clearAllMocks();
 
-    resizeGlRenderTarget(state, target, 128, 96);
+    resizeGlTextureRenderTarget(state, target, 128, 96);
 
     expect(vi.mocked(gl.bindFramebuffer)).toHaveBeenLastCalledWith(gl.FRAMEBUFFER, previous);
     expect(getGlRenderStateRuntime(state).currentFramebuffer).toBe(previous);
@@ -371,7 +406,7 @@ describe('resizeGlRenderTarget', () => {
   it('preserves heterogeneous color formats and sampled depth across resize', () => {
     const { state, gl } = makeState();
     (gl as unknown as { getExtension: (name: string) => unknown }).getExtension = () => ({});
-    const target = createGlRenderTarget(state, {
+    const target = createGlTextureRenderTarget(state, {
       width: 64,
       height: 64,
       colorAttachments: 2,
@@ -380,7 +415,7 @@ describe('resizeGlRenderTarget', () => {
     });
     vi.clearAllMocks();
 
-    resizeGlRenderTarget(state, target, 128, 96);
+    resizeGlTextureRenderTarget(state, target, 128, 96);
 
     expect(target.colorAttachments).toBe(2);
     expect(target.colorFormats).toEqual(['rgba8', 'rgba32f']);
@@ -394,34 +429,61 @@ describe('resizeGlRenderTarget', () => {
   });
 });
 
-describe('resolveGlRenderTarget', () => {
+describe('resolveGlRenderTargetAxes', () => {
+  it('queries effective axes without allocating target storage', () => {
+    const { state, gl } = makeState();
+    vi.mocked(gl.getParameter).mockImplementation((parameter) => (parameter === gl.MAX_SAMPLES ? 2 : null));
+    vi.clearAllMocks();
+
+    const axes = resolveGlRenderTargetAxes(state, { width: 32, height: 16, sampleCount: 4 });
+
+    expect(axes.sampleCount).toBe(2);
+    expect(gl.createFramebuffer).not.toHaveBeenCalled();
+    expect(gl.createTexture).not.toHaveBeenCalled();
+  });
+
+  it('applies preferred fallback and required refusal without allocating storage', () => {
+    const { state, gl } = makeState();
+    (gl as unknown as { getExtension: (name: string) => unknown }).getExtension = () => null;
+    vi.clearAllMocks();
+
+    expect(resolveGlRenderTargetAxes(state, { width: 32, height: 16, format: 'rgba32f' }, 'preferred')).toMatchObject({
+      format: 'rgba8',
+      colorFormats: ['rgba8'],
+    });
+    expect(resolveGlRenderTargetAxes(state, { width: 32, height: 16, format: 'rgba32f' }, 'required')).toBeNull();
+    expect(gl.createFramebuffer).not.toHaveBeenCalled();
+    expect(gl.createTexture).not.toHaveBeenCalled();
+  });
+});
+describe('resolveGlTextureRenderTarget', () => {
   it('is a no-op for a single-sample target', () => {
     const { state, gl } = makeState();
-    const target = createGlRenderTarget(state, { width: 64, height: 48 });
+    const target = createGlTextureRenderTarget(state, { width: 64, height: 48 });
     expect(target.sampleCount).toBe(1);
     vi.clearAllMocks();
 
-    resolveGlRenderTarget(state, target);
+    resolveGlTextureRenderTarget(state, target);
 
     expect(vi.mocked(gl.bindFramebuffer)).not.toHaveBeenCalled();
   });
 
   it('is a no-op when the target has no resolve framebuffer', () => {
     const { state, gl } = makeState();
-    const target = createGlRenderTarget(state, { width: 64, height: 48 });
+    const target = createGlTextureRenderTarget(state, { width: 64, height: 48 });
     // Force the MSAA sample-count gate open but leave resolveFramebuffer null.
     target.sampleCount = 4;
     target.resolveFramebuffer = null;
     vi.clearAllMocks();
 
-    resolveGlRenderTarget(state, target);
+    resolveGlTextureRenderTarget(state, target);
 
     expect(vi.mocked(gl.bindFramebuffer)).not.toHaveBeenCalled();
   });
 
   it('blits each color attachment and flushes for an MSAA target', () => {
     const { state, gl } = makeState();
-    const target = createGlRenderTarget(state, { width: 64, height: 48 });
+    const target = createGlTextureRenderTarget(state, { width: 64, height: 48 });
     target.sampleCount = 4;
     target.resolveFramebuffer = {} as WebGLFramebuffer;
     // Two color attachments resolve as two separate blits.
@@ -443,7 +505,7 @@ describe('resolveGlRenderTarget', () => {
       flush,
     });
 
-    resolveGlRenderTarget(state, target);
+    resolveGlTextureRenderTarget(state, target);
 
     expect(blit).toHaveBeenCalledTimes(2);
     expect(readBuffer).toHaveBeenCalledTimes(2);
@@ -452,7 +514,7 @@ describe('resolveGlRenderTarget', () => {
 
   it('disables an active scissor for the storage-wide resolve and restores it afterward', () => {
     const { state, gl } = makeState();
-    const target = createGlRenderTarget(state, { width: 64, height: 48 });
+    const target = createGlTextureRenderTarget(state, { width: 64, height: 48 });
     target.sampleCount = 4;
     target.resolveFramebuffer = {} as WebGLFramebuffer;
     const runtime = getGlRenderStateRuntime(state);
@@ -470,7 +532,7 @@ describe('resolveGlRenderTarget', () => {
       flush: vi.fn(),
     });
 
-    resolveGlRenderTarget(state, target);
+    resolveGlTextureRenderTarget(state, target);
 
     expect(gl.disable).toHaveBeenCalledWith(gl.SCISSOR_TEST);
     expect(vi.mocked(gl.disable).mock.invocationCallOrder.at(-1)).toBeLessThan(blit.mock.invocationCallOrder[0]);
@@ -480,7 +542,7 @@ describe('resolveGlRenderTarget', () => {
 
   it('restores framebuffer and scissor state when an MSAA blit throws', () => {
     const { state, gl } = makeState();
-    const target = createGlRenderTarget(state, { width: 64, height: 48 });
+    const target = createGlTextureRenderTarget(state, { width: 64, height: 48 });
     target.sampleCount = 4;
     target.resolveFramebuffer = { id: 'resolve' } as unknown as WebGLFramebuffer;
     const runtime = getGlRenderStateRuntime(state);
@@ -501,37 +563,10 @@ describe('resolveGlRenderTarget', () => {
       flush: vi.fn(),
     });
 
-    expect(() => resolveGlRenderTarget(state, target)).toThrow('blit failed');
+    expect(() => resolveGlTextureRenderTarget(state, target)).toThrow('blit failed');
     expect(gl.bindFramebuffer).toHaveBeenCalledWith(gl.READ_FRAMEBUFFER, enclosingFramebuffer);
     expect(gl.bindFramebuffer).toHaveBeenLastCalledWith(gl.DRAW_FRAMEBUFFER, enclosingFramebuffer);
     expect(gl.enable).toHaveBeenLastCalledWith(gl.SCISSOR_TEST);
     expect(gl.scissor).toHaveBeenLastCalledWith(3, 4, 16, 12);
   });
 });
-describe('resolveGlRenderTargetAxes', () => {
-  it('queries effective axes without allocating target storage', () => {
-    const { state, gl } = makeState();
-    vi.mocked(gl.getParameter).mockImplementation((parameter) => (parameter === gl.MAX_SAMPLES ? 2 : null));
-    vi.clearAllMocks();
-
-    const axes = resolveGlRenderTargetAxes(state, { width: 32, height: 16, sampleCount: 4 });
-
-    expect(axes.sampleCount).toBe(2);
-    expect(gl.createFramebuffer).not.toHaveBeenCalled();
-    expect(gl.createTexture).not.toHaveBeenCalled();
-  });
-
-  it('applies preferred fallback and required refusal without allocating storage', () => {
-    const { state, gl } = makeState();
-    (gl as unknown as { getExtension: (name: string) => unknown }).getExtension = () => null;
-    vi.clearAllMocks();
-
-    expect(resolveGlRenderTargetAxes(state, { width: 32, height: 16, format: 'rgba32f' }, 'preferred')).toMatchObject({
-      format: 'rgba8',
-      colorFormats: ['rgba8'],
-    });
-    expect(resolveGlRenderTargetAxes(state, { width: 32, height: 16, format: 'rgba32f' }, 'required')).toBeNull();
-    expect(gl.createFramebuffer).not.toHaveBeenCalled();
-    expect(gl.createTexture).not.toHaveBeenCalled();
-  });
-});