@flighthq/scene2d-gl 0.3.0-next.906.07cea63 → 0.3.0

package/src/glShapeData.test.ts

@@ -0,0 +1,74 @@
+import { getGlRenderStateRuntime } from '@flighthq/render-gl/contract';
+import type { GlShapeRendererData } from '@flighthq/types/contract';
+
+import {
+  acquireGlShapeRasterSurface,
+  createGlShapeData,
+  destroyGlShapeData,
+  getGlShapeData,
+  toGlShapeRendererData,
+} from './glShapeData';
+import { createGlState } from './glTestHelper';
+
+function emptyData(): GlShapeRendererData {
+  return { surface: null, lastContentId: -1, lastPixelRatio: 0, lastW: 0, lastH: 0, meshVersion: -1, meshes: null };
+}
+
+describe('acquireGlShapeRasterSurface', () => {
+  it('allocates once and returns the same surface thereafter', () => {
+    const data = emptyData();
+    const first = acquireGlShapeRasterSurface(data);
+    expect(data.surface).toBe(first);
+    expect(acquireGlShapeRasterSurface(data)).toBe(first);
+  });
+
+  it('wraps the canvas as an Image so the quad batch treats it like any other texture source', () => {
+    const surface = acquireGlShapeRasterSurface(emptyData());
+    expect(surface.image.source).toBe(surface.canvas);
+  });
+});
+
+describe('createGlShapeData', () => {
+  it('starts with neither cache populated, so a shape allocates nothing until a strategy needs it', () => {
+    const { state } = createGlState();
+    const data = getGlShapeData(createGlShapeData(state, {} as never)!);
+    expect(data.surface).toBeNull();
+    expect(data.meshes).toBeNull();
+    expect(data.meshVersion).toBe(-1);
+  });
+});
+
+describe('destroyGlShapeData', () => {
+  it('does nothing when the shape only ever tessellated, since there is no surface to free', () => {
+    const { state, gl } = createGlState();
+    destroyGlShapeData(state, toGlShapeRendererData(emptyData()));
+    expect(gl.deleteTexture).not.toHaveBeenCalled();
+  });
+
+  it('frees the cached GPU texture keyed on the raster surface', () => {
+    const { state, gl } = createGlState();
+    const data = emptyData();
+    const surface = acquireGlShapeRasterSurface(data);
+    const texture = {} as WebGLTexture;
+    getGlRenderStateRuntime(state).textureSourcePremultipliedTextureCache.set(surface.image, { texture } as never);
+
+    destroyGlShapeData(state, toGlShapeRendererData(data));
+
+    expect(gl.deleteTexture).toHaveBeenCalledWith(texture);
+    expect(getGlRenderStateRuntime(state).textureSourcePremultipliedTextureCache.has(surface.image)).toBe(false);
+  });
+});
+
+describe('getGlShapeData', () => {
+  it('round-trips through the opaque RendererData slot', () => {
+    const data = emptyData();
+    expect(getGlShapeData(toGlShapeRendererData(data))).toBe(data);
+  });
+});
+
+describe('toGlShapeRendererData', () => {
+  it('is the inverse of getGlShapeData', () => {
+    const data = emptyData();
+    expect(toGlShapeRendererData(getGlShapeData(toGlShapeRendererData(data)))).toBe(toGlShapeRendererData(data));
+  });
+});

package/src/glShapeMesh.test.ts

