@lightningtv/renderer 2.16.1 → 3.2.3

package/src/core/text-rendering/TrFontManager.ts

@@ -1,183 +0,0 @@
-/*
- * If not stated otherwise in this file or this component's LICENSE file the
- * following copyright and licenses apply:
- *
- * Copyright 2023 Comcast Cable Communications Management, LLC.
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import type { TrFontFace } from './font-face-types/TrFontFace.js';
-import type { TextRendererMap, TrFontProps } from './renderers/TextRenderer.js';
-
-const weightConversions: { [key: string]: number } = {
-  normal: 400,
-  bold: 700,
-  bolder: 900,
-  lighter: 100,
-};
-
-const fontWeightToNumber = (weight: string | number): number => {
-  if (typeof weight === 'number') {
-    return weight;
-  }
-
-  return weightConversions[weight] || 400;
-};
-
-function resolveFontToUse(
-  familyMapsByPriority: FontFamilyMap[],
-  family: string,
-  weightIn: string | number,
-  style: string,
-  stretch: string,
-): TrFontFace | undefined {
-  let weight = fontWeightToNumber(weightIn);
-
-  for (const fontFamiles of familyMapsByPriority) {
-    const fontFaces = fontFamiles[family];
-
-    if (!fontFaces) {
-      continue;
-    }
-
-    if (fontFaces.size === 1) {
-      // No Exact match found, find nearest weight match
-      console.warn(
-        `TrFontManager: Only one font face found for family: '${family}' - will be used for all weights and styles`,
-      );
-
-      return fontFaces.values().next().value as TrFontFace;
-    }
-
-    const weightMap = new Map<number, TrFontFace>();
-    for (const fontFace of fontFaces) {
-      const fontFamilyWeight = fontWeightToNumber(fontFace.descriptors.weight);
-      if (
-        fontFamilyWeight === weight &&
-        fontFace.descriptors.style === style &&
-        fontFace.descriptors.stretch === stretch
-      ) {
-        return fontFace;
-      }
-
-      weightMap.set(fontFamilyWeight, fontFace);
-    }
-
-    // No Exact match found, find nearest weight match
-    const msg = `TrFontManager: No exact match: '${family} Weight: ${weight} Style: ${style} Stretch: ${stretch}'`;
-    console.error(msg);
-
-    // Follow the CSS font-weight algorithm to find the nearest weight match
-    // https://www.w3.org/TR/2018/REC-css-fonts-3-20180920/#font-matching-algorithm
-
-    if (weight === 400 && weightMap.has(500)) {
-      return weightMap.get(500);
-    }
-
-    if (weight === 500 && weightMap.has(400)) {
-      return weightMap.get(400);
-    }
-
-    if (weight < 400) {
-      while (weight > 0) {
-        if (weightMap.has(weight)) {
-          return weightMap.get(weight);
-        }
-        weight -= 100;
-      }
-      // reset back for the next loop
-      weight = 600;
-    }
-
-    while (weight < 1000) {
-      if (weightMap.has(weight)) {
-        return weightMap.get(weight);
-      }
-      weight += 100;
-    }
-
-    // finally check lower again
-    weight = 500;
-    while (weight > 0) {
-      if (weightMap.has(weight)) {
-        return weightMap.get(weight);
-      }
-      weight -= 100;
-    }
-  }
-
-  return;
-}
-
-/**
- * Structure mapping font family names to a set of font faces.
- */
-export interface FontFamilyMap {
-  [familyName: string]: Set<TrFontFace>;
-}
-
-export class TrFontManager {
-  private fontCache = new Map<string, TrFontFace>();
-
-  constructor(private textRenderers: Partial<TextRendererMap>) {
-    // Intentionally left blank
-  }
-
-  public addFontFace(font: TrFontFace): void {
-    // All the font face to all of the text renderers that support it
-    for (const trId in this.textRenderers) {
-      const tr = this.textRenderers[trId as keyof TextRendererMap];
-      if (tr && tr.isFontFaceSupported(font)) {
-        tr.addFontFace(font);
-      }
-    }
-  }
-
-  /**
-   * Utility method to resolve a single font face from a list of prioritized family maps based on
-   * a set of font properties.
-   *
-   * @remarks
-   * These are to be used by a text renderer to resolve a font face if needed.
-   *
-   * @param familyMapsByPriority
-   * @param props
-   * @returns
-   */
-  public resolveFontFace(
-    familyMapsByPriority: FontFamilyMap[],
-    props: TrFontProps,
-    rendererType: 'canvas' | 'sdf',
-  ): TrFontFace | undefined {
-    const { fontFamily, fontWeight, fontStyle, fontStretch } = props;
-    const fontCacheString = `${rendererType}_${fontFamily}_${fontStyle}_${fontWeight}_${fontStretch}`;
-
-    if (this.fontCache.has(fontCacheString) === true) {
-      return this.fontCache.get(fontCacheString);
-    }
-
-    const resolvedFont = resolveFontToUse(
-      familyMapsByPriority,
-      fontFamily,
-      fontWeight,
-      fontStyle,
-      fontStretch,
-    );
-    if (resolvedFont !== undefined) {
-      this.fontCache.set(fontCacheString, resolvedFont);
-    }
-
-    return resolvedFont;
-  }
-}

