Font+Bitmap.c File Reference

#include <assert.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include <Objectively/String.h>
#include "Colors.h"
#include "Font.h"
#include "ImageAtlas.h"
#include "Log.h"
#include "Text.h"

Go to the source code of this file.

Data Structures
struct	RenderContext
struct	Token

Macros
#define	_Class   _Font

Typedefs
typedef void(*	TokenVisitor) (const FontBitmap *bitmap, const Token *token, int x, int y, ident data)
	Receives each drawable token with the pen position of its cell, in texels.

Enumerations
enum	TokenType {   TokenEnd , TokenNewline , TokenColor , TokenGlyph ,   TokenImage }

Functions
static void	blit (SDL_Surface *src, SDL_Surface *dest, const SDL_Rect *rect)
	Copies src into dest at rect, scaling if necessary, without alpha blending, so that glyph coverage lands in the sheet exactly as rasterized.
static Uint32	cellForCodepoint (Uint32 codepoint)
	Resolves codepoint to a cell: FONT_BITMAP_REPLACEMENT's for one outside the baked range.
static SDL_Point	cellOrigin (const FontBitmap *bitmap, Uint32 cell)
	The top-left texel of the given cell within the grid surface.
void	deallocBitmap (FontBitmap *bitmap)
	Releases the resources held by bitmap. Safe to call on a zeroed FontBitmap.
bool	initBitmap (FontBitmap *bitmap, Font *font)
	Bakes FONT_BITMAP_COUNT codepoints of font, from FONT_BITMAP_FIRST, into a glyph sheet, initializing bitmap.
static void	initGlyph (const FontBitmap *bitmap, TTF_Font *font, Uint32 codepoint, Uint32 cell)
	Rasterizes codepoint into the given cell, with its bearing baked in.
static void	nextToken (const char **chars, const ImageAtlas *icons, Token *token)
	Advances *chars past the next token, describing it in token.
void	renderCharactersBitmap (Font *self, const Renderer *renderer, const char *chars, SDL_Color color, int wrapWidth, const SDL_Point *origin, const ImageAtlas *icons)
	Implements Font::renderBitmapCharacters.
void	renderDeviceWillResetBitmap (Font *self)
	Implements Font::renderDeviceWillReset.
static void	renderToken (const FontBitmap *bitmap, const Token *token, int x, int y, ident data)
	TokenVisitor for Font::renderBitmapCharacters.
void	sizeCharactersBitmap (const Font *self, const char *chars, int wrapWidth, const ImageAtlas *icons, int *w, int *h)
	Implements Font::sizeBitmapCharacters.
static int	tokenAdvance (const FontBitmap *bitmap, const Token *token)
	The pen advance of the given token, in texels.
static void	walk (const FontBitmap *bitmap, const char *chars, int wrapWidth, SDL_Color color, const ImageAtlas *icons, TokenVisitor visitor, ident data, int *w, int *h)
	Walks chars, wrapping at word boundaries when wrapWidth (in texels) is non-zero, and reports the extent of the text in texels.
static int	wordAdvance (const FontBitmap *bitmap, const char *chars, const ImageAtlas *icons)
	The advance of the word starting at chars, up to the next space, newline or end.

Macro Definition Documentation

_Class

#define _Class   _Font

Definition at line 31 of file Font+Bitmap.c.

Typedef Documentation

TokenVisitor

typedef void(* TokenVisitor) (const FontBitmap *bitmap, const Token *token, int x, int y, ident data)

Receives each drawable token with the pen position of its cell, in texels.

Definition at line 240 of file Font+Bitmap.c.

Enumeration Type Documentation

TokenType

enum TokenType

Enumerator
TokenEnd
TokenNewline
TokenColor
TokenGlyph
TokenImage

Definition at line 106 of file Font+Bitmap.c.

             {
  TokenEnd,
  TokenNewline,
  TokenColor,
  TokenGlyph,
  TokenImage
} TokenType;

Function Documentation

blit()

static void blit ( SDL_Surface *  src, SDL_Surface *  dest, const SDL_Rect *  rect  )

