ra8_gfx_text_glyph.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_err.h"
#include "ra8_gfx.h"
#include "ra8_gfx_internal.h"

typedef enum : uint8_t {
  k_glyph_bits_per_byte = 8, 
  k_glyph_msb_index     = 7, 
} ra8_gfx_glyph_bits_t;

typedef enum : uint32_t {
  k_mask_byte = 0xFFU, 
} ra8_gfx_color_masks_t;

typedef enum : uint8_t {
  k_idx_r = 0, 
  k_idx_g = 1, 
} ra8_gfx_byte_idx_t;

RA8_INTERNAL
static void internal_blit_glyph_565(int32_t        x,
                                    int32_t        y,
                                    int32_t        gw,
                                    int32_t        gh,
                                    uint32_t       row_bytes,
                                    const uint8_t* gd,
                                    uint32_t       fg,
                                    uint32_t       bg)
{
  /* Clip the glyph cell against the active clip rectangle (within the
   * framebuffer), so it honours both the panel bounds and any dirty-region clip.
   * Default full clip => byte-identical to the unclipped blit. */
  const int32_t cl  = g_gfx_text_state.clip_x0;
  const int32_t ct  = g_gfx_text_state.clip_y0;
  const int32_t cr  = g_gfx_text_state.clip_x1;
  const int32_t cb  = g_gfx_text_state.clip_y1;
  const int32_t cx0 = (x >= cl) ? x : cl;
  const int32_t cy0 = (y >= ct) ? y : ct;
  const int64_t xr  = (int64_t)x + (int64_t)gw; /* 64-bit: no int32 overflow. */
  const int64_t yr  = (int64_t)y + (int64_t)gh;
  const int32_t cx1 = (xr < (int64_t)cr) ? (int32_t)xr : cr;
  const int32_t cy1 = (yr < (int64_t)cb) ? (int32_t)yr : cb;
  if ((cx1 <= cx0) || (cy1 <= cy0)) {
    return; /* glyph fully outside the clip. */
  }
  const uint16_t vfg    = priv_gfx_text_pack_565(fg);
  const uint16_t vbg    = priv_gfx_text_pack_565(bg);
  const uint8_t  flo    = (uint8_t)(vfg & (uint16_t)k_mask_byte);
  const uint8_t  fhi    = (uint8_t)((vfg >> k_glyph_bits_per_byte) & (uint16_t)k_mask_byte);
  const uint8_t  blo    = (uint8_t)(vbg & (uint16_t)k_mask_byte);
  const uint8_t  bhi    = (uint8_t)((vbg >> k_glyph_bits_per_byte) & (uint16_t)k_mask_byte);
  const size_t   bpp    = (size_t)g_gfx_text_state.bpp;
  const size_t   stride = (size_t)g_gfx_text_state.width * bpp;
  for (int32_t sy = cy0; sy < cy1; sy++) {
    const uint32_t grow = (uint32_t)(sy - y);
    uint8_t*       p    = g_gfx_text_state.fb + ((size_t)sy * stride) + ((size_t)cx0 * bpp);
    for (int32_t sx = cx0; sx < cx1; sx++) {
      const uint32_t gcol     = (uint32_t)(sx - x);
      const uint32_t byte_idx = (grow * row_bytes) + (gcol / (uint32_t)k_glyph_bits_per_byte);
      const uint8_t  bit = (uint8_t)(k_glyph_msb_index - (gcol % (uint32_t)k_glyph_bits_per_byte));
      const bool     on  = ((gd[byte_idx] >> bit) & 0x01U) != 0U;
      p[k_idx_r]         = on ? flo : blo;
      p[k_idx_g]         = on ? fhi : bhi;
      p += bpp;
    }
  }
}

RA8_INTERNAL
static void internal_render_glyph(int32_t               x,
                                  int32_t               y,
                                  const ra8_gfx_font_t* font,
                                  uint8_t               cp,
                                  uint32_t              fg,
                                  uint32_t              bg)
{
  uint8_t idx;
  if ((cp < font->first_codepoint) || (cp > font->last_codepoint)) {
    idx = 0; /* render as space */
  } else {
    idx = (uint8_t)(cp - font->first_codepoint);
  }
  const uint32_t row_bytes =
    ((uint32_t)font->glyph_width + (k_glyph_bits_per_byte - 1U)) / k_glyph_bits_per_byte;
  const uint8_t* gd = font->glyph_data + ((size_t)idx * (size_t)font->bytes_per_glyph);
  if (g_gfx_text_state.format == k_ra8_gfx_format_rgb565) {
    internal_blit_glyph_565(x,
                            y,
                            (int32_t)font->glyph_width,
                            (int32_t)font->glyph_height,
                            row_bytes,
                            gd,
                            fg,
                            bg);
    return;
  }
  for (uint32_t row = 0; row < font->glyph_height; row++) {
    for (uint32_t col = 0; col < font->glyph_width; col++) {
      const uint32_t byte_idx = (row * row_bytes) + (col / k_glyph_bits_per_byte);
      const uint8_t  bit      = (uint8_t)(k_glyph_msb_index - (col % k_glyph_bits_per_byte));
      const bool     on       = ((gd[byte_idx] >> bit) & 0x01U) != 0U;
      priv_gfx_text_plot(x + (int32_t)col, y + (int32_t)row, on ? fg : bg);
    }
  }
}
 
ra8_err_t ra8_gfx_text_out(int32_t               x,
                           int32_t               y,
                           const char*           str,
                           const ra8_gfx_font_t* font,
                           uint32_t              fg_color,
                           uint32_t              bg_color)
{
  if ((str == nullptr) || (font == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (!g_gfx_text_state.initialized) {
    return k_ra8_err_not_initialized;
  }
  int32_t       cur_x  = x;
  const int32_t step_x = (int32_t)font->glyph_width;
  /* Static bound: at most one glyph per pixel column we could ever cover. */
  const uint32_t max_chars = k_ra8_gfx_max_dim;
  for (uint32_t i = 0; i < max_chars; i++) {
    const char c = str[i];
    if (c == '\0') {
      break;
    }
    internal_render_glyph(cur_x, y, font, (uint8_t)c, fg_color, bg_color);
    cur_x += step_x;
  }
  return k_ra8_ok;
}
 
ra8_err_t
ra8_gfx_text_size(const char* str, const ra8_gfx_font_t* font, uint32_t* out_w, uint32_t* out_h)
{
  if ((str == nullptr) || (font == nullptr) || (out_w == nullptr) || (out_h == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  uint32_t       n         = 0;
  const uint32_t max_chars = k_ra8_gfx_max_dim;
  for (uint32_t i = 0; i < max_chars; i++) {
    if (str[i] == '\0') {
      break;
    }
    n++;
  }
  *out_w = n * (uint32_t)font->glyph_width;
  *out_h = (uint32_t)font->glyph_height;
  return k_ra8_ok;
}