package/src/core/text-rendering/font-face-types/SdfTrFontFace/SdfTrFontFace.ts

@@ -1,176 +0,0 @@
-/*
- * If not stated otherwise in this file or this component's LICENSE file the
- * following copyright and licenses apply:
- *
- * Copyright 2023 Comcast Cable Communications Management, LLC.
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// import type { Renderer } from '../../../Renderer';
-import { assertTruthy } from '../../../../utils.js';
-import type { Stage } from '../../../Stage.js';
-import { WebGlCoreRenderer } from '../../../renderers/webgl/WebGlCoreRenderer.js';
-import { ImageTexture } from '../../../textures/ImageTexture.js';
-import {
-  TrFontFace,
-  type NormalizedFontMetrics,
-  type TrFontFaceOptions,
-} from '../TrFontFace.js';
-import { fetchJson } from '../utils.js';
-import type { FontShaper } from './internal/FontShaper.js';
-import { SdfFontShaper, type SdfFontData } from './internal/SdfFontShaper.js';
-
-type SdfFontType = 'ssdf' | 'msdf';
-
-declare module '../TrFontFace.js' {
-  interface TrFontFaceMap {
-    ssdf: SdfTrFontFace<'ssdf'>;
-    msdf: SdfTrFontFace<'msdf'>;
-  }
-}
-
-interface GlyphAtlasEntry {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-}
-
-export interface SdfTrFontFaceOptions extends TrFontFaceOptions {
-  atlasUrl: string;
-  atlasDataUrl: string;
-  stage: Stage;
-}
-
-export class SdfTrFontFace<
-  FontTypeT extends SdfFontType = SdfFontType,
-> extends TrFontFace {
-  public readonly type: FontTypeT;
-  public readonly texture: ImageTexture;
-  /**
-   * Height of the tallest character in the font including the whitespace above it
-   * in SDF/vertex units.
-   */
-  public readonly maxCharHeight: number = 0;
-  public readonly shaper: FontShaper | undefined;
-  public readonly glyphMap: Map<number, SdfFontData['chars'][0]> = new Map();
-  public data: SdfFontData | undefined;
-
-  constructor(type: FontTypeT, options: SdfTrFontFaceOptions) {
-    super(options);
-    const { atlasUrl, atlasDataUrl, stage } = options;
-    this.type = type;
-    const renderer = stage.renderer;
-    assertTruthy(
-      renderer instanceof WebGlCoreRenderer,
-      'SDF Font Faces can only be used with the WebGL Renderer',
-    );
-
-    // Load image
-    this.texture = stage.txManager.createTexture('ImageTexture', {
-      src: atlasUrl,
-      // IMPORTANT: The SDF shader requires the alpha channel to NOT be
-      // premultiplied on the atlas texture. If it is premultiplied, the
-      // rendering of SDF glyphs (especially single-channel SDF fonts) will
-      // be very jagged.
-      premultiplyAlpha: false,
-    });
-
-    // Load the texture
-    stage.txManager.loadTexture(this.texture, true);
-
-    // FIXME This is a stop-gap solution to avoid Font Face textures to be cleaned up
-    // Ideally we do want to clean up the textures if they're not being used to save as much memory as possible
-    // However, we need to make sure that the font face is reloaded if the texture is cleaned up and needed again
-    // and make sure the SdfFontRenderer is properly guarded against textures being reloaded
-    // for now this will do the trick and the increase on memory is not that big
-    this.texture.preventCleanup = true;
-
-    this.texture.on('loaded', () => {
-      this.checkLoaded();
-      // Make sure we mark the stage for a re-render (in case the font's texture was freed and reloaded)
-      stage.requestRender();
-    });
-
-    // Set this.data to the fetched data from dataUrl
-    fetchJson(atlasDataUrl)
-      .then((response) => {
-        this.data = JSON.parse(response as unknown as string) as SdfFontData;
-        assertTruthy(this.data);
-        // Add all the glyphs to the glyph map
-
-        let maxCharHeight = 0;
-        this.data.chars.forEach((glyph) => {
-          this.glyphMap.set(glyph.id, glyph);
-          const charHeight = glyph.yoffset + glyph.height;
-          if (charHeight > maxCharHeight) {
-            maxCharHeight = charHeight;
-          }
-        });
-
-        (this.maxCharHeight as number) = maxCharHeight;
-        // We know `data` is defined here, because we just set it
-
-        (this.shaper as FontShaper) = new SdfFontShaper(
-          this.data,
-          this.glyphMap,
-        );
-
-        // If the metrics aren't provided explicitly in the font face options,
-        // Gather them from the metrics added by the msdf-generator tool ()
-        // If they are missing then we throw an error.
-        if (!this.metrics) {
-          if (this.data?.lightningMetrics) {
-            const { ascender, descender, lineGap, unitsPerEm } =
-              this.data.lightningMetrics;
-            (this.metrics as NormalizedFontMetrics | null) = {
-              ascender: ascender / unitsPerEm,
-              descender: descender / unitsPerEm,
-              lineGap: lineGap / unitsPerEm,
-            };
-          } else {
-            throw new Error(
-              `Font metrics not found in ${this.type} font ${this.fontFamily}. ` +
-                'Make sure you are using the latest version of the Lightning ' +
-                '3 `msdf-generator` tool to generate your SDF fonts.',
-            );
-          }
-        }
-
-        this.checkLoaded();
-      })
-      .catch(console.error);
-  }
-
-  getAtlasEntry(glyphId: number): GlyphAtlasEntry {
-    const glyph = this.glyphMap.get(glyphId);
-    if (glyph === undefined) {
-      throw new Error(`Glyph ${glyphId} not found in font ${this.fontFamily}`);
-    }
-    return {
-      x: glyph.x,
-      y: glyph.y,
-      width: glyph.width,
-      height: glyph.height,
-    };
-  }
-
-  private checkLoaded(): void {
-    if (this.loaded) return;
-    if (this.texture.state === 'loaded' && this.data) {
-      (this.loaded as boolean) = true;
-      this.emit('loaded');
-    }
-  }
-}

