@flighthq/bitmapfont 0.3.0-next.1315.1d4eb64 → 0.3.0-next.1392.f0bd0cc

package/dist/bitmapFontFromGlyphAtlas.d.ts

@@ -0,0 +1,19 @@
+import type { BitmapFont, GlyphAtlas } from '@flighthq/types/contract';
+/** Freezes a live `GlyphAtlas` into a static `BitmapFont` — the dynamic cache's contents as a fixed
+ *  font, so a build step can bake what a run actually rasterized and ship it instead of rasterizing
+ *  again at startup.
+ *
+ *  This lives in `@flighthq/bitmapfont` rather than in `@flighthq/glyphatlas` because a conversion
+ *  constructor belongs to the package that owns the PRODUCT, the same way `createImageResourceFromBitmap`
+ *  lives in `@flighthq/image`. Every type is in `@flighthq/types`, so reading a `GlyphAtlas` here costs
+ *  no dependency on the atlas package, and `glyphatlas` gains no edge to `textureatlas` or `texture`.
+ *
+ *  The page is CPU-only: the atlas's own bitmap is already a valid `TextureSource` under the flat
+ *  texture model, so the font's page is a `TextureAtlas` over a bitmap-sourced `Texture` with no GPU
+ *  work and no readback. Whichever backend consumes the font uploads it later through the ordinary
+ *  kind-keyed resolver path, exactly as it would for any other bitmap-sourced texture.
+ *
+ *  The result is a snapshot: later rasterization into the source atlas does not reach the font, and the
+ *  font holds its own reference to the atlas bitmap. */
+export declare function createBitmapFontFromGlyphAtlas(atlas: Readonly<GlyphAtlas>): BitmapFont;
+//# sourceMappingURL=bitmapFontFromGlyphAtlas.d.ts.map

package/dist/bitmapFontFromGlyphAtlas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitmapFontFromGlyphAtlas.d.ts","sourceRoot":"","sources":["../src/bitmapFontFromGlyphAtlas.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAuB,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAI5F;;;;;;;;;;;;;;;wDAewD;AACxD,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,UAAU,CAyBtF"}

package/dist/bitmapFontFromGlyphAtlas.js

@@ -0,0 +1,46 @@
+import { createTexture } from '@flighthq/texture/contract';
+import { createTextureAtlas } from '@flighthq/textureatlas/contract';
+import { createBitmapFont } from './bitmapFont';
+/** Freezes a live `GlyphAtlas` into a static `BitmapFont` — the dynamic cache's contents as a fixed
+ *  font, so a build step can bake what a run actually rasterized and ship it instead of rasterizing
+ *  again at startup.
+ *
+ *  This lives in `@flighthq/bitmapfont` rather than in `@flighthq/glyphatlas` because a conversion
+ *  constructor belongs to the package that owns the PRODUCT, the same way `createImageResourceFromBitmap`
+ *  lives in `@flighthq/image`. Every type is in `@flighthq/types`, so reading a `GlyphAtlas` here costs
+ *  no dependency on the atlas package, and `glyphatlas` gains no edge to `textureatlas` or `texture`.
+ *
+ *  The page is CPU-only: the atlas's own bitmap is already a valid `TextureSource` under the flat
+ *  texture model, so the font's page is a `TextureAtlas` over a bitmap-sourced `Texture` with no GPU
+ *  work and no readback. Whichever backend consumes the font uploads it later through the ordinary
+ *  kind-keyed resolver path, exactly as it would for any other bitmap-sourced texture.
+ *
+ *  The result is a snapshot: later rasterization into the source atlas does not reach the font, and the
+ *  font holds its own reference to the atlas bitmap. */
+export function createBitmapFontFromGlyphAtlas(atlas) {
+    const runtime = atlas.runtime;
+    const glyphs = [];
+    for (const [codepoint, entry] of runtime.entries) {
+        glyphs.push({
+            advance: entry.advance,
+            bearingX: entry.bearingX,
+            bearingY: entry.bearingY,
+            codepoint,
+            height: entry.height,
+            // The dynamic atlas is a single growing bitmap, so every glyph is on page 0.
+            page: 0,
+            width: entry.width,
+            x: entry.x,
+            y: entry.y,
+        });
+    }
+    // Regions stay empty: a bitmap font addresses its glyphs through its own glyph table, so the page
+    // exists to carry the pixels, not to name sub-rectangles.
+    const page = createTextureAtlas({ texture: createTexture({ source: runtime.bitmap }) });
+    return createBitmapFont({
+        glyphs,
+        metrics: { ...runtime.metrics },
+        pages: [page],
+    });
+}
+//# sourceMappingURL=bitmapFontFromGlyphAtlas.js.map

