ra8_glyph_atlas.c

Go to the documentation of this file.

 
#include "ra8_glyph_atlas.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_keycache.h"

static const char* const s_tag = "ra8_glyph_atlas";

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_glyph_render(void* ctx, const void* key, uint8_t* cell, uint32_t cell_bytes, void* user)
{
  const ra8_glyph_atlas_t* atlas = (const ra8_glyph_atlas_t*)ctx;
  const ra8_glyph_key_t*   gk    = (const ra8_glyph_key_t*)key;
  ra8_glyph_dims_t*        dims  = (ra8_glyph_dims_t*)user;
  uint16_t                 w     = 0;
  uint16_t                 h     = 0;
  const ra8_err_t          rerr  = atlas->render(atlas->render_ctx, gk, cell, cell_bytes, &w, &h);
  if (rerr != k_ra8_ok) {
    return rerr;
  }
  dims->w = w;
  dims->h = h;
  return k_ra8_ok;
}
 
ra8_err_t ra8_glyph_atlas_init(ra8_glyph_atlas_t* atlas, const ra8_glyph_atlas_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(atlas, s_tag, "atlas must not be nullptr");
  RA8_CHECK_NULL_PTR(cfg, s_tag, "cfg must not be nullptr");
  RA8_CHECK_NULL_PTR(cfg->render, s_tag, "render must not be nullptr");
  (void)memset(atlas, 0, sizeof(*atlas));
  atlas->render           = cfg->render;
  atlas->render_ctx       = cfg->render_ctx;
  ra8_keycache_cfg_t kcfg = {};
  kcfg.cell_mem           = cfg->cell_mem;
  kcfg.cell_bytes         = cfg->cell_bytes;
  kcfg.cell_count         = cfg->cell_count;
  kcfg.key_mem            = (uint8_t*)cfg->keys;
  kcfg.key_bytes          = (uint32_t)sizeof(ra8_glyph_key_t);
  kcfg.user_mem           = (uint8_t*)cfg->dims;
  kcfg.user_bytes         = (uint32_t)sizeof(ra8_glyph_dims_t);
  kcfg.meta               = cfg->meta;
  kcfg.buckets            = cfg->buckets;
  kcfg.bucket_count       = cfg->bucket_count;
  kcfg.render             = internal_glyph_render;
  kcfg.render_ctx         = atlas;
  return ra8_keycache_init(&atlas->kc, &kcfg);
}
 
ra8_err_t
ra8_glyph_atlas_get(ra8_glyph_atlas_t* atlas, const ra8_glyph_key_t* key, ra8_glyph_t* out_glyph)
{
  RA8_CHECK_NULL_PTR(atlas, s_tag, "atlas must not be nullptr");
  RA8_CHECK_NULL_PTR(key, s_tag, "key must not be nullptr");
  RA8_CHECK_NULL_PTR(out_glyph, s_tag, "out_glyph must not be nullptr");
  ra8_keycache_view_t v   = {};
  const ra8_err_t     err = ra8_keycache_get(&atlas->kc, key, &v);
  if (err != k_ra8_ok) {
    return err;
  }
  const ra8_glyph_dims_t* dims = (const ra8_glyph_dims_t*)v.user;
  *out_glyph = (ra8_glyph_t){.bitmap = v.data, .width = dims->w, .height = dims->h};
  return k_ra8_ok;
}
 
ra8_err_t ra8_glyph_atlas_put(ra8_glyph_atlas_t* atlas, const uint8_t* bitmap)
{
  RA8_CHECK_NULL_PTR(atlas, s_tag, "atlas must not be nullptr");
  RA8_CHECK_NULL_PTR(bitmap, s_tag, "bitmap must not be nullptr");
  return ra8_keycache_put(&atlas->kc, bitmap);
}
 
ra8_err_t ra8_glyph_atlas_stats(const ra8_glyph_atlas_t* atlas,
                                uint32_t*                out_hits,
                                uint32_t*                out_misses,
                                uint32_t*                out_evictions)
{
  RA8_CHECK_NULL_PTR(atlas, s_tag, "atlas must not be nullptr");
  if (atlas->kc.cfg.cell_mem == nullptr) {
    return k_ra8_err_invalid_state;
  }
  return ra8_keycache_stats(&atlas->kc, out_hits, out_misses, out_evictions);
}