package/src/core/text-rendering/font-face-types/SdfTrFontFace/internal/FontShaper.ts

@@ -1,139 +0,0 @@
-/*
- * If not stated otherwise in this file or this component's LICENSE file the
- * following copyright and licenses apply:
- *
- * Copyright 2023 Comcast Cable Communications Management, LLC.
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import type { PeekableIterator } from '../../../renderers/SdfTextRenderer/internal/PeekableGenerator.js';
-
-/**
- * HarfBuzz compatible glyph position info
- */
-export interface GlyphPosition {
-  /**
-   * how much the line advances after drawing this glyph when setting text in horizontal direction.
-   */
-  xAdvance: number;
-  /**
-   * how much the line advances after drawing this glyph when setting text in vertical direction.
-   */
-  yAdvance: number;
-  /**
-   * how much the glyph moves on the X-axis before drawing it, this should not affect how much the line advances.
-   */
-  xOffset: number;
-  /**
-   * how much the glyph moves on the Y-axis before drawing it, this should not affect how much the line advances.
-   */
-  yOffset: number;
-}
-
-/**
- * HarfBuzz compatible glyph info
- */
-export interface GlyphInfo {
-  /**
-   * Glyph ID
-   */
-  glyphId: number;
-
-  /**
-   * First codepoint in the cluster this glyph was mapped from.
-   */
-  codepoint: number;
-
-  /**
-   * the index of the character in the original text that corresponds to this hb_glyph_info_t
-   * This is useful for mapping back from glyphs to characters.
-   */
-  cluster: number;
-}
-
-/**
- * HarfBuzz compatible glyph extents
- */
-export interface GlyphExtents {
-  /**
-   * The X offset from the origin to the leftmost part of the glyph.
-   * This is negative for right-to-left scripts.
-   */
-  xBearing: number;
-
-  /**
-   * The Y offset from the origin to the topmost part of the glyph.
-   * This is negative for bottom-to-top scripts.
-   */
-  yBearing: number;
-
-  /**
-   * Distance from the top extremum of the glyph to the bottom extremum.
-   * This is always positive.
-   */
-  width: number;
-
-  /**
-   * Distance from the left extremum of the glyph to the right extremum.
-   * This is always positive.
-   */
-  height: number;
-}
-
-export interface UnmappedCharacterInfo {
-  mapped: false;
-
-  /**
-   * The Unicode code point of the character.
-   */
-  codepoint: number;
-
-  /**
-   * The index of the character in the original text that corresponds to this hb_glyph_info_t
-   * This is useful for mapping back from glyphs to characters.
-   */
-  cluster: number;
-}
-
-export type MappedGlyphInfo = { mapped: true } & GlyphInfo &
-  GlyphPosition &
-  GlyphExtents;
-
-/**
- * For performance reasons, all properties are required to reduce need for checking for undefined values.
- */
-export interface FontShaperProps {
-  /**
-   * Letter spacing
-   *
-   * @default 0
-   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/letter-spacing
-   **/
-  letterSpacing: number;
-}
-
-export abstract class FontShaper {
-  /**
-   * Returns the glyph IDs of the next
-   *
-   * @remarks
-   * If this returns undefined, a glyph for the next codepoint(s) could not be found.
-   *
-   * @param codepoints
-   */
-  abstract shapeText(
-    props: FontShaperProps,
-    codepoints: PeekableIterator<number>,
-  ): Generator<MappedGlyphInfo | UnmappedCharacterInfo, void>;
-}

