@flighthq/render-gl 0.3.0-next.1032.e2b99fc → 0.3.0-next.1220.6982c21

package/src/glRenderTexturePool.test.ts

@@ -0,0 +1,112 @@
+import { explainGlRenderTexture, isGlRenderTextureReady, writeGlRenderTextureTarget } from './glRenderTexture';
+import {
+  acquireGlRenderTexture,
+  createGlRenderTexturePool,
+  destroyGlRenderTexturePool,
+  releaseGlRenderTexture,
+  withGlRenderTextures,
+} from './glRenderTexturePool';
+import { createGlState } from './glTestHelper';
+
+describe('acquireGlRenderTexture', () => {
+  it('reuses a released handle and applies current dimensions on every acquisition', () => {
+    const { state } = createGlState();
+    const pool = createGlRenderTexturePool();
+    const first = acquireGlRenderTexture(state, pool, { width: 32, height: 16 });
+    writeGlRenderTextureTarget(state, first, () => {});
+    releaseGlRenderTexture(state, pool, first);
+
+    expect(explainGlRenderTexture(state, first).status).toBe('released');
+    expect(isGlRenderTextureReady(state, first)).toBe(false);
+
+    const second = acquireGlRenderTexture(state, pool, { width: 80, height: 48 });
+    expect(second).toBe(first);
+    expect(second.source.width).toBe(80);
+    expect(second.source.height).toBe(48);
+    expect(explainGlRenderTexture(state, second).status).toBe('unrendered');
+
+    writeGlRenderTextureTarget(state, second, () => {});
+    expect(explainGlRenderTexture(state, second)).toEqual({ width: 80, height: 48, status: 'ready' });
+  });
+
+  it('does not allow a pool to cross WebGL contexts', () => {
+    const a = createGlState();
+    const b = createGlState();
+    const pool = createGlRenderTexturePool();
+    acquireGlRenderTexture(a.state, pool, { width: 8, height: 8 });
+
+    expect(() => acquireGlRenderTexture(b.state, pool, { width: 8, height: 8 })).toThrow('cannot cross WebGL contexts');
+  });
+});
+
+describe('createGlRenderTexturePool', () => {
+  it('creates an empty usable pool', () => {
+    const pool = createGlRenderTexturePool();
+    expect(pool.context).toBeNull();
+    expect(pool.destroyed).toBe(false);
+    expect(pool.free).toEqual([]);
+    expect(pool.leased.size).toBe(0);
+  });
+});
+
+describe('destroyGlRenderTexturePool', () => {
+  it('destroys hidden targets for both free and outstanding leases at shutdown', () => {
+    const { state, gl } = createGlState();
+    const pool = createGlRenderTexturePool();
+    const free = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+    const leased = acquireGlRenderTexture(state, pool, { width: 16, height: 16 });
+    writeGlRenderTextureTarget(state, free, () => {});
+    writeGlRenderTextureTarget(state, leased, () => {});
+    releaseGlRenderTexture(state, pool, free);
+    const deletes = vi.mocked(gl.deleteTexture).mock.calls.length;
+
+    destroyGlRenderTexturePool(state, pool);
+
+    expect(gl.deleteTexture).toHaveBeenCalledTimes(deletes + 2);
+    expect(pool.free).toHaveLength(0);
+    expect(pool.leased.size).toBe(0);
+  });
+
+  it('rejects acquisition after destruction', () => {
+    const { state } = createGlState();
+    const pool = createGlRenderTexturePool();
+    destroyGlRenderTexturePool(state, pool);
+    expect(() => acquireGlRenderTexture(state, pool, { width: 8, height: 8 })).toThrow('has been destroyed');
+  });
+});
+
+describe('releaseGlRenderTexture', () => {
+  it('rejects a double release', () => {
+    const { state } = createGlState();
+    const pool = createGlRenderTexturePool();
+    const texture = acquireGlRenderTexture(state, pool, { width: 8, height: 8 });
+    releaseGlRenderTexture(state, pool, texture);
+
+    expect(() => releaseGlRenderTexture(state, pool, texture)).toThrow('texture is not leased');
+  });
+});
+
+describe('withGlRenderTextures', () => {
+  it('releases every lease when the bracket callback throws', () => {
+    const { state } = createGlState();
+    const pool = createGlRenderTexturePool();
+
+    expect(() =>
+      withGlRenderTextures(
+        state,
+        pool,
+        [
+          { width: 8, height: 8 },
+          { width: 8, height: 8 },
+          { width: 8, height: 8 },
+        ],
+        () => {
+          throw new Error('capture failed');
+        },
+      ),
+    ).toThrow('capture failed');
+
+    expect(pool.leased.size).toBe(0);
+    expect(pool.free).toHaveLength(3);
+  });
+});