package/dist/bitmapFontFromGlyphAtlas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitmapFontFromGlyphAtlas.js","sourceRoot":"","sources":["../src/bitmapFontFromGlyphAtlas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAGrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEhD;;;;;;;;;;;;;;;wDAewD;AACxD,MAAM,UAAU,8BAA8B,CAAC,KAA2B;IACxE,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;IAC9B,MAAM,MAAM,GAA0B,EAAE,CAAC;IACzC,KAAK,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;QACjD,MAAM,CAAC,IAAI,CAAC;YACV,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,SAAS;YACT,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,6EAA6E;YAC7E,IAAI,EAAE,CAAC;YACP,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,CAAC,EAAE,KAAK,CAAC,CAAC;YACV,CAAC,EAAE,KAAK,CAAC,CAAC;SACX,CAAC,CAAC;IACL,CAAC;IACD,kGAAkG;IAClG,0DAA0D;IAC1D,MAAM,IAAI,GAAG,kBAAkB,CAAC,EAAE,OAAO,EAAE,aAAa,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;IACxF,OAAO,gBAAgB,CAAC;QACtB,MAAM;QACN,OAAO,EAAE,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE;QAC/B,KAAK,EAAE,CAAC,IAAI,CAAC;KACd,CAAC,CAAC;AACL,CAAC"}

package/dist/contract.d.ts

@@ -1,3 +1,4 @@
+export * from './bitmapFontFromGlyphAtlas';
 export * from './bitmapFont';
 export * from './bitmapFontGlyphSource';
 //# sourceMappingURL=contract.d.ts.map

package/dist/contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC"}

package/dist/contract.js

@@ -1,3 +1,4 @@
+export * from './bitmapFontFromGlyphAtlas';
 export * from './bitmapFont';
 export * from './bitmapFontGlyphSource';
 //# sourceMappingURL=contract.js.map

package/dist/contract.js.map