@@ -127,7 +127,7 @@ describe('drawGlShapeMeshes', () => {
     const shader = getGlRenderStateRuntime(state).shapeMeshColorScaleBiasShader!;
     expect(shader).toBeDefined();
     // Scale and bias are uploaded verbatim — identical to glColorAdjustmentMaterialFeature's
-    // bindGlSpriteBatchUniformColorScaleBias.
+    // bindGlQuadBatchWriterUniformColorScaleBias.
     expect(gl.uniform4f).toHaveBeenCalledWith(shader.colorScaleLocation, 0.5, 0.5, 0.5, 1);
     expect(gl.uniform4f).toHaveBeenCalledWith(shader.colorBiasLocation, 0.5, 0, 0, 0);
     // Flat mesh color still uploaded premultiplied (white, alpha 1); the shader un/re-premultiplies.

package/src/glShapeRasterizer.test.ts

@@ -0,0 +1,32 @@
+import { createRenderState, enableRenderRegistryGuards, explainRenderRegistryMisses } from '@flighthq/render/contract';
+import { RenderRegistry } from '@flighthq/types/contract';
+
+import { getGlShapeRasterizer, registerGlShapeRasterizer } from './glShapeRasterizer';
+import { createGlState } from './glTestHelper';
+
+describe('getGlShapeRasterizer', () => {
+  it('reports none until one is registered', () => {
+    const state = createGlState().state;
+    expect(getGlShapeRasterizer(state)).toBeNull();
+  });
+});
+
+describe('registerGlShapeRasterizer', () => {
+  it('installs the rasterizer the shape path draws non-solid fills through', () => {
+    const state = createGlState().state;
+    const rasterizer = (): void => {};
+
+    registerGlShapeRasterizer(state, rasterizer);
+
+    expect(getGlShapeRasterizer(state)).toBe(rasterizer);
+  });
+
+  it('removes one again, so a state can drop back to tessellation only', () => {
+    const state = createGlState().state;
+    registerGlShapeRasterizer(state, (): void => {});
+
+    registerGlShapeRasterizer(state, null);
+
+    expect(getGlShapeRasterizer(state)).toBeNull();
+  });
+});

package/src/glSprite.test.ts

@@ -1,79 +1,88 @@
-import { addNodeChild } from '@flighthq/node/contract';
-import { getOrCreateRenderProxy2D, prepareScene2DRender, registerRenderer } from '@flighthq/render/contract';
-import { createSprite } from '@flighthq/sprite/contract';
-import { SpriteKind } from '@flighthq/types/contract';
-
-import { renderGlSprite } from './glSprite';
+import {
+  getGlRenderStateRuntime,
+  registerGlBitmapTextureResolver,
+  registerGlRenderTextureResolver,
+  renderIntoGlRenderTexture,
+} from '@flighthq/render-gl/contract';
+import { createRenderTexture, createTexture, setTextureUvFromPixelRect } from '@flighthq/texture/contract';
+import type { Bitmap, RenderProxy2D, Sprite } from '@flighthq/types/contract';
+import { BatchFormat, BitmapTextureSourceKind } from '@flighthq/types/contract';
+
+import { flushGlQuadBatchWriter } from './glQuadBatchWriter';
+import { defaultGlSpriteRenderer, drawGlSprite } from './glSprite';
+import { registerGlStandardMaterial } from './glStandardMaterial';
 import { createGlState } from './glTestHelper';
 
-function makeRenderer() {
-  return { createData: () => null, submit: vi.fn() } as any;
+function makeSprite(width = 64, height = 48): Sprite {
+  const image = {
+    alphaType: 'straight',
+    colorSpace: 'srgb',
+    data: new Uint8ClampedArray(width * height * 4),
+    format: 'rgba8unorm',
+    height,
+    kind: BitmapTextureSourceKind,
+    version: 1,
+    width,
+  } as unknown as Bitmap;
+  return {
+    data: { texture: createTexture({ dimension: '2d', source: image }) },
+  } as Sprite;
 }
 
-describe('renderGlSprite', () => {
-  it('does not throw for an empty sprite node', () => {
-    const { state } = createGlState();
-    const sprite = createSprite();
-    expect(() => {
-      prepareScene2DRender(state, sprite);
-      renderGlSprite(state, sprite);
-    }).not.toThrow();
-  });
-
-  it('calls renderer.submit for a visible sprite with a registered renderer', () => {
-    const { state } = createGlState();
-    const renderer = makeRenderer();
-    registerRenderer(state, SpriteKind, renderer);
-
-    const sprite = createSprite();
-    const data = getOrCreateRenderProxy2D(state, sprite);
-
-    prepareScene2DRender(state, sprite);
-    renderGlSprite(state, sprite);
+function makeRenderProxy(sprite: Sprite): RenderProxy2D {
+  return {
+    alpha: 1,
+    blendMode: 0,
+    colorMatrix: null,
+    colorScaleBias: null,
+    material: null,
+    materialData: null,
+    source: sprite,
+    transform2D: { a: 1, b: 0, c: 0, d: 1, tx: 10, ty: 20 },
+  } as unknown as RenderProxy2D;
+}
 
-    expect(renderer.submit).toHaveBeenCalledWith(state, data);
+describe('defaultGlSpriteRenderer', () => {
+  it('declares the quad format and submit function', () => {
+    expect(defaultGlSpriteRenderer.format).toBe(BatchFormat.Quad);
+    expect(typeof defaultGlSpriteRenderer.isDirty).toBe('function');
+    expect(defaultGlSpriteRenderer.submit).toBe(drawGlSprite);
   });
+});
 
-  it('skips a sprite node with visible set to false', () => {
+describe('drawGlSprite', () => {
+  it('writes natural size and uv window into the shared batch', () => {
     const { state } = createGlState();
-    const renderer = makeRenderer();
-    registerRenderer(state, SpriteKind, renderer);
-
-    const sprite = createSprite();
-    sprite.visible = false;
-
-    prepareScene2DRender(state, sprite);
-    renderGlSprite(state, sprite);
-
-    expect(renderer.submit).not.toHaveBeenCalled();
+    registerGlBitmapTextureResolver(state);
+    registerGlStandardMaterial(state);
+    const sprite = makeSprite(128, 64);
+    setTextureUvFromPixelRect(sprite.data.texture!, 16, 8, 32, 16);
+    drawGlSprite(state, makeRenderProxy(sprite));
+    const data = getGlRenderStateRuntime(state).quadBatchWriterInstanceData;
+    expect(Array.from(data.slice(6, 12))).toEqual([32, 16, 0.125, 0.125, 0.375, 0.375]);
   });
 
-  it('skips a sprite node with alpha at or below 0', () => {
+  it('uses the physical slab once and reflects a render-target sub-view into GL coordinates', () => {
     const { state } = createGlState();
-    const renderer = makeRenderer();
-    registerRenderer(state, SpriteKind, renderer);
-
-    const sprite = createSprite();
-    sprite.alpha = 0;
+    registerGlRenderTextureResolver(state);
+    registerGlStandardMaterial(state);
+    const renderTexture = createRenderTexture({ height: 480, width: 720 });
+    setTextureUvFromPixelRect(renderTexture, 140, 160, 100, 80);
+    renderIntoGlRenderTexture(state, renderTexture, () => {});
+    const sprite = { data: { texture: renderTexture } } as Sprite;
 
-    prepareScene2DRender(state, sprite);
-    renderGlSprite(state, sprite);
+    drawGlSprite(state, makeRenderProxy(sprite));
 
-    expect(renderer.submit).not.toHaveBeenCalled();
+    const data = getGlRenderStateRuntime(state).quadBatchWriterInstanceData;
+    expect(data.slice(6, 12)).toEqual(new Float32Array([100, 80, 140 / 720, 1 - 160 / 480, 240 / 720, 1 - 240 / 480]));
   });
 
-  it('recurses into children and renders visible ones', () => {
-    const { state } = createGlState();
-    const renderer = makeRenderer();
-    registerRenderer(state, SpriteKind, renderer);
-
-    const parent = createSprite();
-    const child = createSprite();
-    addNodeChild(parent, child);
-
-    prepareScene2DRender(state, parent);
-    renderGlSprite(state, parent);
-
-    expect(renderer.submit).toHaveBeenCalledTimes(2);
+  it('resolves and draws the texture on flush', () => {
+    const { gl, state } = createGlState();
+    registerGlBitmapTextureResolver(state);
+    registerGlStandardMaterial(state);
+    drawGlSprite(state, makeRenderProxy(makeSprite()));
+    flushGlQuadBatchWriter(state);
+    expect(gl.drawElementsInstanced).toHaveBeenCalledOnce();
   });
 });

package/src/glStandardMaterial.test.ts

@@ -1,13 +1,13 @@
 import { getGlMaterialRenderer } from '@flighthq/render-gl/contract';
 import { StandardMaterialKind } from '@flighthq/types/contract';
 
-import { registerStandardGlMaterial, standardGlMaterialRenderer } from './glStandardMaterial';
+import { registerGlStandardMaterial, standardGlMaterialRenderer } from './glStandardMaterial';
 import { createGlState } from './glTestHelper';
 
-describe('registerStandardGlMaterial', () => {
+describe('registerGlStandardMaterial', () => {
   it('registers the default renderer under StandardMaterialKind', () => {
     const { state } = createGlState();
-    registerStandardGlMaterial(state);
+    registerGlStandardMaterial(state);
     expect(getGlMaterialRenderer(state, StandardMaterialKind)).toBe(standardGlMaterialRenderer);
   });
 });

package/src/glTextLabel.test.ts

@@ -4,8 +4,8 @@ import { createTextLabel, setTextLabelString } from '@flighthq/text/contract';
 import type { RenderProxy2D, TextLabel } from '@flighthq/types/contract';
 import { BatchFormat } from '@flighthq/types/contract';
 
-import { flushGlSpriteBatch } from './glSpriteBatch';
-import { registerStandardGlMaterial } from './glStandardMaterial';
+import { flushGlQuadBatchWriter } from './glQuadBatchWriter';
+import { registerGlStandardMaterial } from './glStandardMaterial';
 import { createGlState } from './glTestHelper';
 import type * as GlTextLabelModule from './glTextLabel';
 import { scopeModuleMocks } from './moduleMockTestHelper';
@@ -83,46 +83,46 @@ describe('defaultGlTextLabelRenderer', () => {
 describe('drawGlTextLabel', () => {
   it('returns early without writing to batch when text is empty', () => {
     const { state } = createGlState();
-    registerStandardGlMaterial(state);
+    registerGlStandardMaterial(state);
     drawGlTextLabel(state, makeTextProxy('', makeTextData()));
-    expect(getGlRenderStateRuntime(state).spriteBatchCount).toBe(0);
+    expect(getGlRenderStateRuntime(state).quadBatchWriterCount).toBe(0);
   });
 
   it('returns early without writing to batch when rendererData is null', () => {
     const { state } = createGlState();
-    registerStandardGlMaterial(state);
+    registerGlStandardMaterial(state);
     drawGlTextLabel(state, makeTextProxy('hello', null));
-    expect(getGlRenderStateRuntime(state).spriteBatchCount).toBe(0);
+    expect(getGlRenderStateRuntime(state).quadBatchWriterCount).toBe(0);
   });
 
   it('returns early without writing to batch when no material renderer is registered', () => {
     const { state } = createGlState();
     drawGlTextLabel(state, makeTextProxy('hello', makeTextData()));
-    expect(getGlRenderStateRuntime(state).spriteBatchCount).toBe(0);
+    expect(getGlRenderStateRuntime(state).quadBatchWriterCount).toBe(0);
   });
 
-  it('writes one instance to the sprite batch when text has content', () => {
+  it('writes one instance to the quad-batch writer when text has content', () => {
     const { state } = createGlState();
-    registerStandardGlMaterial(state);
+    registerGlStandardMaterial(state);
     drawGlTextLabel(state, makeTextProxy('hello', makeTextData()));
-    expect(getGlRenderStateRuntime(state).spriteBatchCount).toBe(1);
+    expect(getGlRenderStateRuntime(state).quadBatchWriterCount).toBe(1);
   });
 
   it('draws via drawElementsInstanced after flush', () => {
     const { state, gl } = createGlState();
-    registerStandardGlMaterial(state);
+    registerGlStandardMaterial(state);
     drawGlTextLabel(state, makeTextProxy('hello', makeTextData()));
-    flushGlSpriteBatch(state);
+    flushGlQuadBatchWriter(state);
     expect(gl.drawElementsInstanced).toHaveBeenCalled();
   });
 
   it('skips layout and rasterization on repeated calls when the content version is unchanged', () => {
     const { state } = createGlState();
-    registerStandardGlMaterial(state);
+    registerGlStandardMaterial(state);
     const data = makeTextData();
     const proxy = makeTextProxy('hello', data);
     drawGlTextLabel(state, proxy);
-    // Rasterization bumps the canvas resource's version (setImageResourceSource); a skipped raster leaves
+    // Rasterization bumps the canvas resource's version (invalidateImageResource); a skipped raster leaves
     // it untouched. First draw rasterizes (version → 1); the repeat is skipped.
     const rasterized = data.image.version;
     drawGlTextLabel(state, proxy);
@@ -131,7 +131,7 @@ describe('drawGlTextLabel', () => {
 
   it('re-rasterizes when the content version is bumped', () => {
     const { state } = createGlState();
-    registerStandardGlMaterial(state);
+    registerGlStandardMaterial(state);
     const data = makeTextData();
     const proxy = makeTextProxy('hello', data);
     drawGlTextLabel(state, proxy);
@@ -143,7 +143,7 @@ describe('drawGlTextLabel', () => {
 
   it('does not re-rasterize when only alpha changes (version unchanged)', () => {
     const { state } = createGlState();
-    registerStandardGlMaterial(state);
+    registerGlStandardMaterial(state);
     const data = makeTextData();
     const proxy = makeTextProxy('hello', data);
     drawGlTextLabel(state, proxy);

package/src/glTilemap.test.ts

@@ -1,33 +1,36 @@
 import type { RenderProxy2D } from '@flighthq/types/contract';
 
-import { flushGlSpriteBatch } from './glSpriteBatch';
-import { registerStandardGlMaterial } from './glStandardMaterial';
+import { flushGlQuadBatchWriter } from './glQuadBatchWriter';
+import { registerGlStandardMaterial } from './glStandardMaterial';
 import { createGlState } from './glTestHelper';
 import { defaultGlTilemapRenderer } from './glTilemap';
 
 function makeAtlas() {
   const img = document.createElement('img');
+  const image = createImageResource(img);
+  image.width = 64;
+  image.height = 64;
   return {
-    image: { source: img, width: 64, height: 64 },
     regions: [{ x: 0, y: 0, width: 16, height: 16 }],
+    texture: createTexture({ dimension: '2d', source: image }),
   };
 }
 
-function makeTileset(atlasOverride?: unknown) {
-  return {
-    atlas: atlasOverride !== undefined ? atlasOverride : makeAtlas(),
-    tileWidth: 16,
-    tileHeight: 16,
-  };
+function createAtlasGlState() {
+  const result = createGlState();
+  registerGlImageTextureResolver(result.state);
+  return result;
 }
 
 function makeTilemapNode(data: Record<string, unknown> = {}): RenderProxy2D {
   return {
     source: {
       data: {
-        tileset: makeTileset(),
+        atlas: makeAtlas(),
         columns: 2,
         rows: 2,
+        tileHeight: 16,
+        tileWidth: 16,
         tiles: [0, 0, 0, 0],
         ...data,
       },
@@ -53,75 +56,69 @@ describe('defaultGlTilemapRenderer', () => {
 });
 
 describe('defaultGlTilemapRenderer.submit', () => {
-  it('returns early without drawing when tileset is null', () => {
-    const { state, gl } = createGlState();
-    registerStandardGlMaterial(state);
-    defaultGlTilemapRenderer.submit(state, makeTilemapNode({ tileset: null }));
-    flushGlSpriteBatch(state);
-    expect(gl.drawElementsInstanced).not.toHaveBeenCalled();
-  });
-
   it('returns early without drawing when atlas is null', () => {
-    const { state, gl } = createGlState();
-    registerStandardGlMaterial(state);
-    defaultGlTilemapRenderer.submit(state, makeTilemapNode({ tileset: makeTileset(null) }));
-    flushGlSpriteBatch(state);
+    const { state, gl } = createAtlasGlState();
+    registerGlStandardMaterial(state);
+    defaultGlTilemapRenderer.submit(state, makeTilemapNode({ atlas: null }));
+    flushGlQuadBatchWriter(state);
     expect(gl.drawElementsInstanced).not.toHaveBeenCalled();
   });
 
-  it('returns early without drawing when atlas.image is null', () => {
-    const { state, gl } = createGlState();
-    registerStandardGlMaterial(state);
-    defaultGlTilemapRenderer.submit(
-      state,
-      makeTilemapNode({ tileset: { atlas: { image: null, regions: [] }, tileWidth: 16, tileHeight: 16 } }),
-    );
-    flushGlSpriteBatch(state);
+  it('returns early without drawing when atlas.texture is null', () => {
+    const { state, gl } = createAtlasGlState();
+    registerGlStandardMaterial(state);
+    defaultGlTilemapRenderer.submit(state, makeTilemapNode({ atlas: { regions: [], texture: null } }));
+    flushGlQuadBatchWriter(state);
     expect(gl.drawElementsInstanced).not.toHaveBeenCalled();
   });
 
-  it('returns early without drawing when atlas.image.source is null', () => {
-    const { state, gl } = createGlState();
-    registerStandardGlMaterial(state);
+  it('returns early without drawing when atlas Texture is unbound', () => {
+    const { state, gl } = createAtlasGlState();
+    registerGlStandardMaterial(state);
     defaultGlTilemapRenderer.submit(
       state,
-      makeTilemapNode({ tileset: { atlas: { image: { source: null }, regions: [] }, tileWidth: 16, tileHeight: 16 } }),
+      makeTilemapNode({
+        atlas: { regions: [], texture: createTexture() },
+      }),
     );
-    flushGlSpriteBatch(state);
+    flushGlQuadBatchWriter(state);
     expect(gl.drawElementsInstanced).not.toHaveBeenCalled();
   });
 
   it('returns early without drawing when columns is 0', () => {
-    const { state, gl } = createGlState();
-    registerStandardGlMaterial(state);
+    const { state, gl } = createAtlasGlState();
+    registerGlStandardMaterial(state);
     defaultGlTilemapRenderer.submit(state, makeTilemapNode({ columns: 0 }));
-    flushGlSpriteBatch(state);
+    flushGlQuadBatchWriter(state);
     expect(gl.drawElementsInstanced).not.toHaveBeenCalled();
   });
 
   it('returns early without drawing when rows is 0', () => {
-    const { state, gl } = createGlState();
-    registerStandardGlMaterial(state);
+    const { state, gl } = createAtlasGlState();
+    registerGlStandardMaterial(state);
     defaultGlTilemapRenderer.submit(state, makeTilemapNode({ rows: 0 }));
-    flushGlSpriteBatch(state);
+    flushGlQuadBatchWriter(state);
     expect(gl.drawElementsInstanced).not.toHaveBeenCalled();
   });
 
   it('draws all valid tiles in a single instanced call', () => {
-    const { state, gl } = createGlState();
-    registerStandardGlMaterial(state);
+    const { state, gl } = createAtlasGlState();
+    registerGlStandardMaterial(state);
     defaultGlTilemapRenderer.submit(state, makeTilemapNode());
-    flushGlSpriteBatch(state);
+    flushGlQuadBatchWriter(state);
     expect(gl.drawElementsInstanced).toHaveBeenCalledTimes(1);
     expect(gl.drawElementsInstanced).toHaveBeenCalledWith(expect.anything(), 6, expect.anything(), 0, 4);
   });
 
   it('excludes out-of-range tile ids from the instanced draw count', () => {
-    const { state, gl } = createGlState();
-    registerStandardGlMaterial(state);
+    const { state, gl } = createAtlasGlState();
+    registerGlStandardMaterial(state);
     defaultGlTilemapRenderer.submit(state, makeTilemapNode({ tiles: [0, 99, 99, 0] }));
-    flushGlSpriteBatch(state);
+    flushGlQuadBatchWriter(state);
     expect(gl.drawElementsInstanced).toHaveBeenCalledTimes(1);
     expect(gl.drawElementsInstanced).toHaveBeenCalledWith(expect.anything(), 6, expect.anything(), 0, 2);
   });
 });
+import { createImageResource } from '@flighthq/image/contract';
+import { registerGlImageTextureResolver } from '@flighthq/render-gl/contract';
+import { createTexture } from '@flighthq/texture/contract';

package/src/glVelocity.test.ts

@@ -1,6 +1,6 @@
 import { createParticleEmitter2D, reserveParticleEmitter2D } from '@flighthq/particleemitter/contract';
+import { createQuadBatch, getQuadBatchRuntime } from '@flighthq/quadbatch/contract';
 import { createDisplayObject } from '@flighthq/scene2d/contract';
-import { createQuadBatch, getQuadBatchRuntime } from '@flighthq/sprite/contract';
 import type { QuadBatchRuntime, TextureAtlas, TextureAtlasRegion } from '@flighthq/types/contract';
 import { QuadBatchKind } from '@flighthq/types/contract';
 import { beginVelocityFrame, contributeVelocity, createVelocityField } from '@flighthq/velocity/contract';
@@ -42,7 +42,7 @@ describe('defaultGlParticleEmitter2DVelocityWriter', () => {
     const { state } = createGlState();
     const target = createGlVelocityTarget(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 atlas = { texture: null, regions: [region] } as TextureAtlas;
     const emitter = createParticleEmitter2D();
     reserveParticleEmitter2D(emitter, 2);
     emitter.data.atlas = atlas;
@@ -69,7 +69,7 @@ describe('defaultGlQuadBatchVelocityWriter', () => {
     const { state } = createGlState();
     const target = createGlVelocityTarget(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 atlas = { texture: null, regions: [region] } as TextureAtlas;
     // Two vector2 instances at distinct positions, each moving independently.
     const batch = createQuadBatch({
       data: {
@@ -94,7 +94,7 @@ describe('defaultGlQuadBatchVelocityWriter', () => {
     const { state } = createGlState();
     const target = createGlVelocityTarget(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 atlas = { texture: null, regions: [region] } as TextureAtlas;
     const batch = createQuadBatch({
       data: { atlas, ids: new Uint16Array([0]), instanceCount: 1, transforms: new Float32Array([0, 0]) },
     });

package/dist/glBitmap.d.ts

@@ -1,4 +0,0 @@
-import type { Scene2DRenderer, GlRenderState, RenderProxy2D } from '@flighthq/types/contract';
-export declare function drawGlBitmap(state: GlRenderState, renderProxy: RenderProxy2D): void;
-export declare const defaultGlBitmapRenderer: Scene2DRenderer;
-//# sourceMappingURL=glBitmap.d.ts.map

package/dist/glBitmap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"glBitmap.d.ts","sourceRoot":"","sources":["../src/glBitmap.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAEV,eAAe,EACf,aAAa,EAIb,aAAa,EACd,MAAM,0BAA0B,CAAC;AAgClC,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,GAAG,IAAI,CAwEnF;AAED,eAAO,MAAM,uBAAuB,EAAE,eAKrC,CAAC"}