static

Copies src into dest at rect, scaling if necessary, without alpha blending, so that glyph coverage lands in the sheet exactly as rasterized.

Definition at line 46 of file Font+Bitmap.c.

                                                                            {
 
  SDL_BlendMode blendMode;
  SDL_GetSurfaceBlendMode(src, &blendMode);
  SDL_SetSurfaceBlendMode(src, SDL_BLENDMODE_NONE);
 
  if (src->w == rect->w && src->h == rect->h) {
    SDL_BlitSurface(src, NULL, dest, rect);
  } else {
    SDL_BlitSurfaceScaled(src, NULL, dest, rect, SDL_SCALEMODE_LINEAR);
  }
 
  SDL_SetSurfaceBlendMode(src, blendMode);
}

cellForCodepoint()

static Uint32 cellForCodepoint ( Uint32  codepoint )

static

Resolves codepoint to a cell: FONT_BITMAP_REPLACEMENT's for one outside the baked range.

Definition at line 125 of file Font+Bitmap.c.

                                                 {
 
  if (codepoint >= FONT_BITMAP_FIRST && codepoint < FONT_BITMAP_LAST) {
    return codepoint - FONT_BITMAP_FIRST;
  }
 
  return FONT_BITMAP_REPLACEMENT - FONT_BITMAP_FIRST;
}

cellOrigin()

static SDL_Point cellOrigin ( const FontBitmap *  bitmap, Uint32  cell  )

static

The top-left texel of the given cell within the grid surface.

Definition at line 38 of file Font+Bitmap.c.

                                                                   {
  return MakePoint((cell % FONT_BITMAP_COLUMNS) * bitmap->cellSize.w, (cell / FONT_BITMAP_COLUMNS) * bitmap->cellSize.h);
}

deallocBitmap()

void deallocBitmap

(

FontBitmap *

bitmap

)

Releases the resources held by bitmap. Safe to call on a zeroed FontBitmap.

Parameters

bitmap

The FontBitmap.

Definition at line 375 of file Font+Bitmap.c.

                                       {
 
  assert(bitmap);
 
  release(bitmap->texture);
 
  if (bitmap->surface) {
    SDL_DestroySurface(bitmap->surface);
  }
}

initBitmap()

bool initBitmap	(	FontBitmap *	bitmap,
		Font *	font
	)

Bakes FONT_BITMAP_COUNT codepoints of font, from FONT_BITMAP_FIRST, into a glyph sheet, initializing bitmap.

A codepoint outside the range draws FONT_BITMAP_REPLACEMENT instead.

Parameters

bitmap	The FontBitmap, zero-initialized.
font	The Font, which MUST be fixed-width.

Returns

True if the bitmap was baked, false if font is not fixed-width or has no glyphs in the range, in which case bitmap is left zeroed.

Definition at line 322 of file Font+Bitmap.c.

                                                {
 
  assert(bitmap);
  assert(font);
 
  if (!TTF_FontIsFixedWidth(font->font)) {
    String *name = $(font, name);
    MVC_LogWarn("%s is not fixed-width\n", name->chars);
    release(name);
    return false;
  }
 
  int minX = INT_MAX, maxX = INT_MIN, advance = 0;
 
  for (Uint32 codepoint = FONT_BITMAP_FIRST; codepoint < FONT_BITMAP_LAST; codepoint++) {
 
    if (TTF_FontHasGlyph(font->font, codepoint)) {
      int glyphMinX = 0, glyphMaxX = 0, glyphAdvance = 0;
      if (!TTF_GetGlyphMetrics(font->font, codepoint, &glyphMinX, &glyphMaxX, NULL, NULL, &glyphAdvance)) {
        continue;
      }
 
      minX = min(minX, glyphMinX);
      maxX = max(maxX, max(glyphMaxX, glyphAdvance));
      advance = max(advance, glyphAdvance);
    }
  }
 
  if (maxX <= minX || advance == 0) {
    String *name = $(font, name);
    MVC_LogWarn("%s has no glyphs in U+%04X-U+%04X\n", name->chars, FONT_BITMAP_FIRST, FONT_BITMAP_LAST - 1);
    release(name);
    return false;
  }
 
  bitmap->advance = advance;
  bitmap->bearing = minX;
  bitmap->cellSize = MakeSize(maxX - minX, TTF_GetFontHeight(font->font));
 
  const int rows = FONT_BITMAP_COUNT / FONT_BITMAP_COLUMNS;
 
  bitmap->surface = SDL_CreateSurface(FONT_BITMAP_COLUMNS * bitmap->cellSize.w, rows * bitmap->cellSize.h, SDL_PIXELFORMAT_RGBA32);
  assert(bitmap->surface);
 
  SDL_FillSurfaceRect(bitmap->surface, NULL, 0);
 
  for (Uint32 i = 0; i < FONT_BITMAP_COUNT; i++) {
    initGlyph(bitmap, font->font, FONT_BITMAP_FIRST + i, i);
  }
 
  return true;
}