@@ -1 +1 @@
-{"version":3,"file":"contract.js","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"contract.js","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC"}

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { createBitmapFont, createGlyphSourceFromBitmapFont, getBitmapFontGlyph, getBitmapFontKerning, getBitmapFontMetrics, getBitmapFontPage, getBitmapFontPages, } from './contract';
+export { createBitmapFontFromGlyphAtlas, createBitmapFont, createGlyphSourceFromBitmapFont, getBitmapFontGlyph, getBitmapFontKerning, getBitmapFontMetrics, getBitmapFontPage, getBitmapFontPages, } from './contract';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,+BAA+B,EAC/B,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAC9B,gBAAgB,EAChB,+BAA+B,EAC/B,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1,2 +1,2 @@
-export { createBitmapFont, createGlyphSourceFromBitmapFont, getBitmapFontGlyph, getBitmapFontKerning, getBitmapFontMetrics, getBitmapFontPage, getBitmapFontPages, } from './contract';
+export { createBitmapFontFromGlyphAtlas, createBitmapFont, createGlyphSourceFromBitmapFont, getBitmapFontGlyph, getBitmapFontKerning, getBitmapFontMetrics, getBitmapFontPage, getBitmapFontPages, } from './contract';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,+BAA+B,EAC/B,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAC9B,gBAAgB,EAChB,+BAA+B,EAC/B,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,YAAY,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flighthq/bitmapfont",
-  "version": "0.3.0-next.1315.1d4eb64",
+  "version": "0.3.0-next.1392.f0bd0cc",
   "repository": {
     "type": "git",
     "url": "https://github.com/flighthq/flight.git",
@@ -36,10 +36,12 @@
     "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
   },
   "dependencies": {
-    "@flighthq/textureatlas": "0.3.0-next.1315.1d4eb64",
-    "@flighthq/types": "0.3.0-next.1315.1d4eb64"
+    "@flighthq/texture": "0.3.0-next.1392.f0bd0cc",
+    "@flighthq/textureatlas": "0.3.0-next.1392.f0bd0cc",
+    "@flighthq/types": "0.3.0-next.1392.f0bd0cc"
   },
   "devDependencies": {
+    "@flighthq/glyphatlas": "*",
     "typescript": "^5.3.0"
   },
   "description": "Static bitmap font — an immutable pre-baked atlas + glyph/kerning/metrics tables implementing the GlyphSource seam, the static sibling of the dynamic glyphatlas",

package/src/bitmapFontFromGlyphAtlas.test.ts

@@ -0,0 +1,81 @@
+import { createGlyphAtlas, getGlyphAtlasEntry, setGlyphRasterizerBackend } from '@flighthq/glyphatlas/contract';
+import type { GlyphRasterizerBackend } from '@flighthq/types/contract';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { getBitmapFontGlyph, getBitmapFontMetrics } from './bitmapFont';
+import { createBitmapFontFromGlyphAtlas } from './bitmapFontFromGlyphAtlas';
+
+function backendProducing(width: number, height: number): GlyphRasterizerBackend {
+  return {
+    measureMetrics: () => ({ ascent: 12, descent: 3, lineGap: 1 }),
+    rasterize: () => ({
+      advance: width,
+      bearingX: 1,
+      bearingY: 2,
+      height,
+      pixels: new Uint8ClampedArray(width * height * 4),
+      width,
+    }),
+  };
+}
+
+describe('createBitmapFontFromGlyphAtlas', () => {
+  afterEach(() => setGlyphRasterizerBackend(null));
+
+  function bakedFromTwoGlyphs() {
+    setGlyphRasterizerBackend(backendProducing(8, 8));
+    const atlas = createGlyphAtlas({ fontFamily: 'mock', fontSize: 16, height: 64, width: 64 });
+    getGlyphAtlasEntry(atlas, 65);
+    getGlyphAtlasEntry(atlas, 66);
+    return { atlas, font: createBitmapFontFromGlyphAtlas(atlas) };
+  }
+
+  it('carries every cached glyph across with its rect and pen data', () => {
+    const { atlas, font } = bakedFromTwoGlyphs();
+
+    const source = getGlyphAtlasEntry(atlas, 65)!;
+    const baked = getBitmapFontGlyph(font, 65)!;
+
+    expect(baked).not.toBeNull();
+    expect(baked.x).toBe(source.x);
+    expect(baked.y).toBe(source.y);
+    expect(baked.width).toBe(source.width);
+    expect(baked.advance).toBe(source.advance);
+    expect(baked.bearingY).toBe(source.bearingY);
+    expect(getBitmapFontGlyph(font, 66)).not.toBeNull();
+  });
+
+  it('carries the atlas metrics rather than re-deriving them', () => {
+    const { font } = bakedFromTwoGlyphs();
+    expect(getBitmapFontMetrics(font)).toEqual({ ascent: 12, descent: 3, lineGap: 1 });
+  });
+
+  // The page is CPU-only: the atlas bitmap is already a valid texture source under the flat model, so
+  // baking needs no GPU work and no readback.
+  it('builds a single page whose texture is sourced from the atlas bitmap', () => {
+    const { atlas, font } = bakedFromTwoGlyphs();
+
+    expect(font.pages).toHaveLength(1);
+    expect(font.pages[0]!.texture!.source).toBe(atlas.runtime.bitmap);
+  });
+
+  // A bake is a snapshot. Rasterizing more glyphs into the source atlas afterwards must not reach the
+  // font, or "bake" would just be another view of a live cache.
+  it('does not gain glyphs rasterized into the atlas after the bake', () => {
+    const { atlas, font } = bakedFromTwoGlyphs();
+
+    getGlyphAtlasEntry(atlas, 67);
+
+    expect(getBitmapFontGlyph(font, 67)).toBeNull();
+  });
+
+  it('bakes an empty atlas to a font with no glyphs rather than failing', () => {
+    setGlyphRasterizerBackend(backendProducing(8, 8));
+    const atlas = createGlyphAtlas({ fontFamily: 'mock', fontSize: 16, height: 64, width: 64 });
+
+    const font = createBitmapFontFromGlyphAtlas(atlas);
+
+    expect(getBitmapFontGlyph(font, 65)).toBeNull();
+    expect(font.pages).toHaveLength(1);
+  });
+});