package/src/glTextureResolver.test.ts

@@ -1,10 +1,10 @@
-import type { ImageResource, RenderTexture, TextureLike } from '@flighthq/types/contract';
+import { createEntity } from '@flighthq/entity/contract';
+import type { Image, RenderTexture, TextureLike, TextureSource } from '@flighthq/types/contract';
 import {
-  BitmapTextureBackingKind,
-  CompressedImageTextureBackingKind,
-  ImageTextureBackingKind,
-  RenderTextureBackingKind,
-  VideoTextureBackingKind,
+  BitmapTextureSourceKind,
+  CompressedImageTextureSourceKind,
+  ImageTextureSourceKind,
+  RenderTargetTextureSourceKind,
 } from '@flighthq/types/contract';
 
 import { getGlRenderStateRuntime } from './glRenderState';
@@ -15,12 +15,12 @@ import {
   registerGlBitmapTextureResolver,
   registerGlCompressedImageTextureResolver,
   registerGlRenderTextureResolver,
+  registerStandardGlTextureResolvers,
   registerGlTextureResolver,
-  registerGlVideoTextureResolver,
   resolveGlTexture,
 } from './glTextureResolver';
 
-function textureWithImage(image: ImageResource | null): TextureLike {
+function textureWithImage(image: TextureSource | null): TextureLike {
   return {
     colorSpace: 'srgb',
     flipX: false,
@@ -34,7 +34,8 @@ function textureWithImage(image: ImageResource | null): TextureLike {
       wrapU: 'clamp-to-edge',
       wrapV: 'clamp-to-edge',
     },
-    storage: { dimension: '2d', image },
+    dimension: '2d',
+    source: image,
     uvOffset: { x: 0, y: 0 },
     uvRotation: 0,
     uvScale: { x: 1, y: 1 },
@@ -42,46 +43,59 @@ function textureWithImage(image: ImageResource | null): TextureLike {
   } as unknown as TextureLike;
 }
 
-function imageResource(
-  source: CanvasImageSource = document.createElement('img'),
-  kind = ImageTextureBackingKind,
-): ImageResource {
+function imageResource(source: CanvasImageSource = document.createElement('img')): Image {
   return {
     height: 1,
-    kind,
+    kind: ImageTextureSourceKind,
     source,
     version: 0,
     width: 1,
-  } as unknown as ImageResource;
+  } as unknown as Image;
+}
+
+function textureSource(kind: string): TextureSource {
+  return {
+    height: 1,
+    kind,
+    version: 0,
+    width: 1,
+  } as unknown as TextureSource;
 }
 
 function textureWithTarget(): TextureLike {
   const texture = textureWithImage(null);
   texture.colorSpace = 'linear';
-  texture.storage.target = { colorSpace: 'linear', height: 8, kind: RenderTextureBackingKind, width: 8 };
+  if (texture.dimension !== '2d') throw new Error('test texture must be 2d');
+  texture.source = createEntity({
+    colorSpace: 'linear' as const,
+    height: 8,
+    kind: RenderTargetTextureSourceKind,
+    version: 0,
+    width: 8,
+  });
   return texture;
 }
 
 describe('registerGlBitmapTextureResolver', () => {
-  it('registers only the Bitmap backing key', () => {
+  it('registers only the Bitmap source key', () => {
     const { state } = createGlState();
     registerGlBitmapTextureResolver(state);
-    expect([...getGlRenderStateRuntime(state).glTextureResolverRegistry!.keys()]).toEqual([BitmapTextureBackingKind]);
+    expect([...getGlRenderStateRuntime(state).glTextureResolverRegistry!.keys()]).toEqual([BitmapTextureSourceKind]);
   });
 });
 
 describe('registerGlCompressedImageTextureResolver', () => {
-  it('registers only the CompressedImage backing key', () => {
+  it('registers only the CompressedImage source key', () => {
     const { state } = createGlState();
     registerGlCompressedImageTextureResolver(state);
     expect([...getGlRenderStateRuntime(state).glTextureResolverRegistry!.keys()]).toEqual([
-      CompressedImageTextureBackingKind,
+      CompressedImageTextureSourceKind,
     ]);
   });
 });
 
 describe('registerGlImageTextureResolver', () => {
-  it('registers the 2D image matcher and resolves through the backing-keyed upload cache', () => {
+  it('registers the 2D image matcher and resolves through the source-keyed upload cache', () => {
     const { state, gl } = createGlState();
     const texture = textureWithImage(imageResource());
     registerGlImageTextureResolver(state);
@@ -94,11 +108,31 @@ describe('registerGlImageTextureResolver', () => {
     expect(gl.texImage2D).toHaveBeenCalledOnce();
   });
 
-  it('returns null for an unbound image backing', () => {
+  it('returns null for an unbound image source', () => {
     const { state } = createGlState();
     registerGlImageTextureResolver(state);
     expect(resolveGlTexture(state, textureWithImage(null))).toBeNull();
   });
+
+  it('uploads a host video through the image source kind and gates by version', () => {
+    const { state, gl } = createGlState();
+    const video = imageResource({
+      readyState: 4,
+      videoHeight: 240,
+      videoWidth: 320,
+    } as HTMLVideoElement);
+    const texture = textureWithImage(video);
+    registerGlImageTextureResolver(state);
+
+    const first = resolveGlTexture(state, texture);
+    const uploads = (gl.texImage2D as ReturnType<typeof vi.fn>).mock.calls.length;
+    const second = resolveGlTexture(state, texture);
+
+    expect(first).not.toBeNull();
+    expect(second).toBe(first);
+    expect(gl.texImage2D).toHaveBeenCalledWith(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, video.source);
+    expect(gl.texImage2D).toHaveBeenCalledTimes(uploads);
+  });
 });
 
 describe('registerGlRenderTextureResolver', () => {
@@ -123,59 +157,47 @@ describe('registerGlTextureResolver', () => {
   it('keeps registrations state-scoped, replaces by string kind, and removes with null', () => {
     const { state: a } = createGlState();
     const { state: b } = createGlState();
-    const backingKind = 'acme.generated';
+    const sourceKind = 'acme.generated';
     const first = vi.fn(() => ({ first: true }) as unknown as WebGLTexture);
     const second = vi.fn(() => ({ second: true }) as unknown as WebGLTexture);
-    const image = imageResource();
-    image.kind = backingKind;
-    const texture = textureWithImage(image);
+    const source = textureSource(sourceKind);
+    const texture = textureWithImage(source);
 
-    registerGlTextureResolver(a, backingKind, first);
+    registerGlTextureResolver(a, sourceKind, first);
     expect(resolveGlTexture(a, texture)).not.toBeNull();
     expect(resolveGlTexture(b, texture)).toBeNull();
 
-    registerGlTextureResolver(a, backingKind, second);
+    registerGlTextureResolver(a, sourceKind, second);
     expect(resolveGlTexture(a, texture)).toEqual({ second: true });
     expect(getGlRenderStateRuntime(a).glTextureResolverRegistry?.size).toBe(1);
 
-    registerGlTextureResolver(a, backingKind, null);
+    registerGlTextureResolver(a, sourceKind, null);
     expect(resolveGlTexture(a, texture)).toBeNull();
   });
 
   it('uses one exact keyed lookup and does not fall through to another kind', () => {
     const { state } = createGlState();
-    const image = imageResource();
-    image.kind = 'acme.specific';
+    const image = textureSource('acme.specific');
     registerGlTextureResolver(state, 'image', () => ({ kind: 'image' }) as unknown as WebGLTexture);
     registerGlTextureResolver(state, 'acme.specific', () => ({ kind: 'specific' }) as unknown as WebGLTexture);
     expect(resolveGlTexture(state, textureWithImage(image))).toEqual({ kind: 'specific' });
   });
 });
 
-describe('registerGlVideoTextureResolver', () => {
-  it('specializes the general image resolver and gates uploads by backing version', () => {
-    const { state, gl } = createGlState();
-    const video = imageResource(
-      { readyState: 4, videoHeight: 240, videoWidth: 320 } as HTMLVideoElement,
-      VideoTextureBackingKind,
-    );
-    const texture = textureWithImage(video);
-    registerGlImageTextureResolver(state);
-    registerGlVideoTextureResolver(state);
-
-    const first = resolveGlTexture(state, texture);
-    const uploads = (gl.texImage2D as ReturnType<typeof vi.fn>).mock.calls.length;
-    const second = resolveGlTexture(state, texture);
-
-    expect(first).not.toBeNull();
-    expect(second).toBe(first);
-    expect(gl.texImage2D).toHaveBeenCalledWith(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, video.source);
-    expect(gl.texImage2D).toHaveBeenCalledTimes(uploads);
+describe('registerStandardGlTextureResolvers', () => {
+  it('registers bitmap, image, and render texture sources without compressed images', () => {
+    const { state } = createGlState();
+    registerStandardGlTextureResolvers(state);
+    expect([...getGlRenderStateRuntime(state).glTextureResolverRegistry!.keys()]).toEqual([
+      BitmapTextureSourceKind,
+      ImageTextureSourceKind,
+      RenderTargetTextureSourceKind,
+    ]);
   });
 });
 
 describe('resolveGlTexture', () => {
-  it('returns null when the state has no registered backing resolver', () => {
+  it('returns null when the state has no registered source resolver', () => {
     const { state } = createGlState();
     expect(resolveGlTexture(state, textureWithImage(imageResource()))).toBeNull();
   });

package/src/glTextureUpload.test.ts

@@ -1,4 +1,4 @@
-import type { ImageResource } from '@flighthq/types/contract';
+import type { Image } from '@flighthq/types/contract';
 
 import { uploadGlTextureData, uploadGlTextureElement, uploadGlTextureImageResource } from './glTextureUpload';
 
@@ -34,7 +34,7 @@ describe('uploadGlTextureImageResource', () => {
   it('takes the element path when the resource carries a source', () => {
     const gl = makeGl();
     const source = {} as TexImageSource;
-    const image = { source, width: 4, height: 4 } as unknown as ImageResource;
+    const image = { source, width: 4, height: 4 } as unknown as Image;
     uploadGlTextureImageResource(gl, gl.TEXTURE_2D, image);
     expect(gl.texImage2D).toHaveBeenCalledWith(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
   });

package/src/glTextureVideoUpload.test.ts

@@ -1,4 +1,4 @@
-import type { ImageResource } from '@flighthq/types/contract';
+import type { Image } from '@flighthq/types/contract';
 
 import { uploadGlTextureVideoFrame } from './glTextureVideoUpload';
 
@@ -11,12 +11,12 @@ function makeGl(): WebGL2RenderingContext {
   } as unknown as WebGL2RenderingContext;
 }
 
-// A video ImageResource whose only relevant fields are version and the borrowed host element.
-function makeVideoImage(version: number, readyState = 4, videoWidth = 320, videoHeight = 240): ImageResource {
+// A video Image whose only relevant fields are version and the borrowed host element.
+function makeVideoImage(version: number, readyState = 4, videoWidth = 320, videoHeight = 240): Image {
   return {
     source: { readyState, videoWidth, videoHeight } as unknown as HTMLVideoElement,
     version,
-  } as unknown as ImageResource;
+  } as unknown as Image;
 }
 
 describe('uploadGlTextureVideoFrame', () => {
@@ -46,7 +46,7 @@ describe('uploadGlTextureVideoFrame', () => {
 
   it('skips when the element is null', () => {
     const gl = makeGl();
-    const image = { source: null, version: 2 } as unknown as ImageResource;
+    const image = { source: null, version: 2 } as unknown as Image;
     expect(uploadGlTextureVideoFrame(gl, image, -1)).toBe(-1);
     expect(gl.texImage2D).not.toHaveBeenCalled();
   });