initGlyph()

static void initGlyph ( const FontBitmap *  bitmap, TTF_Font *  font, Uint32  codepoint, Uint32  cell  )

static

Rasterizes codepoint into the given cell, with its bearing baked in.

Definition at line 64 of file Font+Bitmap.c.

                                                                                               {
 
  SDL_Surface *sheet = bitmap->surface;
 
  if (!TTF_FontHasGlyph(font, codepoint)) {
    return;
  }
 
  int minX = 0, maxX = 0;
  if (!TTF_GetGlyphMetrics(font, codepoint, &minX, &maxX, NULL, NULL, NULL)) {
    MVC_LogError("U+%04X: %s\n", codepoint, SDL_GetError());
    return;
  }
 
  if (maxX <= minX) {
    return;
  }
 
  SDL_Surface *glyph = TTF_RenderGlyph_Blended(font, codepoint, Colors.White);
  if (glyph) {
 
    // The glyph surface's left edge is the pen, with the glyph's own bearing already applied,
    // except that SDL_ttf shifts a glyph with a negative bearing right so that its ink is not
    // cut off. The cell's left edge is the pen plus the range's minimum bearing.
    const SDL_Point origin = cellOrigin(bitmap, cell);
    const SDL_Rect rect = MakeRect(origin.x - bitmap->bearing + min(minX, 0), origin.y, glyph->w, glyph->h);
 
    // A glyph surface can exceed its cell, and must not overwrite its neighbours
    const SDL_Rect clip = MakeRect(origin.x, origin.y, bitmap->cellSize.w, bitmap->cellSize.h);
    SDL_SetSurfaceClipRect(sheet, &clip);
 
    blit(glyph, sheet, &rect);
 
    SDL_SetSurfaceClipRect(sheet, NULL);
    SDL_DestroySurface(glyph);
  } else {
    MVC_LogDebug("U+%04X: %s\n", codepoint, SDL_GetError());
  }
}

nextToken()

static void nextToken ( const char **  chars, const ImageAtlas *  icons, Token *  token  )

static

Advances *chars past the next token, describing it in token.

Definition at line 137 of file Font+Bitmap.c.

                                                                                 {
 
  const char *p = *chars;
 
  token->codepoint = 0;
  token->cell = 0;
  token->image = NULL;
 
  while (*p == '\r') {
    p++;
  }
 
  if (*p == '\0') {
    token->type = TokenEnd;
    *chars = p;
    return;
  }
 
  if (*p == '\n') {
    token->type = TokenNewline;
    *chars = p + 1;
    return;
  }
 
  if (p[0] == '^' && p[1] >= '0' && p[1] <= '9') {
    token->type = TokenColor;
    token->color = TextEscapeColors[p[1] - '0'];
    *chars = p + 2;
    return;
  }
 
  if (p[0] == '^' && p[1] == '^') {
    token->type = TokenGlyph;
    token->codepoint = '^';
    token->cell = cellForCodepoint('^');
    *chars = p + 2;
    return;
  }
 
  if (*p == ':') {
    const size_t length = MVC_IconEscapeLength(p, icons, &token->image);
    if (length) {
      token->type = TokenImage;
      *chars = p + length;
      return;
    }
  }
 
  const Uint32 codepoint = SDL_StepUTF8(&p, NULL);
 
  token->type = TokenGlyph;
  token->codepoint = codepoint;
  token->cell = cellForCodepoint(codepoint);
  *chars = p;
}