package/src/core/text-rendering/font-face-types/SdfTrFontFace/internal/SdfFontShaper.test.ts

@@ -1,173 +0,0 @@
-/*
- * If not stated otherwise in this file or this component's LICENSE file the
- * following copyright and licenses apply:
- *
- * Copyright 2023 Comcast Cable Communications Management, LLC.
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { describe, expect, it } from 'vitest';
-
-import { PeekableIterator } from '../../../renderers/SdfTextRenderer/internal/PeekableGenerator.js';
-import { SdfFontShaper, type SdfFontData } from './SdfFontShaper.js';
-import { getUnicodeCodepoints } from '../../../renderers/SdfTextRenderer/internal/getUnicodeCodepoints.js';
-import sdfData from 'test/mockdata/Ubuntu-Bold.msdf.json';
-
-const glyphMap = new Map<number, SdfFontData['chars'][0]>();
-sdfData.chars.forEach((glyph) => {
-  glyphMap.set(glyph.id, glyph);
-});
-
-// TODO: Need tests for
-// - mapped = false
-
-describe('SdfFontShaper', () => {
-  it('should be able to shape text.', () => {
-    const shaper = new SdfFontShaper(
-      sdfData as unknown as SdfFontData,
-      glyphMap,
-    );
-    const peekableCodepoints = new PeekableIterator(
-      getUnicodeCodepoints('Hi!'),
-    );
-    const glyphs = shaper.shapeText({ letterSpacing: 0 }, peekableCodepoints);
-    // H
-    expect(glyphs.next().value).toEqual({
-      mapped: true,
-      codepoint: 72,
-      glyphId: 72,
-      cluster: 0,
-      width: 28,
-      height: 33,
-      xAdvance: 30.828,
-      yAdvance: 0,
-      xOffset: 1,
-      yOffset: 5.592,
-      xBearing: 0,
-      yBearing: 0,
-    });
-    // i
-    expect(glyphs.next().value).toEqual({
-      mapped: true,
-      codepoint: 105,
-      glyphId: 105,
-      cluster: 1,
-      width: 11,
-      height: 36,
-      xAdvance: 12.138,
-      yAdvance: 0,
-      xOffset: 0,
-      yOffset: 2.592,
-      xBearing: 0,
-      yBearing: 0,
-    });
-    // !
-    expect(glyphs.next().value).toEqual({
-      mapped: true,
-      codepoint: 33,
-      glyphId: 33,
-      cluster: 2,
-      width: 12,
-      height: 34,
-      xAdvance: 12.012,
-      yAdvance: 0,
-      xOffset: 0,
-      yOffset: 5.592,
-      xBearing: 0,
-      yBearing: 0,
-    });
-    expect(glyphs.next().done).toBe(true);
-  });
-
-  it('should be able to shape text that we know have kerning pairs.', () => {
-    const shaper = new SdfFontShaper(
-      sdfData as unknown as SdfFontData,
-      glyphMap,
-    );
-    const peekableCodepoints = new PeekableIterator(
-      getUnicodeCodepoints('WeVo'),
-    );
-    const glyphs = shaper.shapeText({ letterSpacing: 0 }, peekableCodepoints);
-    // W
-    expect(glyphs.next().value).toEqual(
-      expect.objectContaining({
-        codepoint: 87,
-        xAdvance: 39.816,
-        xOffset: -1,
-      }),
-    );
-    // e
-    expect(glyphs.next().value).toEqual(
-      expect.objectContaining({
-        codepoint: 101,
-        xAdvance: 24.528,
-        xOffset: 0,
-      }),
-    );
-    // V
-    expect(glyphs.next().value).toEqual(
-      expect.objectContaining({
-        codepoint: 86,
-        xAdvance: 30.324,
-        xOffset: -2,
-      }),
-    );
-    // o
-    expect(glyphs.next().value).toEqual(
-      expect.objectContaining({
-        codepoint: 111,
-        xAdvance: 23.184,
-        xOffset: -2.31,
-      }),
-    );
-
-    expect(glyphs.next().done).toBe(true);
-  });
-
-  it('should be able to shape text with letterSpacing.', () => {
-    const shaper = new SdfFontShaper(
-      sdfData as unknown as SdfFontData,
-      glyphMap,
-    );
-    const peekableCodepoints = new PeekableIterator(
-      getUnicodeCodepoints('We!'),
-    );
-    const glyphs = shaper.shapeText({ letterSpacing: 5 }, peekableCodepoints);
-    // W
-    expect(glyphs.next().value).toEqual(
-      expect.objectContaining({
-        codepoint: 87,
-        xAdvance: 39.816,
-        xOffset: -1,
-      }),
-    );
-    // e
-    expect(glyphs.next().value).toEqual(
-      expect.objectContaining({
-        codepoint: 101,
-        xAdvance: 29.528,
-        xOffset: 5,
-      }),
-    );
-    // !
-    expect(glyphs.next().value).toEqual(
-      expect.objectContaining({
-        codepoint: 33,
-        xAdvance: 17.012,
-        xOffset: 5,
-      }),
-    );
-    expect(glyphs.next().done).toBe(true);
-  });
-});