renderCharactersBitmap()

void renderCharactersBitmap	(	Font *	self,
		const Renderer *	renderer,
		const char *	chars,
		SDL_Color	color,
		int	wrapWidth,
		const SDL_Point *	origin,
		const ImageAtlas *	icons
	)

Implements Font::renderBitmapCharacters.

Definition at line 452 of file Font+Bitmap.c.

                                                                                                                                                                       {
 
  assert(self);
  assert(renderer);
  assert(origin);
 
  FontBitmap *bitmap = &self->bitmap;
  assert(bitmap->surface);
 
  if (chars == NULL) {
    return;
  }
 
  if (bitmap->texture == NULL) {
    bitmap->texture = $(renderer->device, createTextureFromSurface, bitmap->surface, SDL_GPU_TEXTUREUSAGE_SAMPLER, false);
    assert(bitmap->texture);
  }
 
  RenderContext context = {
    .renderer = renderer,
    .device = renderer->device,
    .texture = bitmap->texture,
    .origin = { roundf(origin->x * self->pixelDensity), roundf(origin->y * self->pixelDensity) },
    .scale = self->pixelDensity,
  };
 
  walk(bitmap, chars, (int) (wrapWidth * context.scale), color, icons, renderToken, &context, NULL, NULL);
}

renderDeviceWillResetBitmap()

void renderDeviceWillResetBitmap

(

Font *

self

)

Implements Font::renderDeviceWillReset.

Definition at line 390 of file Font+Bitmap.c.

                                             {
 
  assert(self);
 
  self->bitmap.texture = release(self->bitmap.texture);
}

renderToken()

static void renderToken ( const FontBitmap *  bitmap, const Token *  token, int  x, int  y, ident  data  )

static

TokenVisitor for Font::renderBitmapCharacters.

Definition at line 408 of file Font+Bitmap.c.

                                                                                                {
 
  const RenderContext *context = data;
 
  if (token->type == TokenImage) {
    ImageAtlas *atlas = token->image->atlas;
    if (atlas == NULL) {
      return;
    }
 
    // A square of the line height, centered in its whole-cell slot, from the icon atlas
    const int side = bitmap->cellSize.h;
    const int slot = tokenAdvance(bitmap, token);
 
    const SDL_FRect dest = {
      (context->origin.x + x + bitmap->bearing + (slot - side) / 2) / context->scale,
      (context->origin.y + y) / context->scale,
      side / context->scale,
      side / context->scale
    };
 
    Texture *texture = $(atlas, texture, context->device);
    $(context->renderer, drawTextureRegion, texture, &token->image->rect, &dest, &token->color);
    return;
  }
 
  const SDL_Point origin = cellOrigin(bitmap, token->cell);
  const SDL_Rect src = MakeRect(origin.x, origin.y, bitmap->cellSize.w, bitmap->cellSize.h);
 
  // Positioned in whole texels so that the sheet is sampled 1:1, then scaled to logical
  const SDL_FRect dest = {
    (context->origin.x + x + bitmap->bearing) / context->scale,
    (context->origin.y + y) / context->scale,
    src.w / context->scale,
    src.h / context->scale
  };
 
  $(context->renderer, drawTextureRegion, context->texture, &src, &dest, &token->color);
}

sizeCharactersBitmap()

void sizeCharactersBitmap	(	const Font *	self,
		const char *	chars,
		int	wrapWidth,
		const ImageAtlas *	icons,
		int *	w,
		int *	h
	)

Implements Font::sizeBitmapCharacters.

Definition at line 485 of file Font+Bitmap.c.

                                                                                                                       {
 
  assert(self);
 
  const FontBitmap *bitmap = &self->bitmap;
  assert(bitmap->surface);
 
  int texelsW = 0, texelsH = 0;
 
  if (chars) {
    walk(bitmap, chars, (int) (wrapWidth * self->pixelDensity), Colors.White, icons, NULL, NULL, &texelsW, &texelsH);
  }
 
  if (w) {
    *w = (int) ceilf(texelsW / self->pixelDensity);
  }
  if (h) {
    *h = (int) ceilf(texelsH / self->pixelDensity);
  }
}

tokenAdvance()

static int tokenAdvance ( const FontBitmap *  bitmap, const Token *  token  )

static

The pen advance of the given token, in texels.

Definition at line 196 of file Font+Bitmap.c.

                                                                      {
 
  switch (token->type) {
    case TokenGlyph:
      return bitmap->advance;
    case TokenImage:
      // A square of the line height, in whole cells, so that the grid stays aligned
      return ((bitmap->cellSize.h + bitmap->advance - 1) / bitmap->advance) * bitmap->advance;
    default:
      return 0;
  }
}

walk()

static void walk ( const FontBitmap *  bitmap, const char *  chars, int  wrapWidth, SDL_Color  color, const ImageAtlas *  icons, TokenVisitor  visitor, ident  data, int *  w, int *  h  )

static

Walks chars, wrapping at word boundaries when wrapWidth (in texels) is non-zero, and reports the extent of the text in texels.

Definition at line 246 of file Font+Bitmap.c.

                                                                   {
 
  int x = 0, y = 0, maxX = 0;
  bool lineHasContent = false;
 
  const int overhang = max(0, bitmap->bearing + bitmap->cellSize.w - bitmap->advance);
 
  Token token = { .type = TokenEnd, .color = color };
 
  while (true) {
    nextToken(&chars, icons, &token);
 
    if (token.type == TokenEnd) {
      break;
    }
 
    if (token.type == TokenNewline) {
      x = 0;
      y += bitmap->cellSize.h;
      lineHasContent = false;
      continue;
    }
 
    if (token.type == TokenColor) {
      color = token.color;
      continue;
    }
 
    if (wrapWidth && token.type == TokenGlyph && token.codepoint == ' ' && x > 0) {
      if (x + bitmap->advance + wordAdvance(bitmap, chars, icons) > wrapWidth) {
        x = 0;
        y += bitmap->cellSize.h;
        lineHasContent = false;
        continue;
      }
    }
 
    const int advance = tokenAdvance(bitmap, &token);
 
    if (wrapWidth && x > 0 && x + advance > wrapWidth) {
      x = 0;
      y += bitmap->cellSize.h;
      lineHasContent = false;
    }
 
    if (visitor) {
      token.color = token.type == TokenImage ? Colors.White : color;
      visitor(bitmap, &token, x, y, data);
    }
 
    x += advance;
    lineHasContent = true;
    // Ink past the pen: a glyph's cell overhang, or the bearing an icon shares with the glyph
    // column, less what centering in its slot gives back
    int extent = 0;
    if (token.type == TokenGlyph) {
      extent = overhang;
    } else if (token.type == TokenImage) {
      const int side = bitmap->cellSize.h;
      extent = max(0, bitmap->bearing + (advance - side) / 2 + side - advance);
    }
 
    maxX = max(maxX, x + extent);
  }
 
  if (w) {
    *w = maxX;
  }
  if (h) {
    *h = y + (lineHasContent ? bitmap->cellSize.h : 0);
  }
}

wordAdvance()

static int wordAdvance ( const FontBitmap *  bitmap, const char *  chars, const ImageAtlas *  icons  )

static

The advance of the word starting at chars, up to the next space, newline or end.

Definition at line 212 of file Font+Bitmap.c.

                                                                                             {
 
  int advance = 0;
 
  while (true) {
    const char *next = chars;
 
    Token token;
    nextToken(&next, icons, &token);
 
    if (token.type == TokenEnd || token.type == TokenNewline) {
      break;
    }
 
    if (token.type == TokenGlyph && token.codepoint == ' ') {
      break;
    }
 
    advance += tokenAdvance(bitmap, &token);
    chars = next;
  }
 
  return advance;
}