qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-10 07:11:41 +00:00
Code Issues Projects Releases Packages Wiki Activity

[ui] Add a shaped text cache system

Browse source 
Shaped text is cached using all the shaping parameters as well as the
text itself as a key. This makes text shaping a non-issue for imui when
the text is stable, taking my simple test from 120fps to 1000fps
(optimized build).
This commit is contained in:
Bill Currie 2023-07-08 03:29:53 +09:00
parent 0360e33a00
commit 79ab2f7ba7
6 changed files with 385 additions and 32 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

58
include/QF/ui/shaper.h Normal file
View file

@ -0,0 +1,58 @@
/*
shaper.h
Text shaping system
Copyright (C) 2023 Bill Currie <bill@taniwha.org>
Author: Bill Currie <bill@taniwha.org>
Date: 2023/07/07
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifndef __QF_ui_shaper_h
#define __QF_ui_shaper_h
#include "QF/ui/text.h"
typedef struct text_shaper_s text_shaper_t;
typedef struct shaped_glyphs_s {
const hb_glyph_info_t *glyphInfo;
const hb_glyph_position_t *glyphPos;
unsigned count;
} shaped_glyphs_t;
typedef struct shaping_s {
const script_component_t *script;
const featureset_t *features;
const struct font_s *font;
} shaping_t;
text_shaper_t *Shaper_New (void);
void Shaper_Delete (text_shaper_t *shaper);
void Shaper_FlushUnused (text_shaper_t *shaper);
shaped_glyphs_t Shaper_ShapeText (text_shaper_t *shaper,
const shaping_t *control,
const char *text, size_t text_len);
#endif//__QF_ui_shaper_h

4
include/QF/ui/text.h
View file

@ -106,6 +106,7 @@ extern hb_feature_t CligOn;
struct font_s;
struct passage_s;
struct text_shaper_s;
typedef struct text_system_s {
ecs_registry_t *reg;
@ -118,7 +119,8 @@ struct view_s Text_PassageView (text_system_t textsys,
struct view_s Text_StringView (text_system_t textsys, struct view_s parent,
struct font_s *font,
const char *str, uint32_t len,
script_component_t *sc, featureset_t *fs);
script_component_t *sc, featureset_t *fs,
struct text_shaper_s *shaper);
void Text_SetScript (text_system_t textsys, uint32_t textid,
const char *lang, hb_script_t script, text_dir_e dir);
void Text_SetFont (text_system_t textsys, uint32_t textid,

1
libs/ui/Makemodule.am
View file

@ -23,6 +23,7 @@ libs_ui_libQFgui_la_SOURCES= \
libs/ui/canvas.c \
libs/ui/font.c \
libs/ui/imui.c \
libs/ui/shaper.c \
libs/ui/text.c
libs_ui_libQFui_la_LDFLAGS= $(lib_ldflags)

10
libs/ui/imui.c
View file

@ -46,6 +46,7 @@
#include "QF/ui/canvas.h"
#include "QF/ui/font.h"
#include "QF/ui/imui.h"
#include "QF/ui/shaper.h"
#include "QF/ui/text.h"
#define c_percent_x (ctx->csys.imui_base + imui_percent_x)
@ -81,6 +82,9 @@ struct imui_ctx_s {
uint32_t canvas;
ecs_system_t vsys;
text_system_t tsys;
text_shaper_t *shaper;
hashctx_t *hashctx;
hashtab_t *tab;
PR_RESMAP (imui_state_t) state_map;
@ -181,6 +185,7 @@ IMUI_NewContext (canvas_system_t canvas_sys, const char *font, float fontsize)
.canvas = canvas = Canvas_New (canvas_sys),
.vsys = { canvas_sys.reg, canvas_sys.view_base },
.tsys = { canvas_sys.reg, canvas_sys.view_base, canvas_sys.text_base },
.shaper = Shaper_New (),
.root_view = Canvas_GetRootView (canvas_sys, canvas),
.parent_stack = DARRAY_STATIC_INIT (8),
.hot = nullent,
@ -234,6 +239,7 @@ IMUI_DestroyContext (imui_ctx_t *ctx)
Hash_DelTable (ctx->tab);
Hash_DelContext (ctx->hashctx);
Shaper_Delete (ctx->shaper);
free (ctx);
}
@ -274,6 +280,7 @@ IMUI_ProcessEvent (imui_ctx_t *ctx, const IE_event_t *ie_event)
void
IMUI_BeginFrame (imui_ctx_t *ctx)
{
Shaper_FlushUnused (ctx->shaper);
uint32_t root_ent = ctx->root_view.id;
auto root_size = View_GetLen (ctx->root_view);
Ent_RemoveComponent (root_ent, ctx->root_view.comp, ctx->root_view.reg);
@ -717,7 +724,8 @@ add_text (imui_ctx_t *ctx, view_t view, imui_state_t *state, int mode)
auto reg = ctx->csys.reg;
auto text = Text_StringView (ctx->tsys, view, ctx->font,
state->label, state->label_len, 0, 0);
state->label, state->label_len, 0, 0,
ctx->shaper);
int ascender = ctx->font->face->size->metrics.ascender / 64;
int descender = ctx->font->face->size->metrics.descender / 64;

295
libs/ui/shaper.c Normal file
View file

@ -0,0 +1,295 @@
/*
shaper.c
Immediate mode user inferface
Copyright (C) 2023 Bill Currie <bill@taniwha.org>
Author: Bill Currie <bill@taniwha.org>
Date: 2023/07/01
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdlib.h>
#include <string.h>
#include "QF/darray.h"
#include "QF/ecs.h"
#include "QF/fbsearch.h"
#include "QF/hash.h"
#include "QF/mathlib.h"
#include "QF/progs.h"
#include "QF/quakeio.h"
#include "QF/va.h"
#include "QF/input/event.h"
#include "QF/ui/font.h"
#include "QF/ui/shaper.h"
typedef struct shaper_cache_s {
struct shaper_cache_s *next;
struct shaper_cache_s **prev;
script_component_t script;
featureset_t features;
const font_t *font;
char *text;
size_t text_len;
hb_buffer_t *buffer;
} shaper_cache_t;
typedef struct shaper_font_s {
hb_font_t *hb_font;
uint32_t fontid;
} shaper_font_t;
struct text_shaper_s {
hashtab_t *tab;
hashctx_t *hashctx;
PR_RESMAP (shaper_cache_t) cache_map;
shaper_cache_t *buffers;
shaper_cache_t *unused_buffers; // buffers not used since last flush
struct DARRAY_TYPE (shaper_font_t) fonts;
};
static uintptr_t
shaper_get_hash (const void *obj, void *data)
{
const shaper_cache_t *cache = obj;
uintptr_t script = Hash_Buffer (&cache->script, sizeof (cache->script));
auto f = &cache->features;
uintptr_t features = 0;
if (f->a && f->size) {
features = Hash_Buffer (f->a, sizeof (hb_feature_t[f->size]));
}
uintptr_t font = cache->font->fontid;
uintptr_t text = Hash_nString (cache->text, cache->text_len);
return script + features + font + text;
}
static int
shaper_compare (const void *a, const void *b, void *data)
{
const shaper_cache_t *cachea = a;
const shaper_cache_t *cacheb = b;
if (cachea->font->fontid != cacheb->font->fontid) {
return 0;
}
auto af = &cachea->features;
auto bf = &cacheb->features;
if (af->size != bf->size || (!af->a != !bf->a)) {
return 0;
}
if (af->size && memcmp (af->a, &bf->a, sizeof (hb_feature_t[af->size]))) {
return 0;
}
if (memcmp (&cachea->script, &cacheb->script, sizeof (cachea->script))) {
return 0;
}
return (cachea->text_len == cacheb->text_len
&& !strncmp (cachea->text, cacheb->text, cachea->text_len));
}
static void
shaper_free_cache_data (shaper_cache_t *cache)
{
free (cache->text);
free (cache->features.a);
if (cache->buffer) {
hb_buffer_destroy (cache->buffer);
}
}
text_shaper_t *
Shaper_New (void)
{
text_shaper_t *shaper = malloc (sizeof (text_shaper_t));
*shaper = (text_shaper_t) {
.fonts = DARRAY_STATIC_INIT (8),
};
shaper->tab = Hash_NewTable (511, 0, 0, shaper, &shaper->hashctx);
Hash_SetHashCompare (shaper->tab, shaper_get_hash, shaper_compare);
return shaper;
}
void
Shaper_Delete (text_shaper_t *shaper)
{
for (auto c = shaper->buffers; c; c = c->next) {
shaper_free_cache_data (c);
}
for (auto c = shaper->unused_buffers; c; c = c->next) {
shaper_free_cache_data (c);
}
PR_RESDELMAP (shaper->cache_map);
Hash_DelTable (shaper->tab);
Hash_DelContext (shaper->hashctx);
for (size_t i = 0; i < shaper->fonts.size; i++) {
hb_font_destroy (shaper->fonts.a[i].hb_font);
}
DARRAY_CLEAR (&shaper->fonts);
free (shaper);
}
static void
shaper_link_cache (text_shaper_t *shaper, shaper_cache_t *cache)
{
cache->next = shaper->buffers;
cache->prev = &shaper->buffers;
if (shaper->buffers) {
shaper->buffers->prev = &cache->next;
}
shaper->buffers = cache;
}
static void
shaper_unlink_cache (shaper_cache_t *cache)
{
if (cache->next) {
cache->next->prev = cache->prev;
}
*cache->prev = cache->next;
}
static shaper_cache_t *
shaper_cache_new (text_shaper_t *shaper)
{
shaper_cache_t *cache = PR_RESNEW (shaper->cache_map);
return cache;
}
static void
shaper_cache_free (text_shaper_t *shaper, shaper_cache_t *cache)
{
Hash_DelElement (shaper->tab, cache);
shaper_unlink_cache (cache);
shaper_free_cache_data (cache);
PR_RESFREE (shaper->cache_map, cache);
}
void
Shaper_FlushUnused (text_shaper_t *shaper)
{
shaper_cache_t *c;
while ((c = shaper->unused_buffers)) {
shaper_cache_free (shaper, c);
}
shaper->unused_buffers = shaper->buffers;
if (shaper->buffers) {
shaper->buffers->prev = &shaper->unused_buffers;
}
shaper->buffers = 0;
}
static int
shaper_font_compare (const void *a, const void *b)
{
const uint32_t *fontid = a;
const shaper_font_t *font = b;
return *fontid - font->fontid;
}
static hb_font_t *
shaper_find_font (text_shaper_t *shaper, const font_t *font)
{
shaper_font_t *f = fbsearch (&font->fontid, shaper->fonts.a,
shaper->fonts.size, sizeof (shaper_font_t),
shaper_font_compare);
if (f && f->fontid == font->fontid) {
return f->hb_font;
}
auto nf = (shaper_font_t) {
.hb_font = hb_ft_font_create (font->face, 0),
.fontid = font->fontid,
};
size_t index = f - shaper->fonts.a;
if (!f) {
index = 0;
}
DARRAY_INSERT_AT (&shaper->fonts, nf, index);
return nf.hb_font;
}
shaped_glyphs_t
Shaper_ShapeText (text_shaper_t *shaper, const shaping_t *control,
const char *text, size_t text_len)
{
shaper_cache_t search_cache = {
.script = *control->script,
.features.size = control->features->size,
.features.a = control->features->a,
.font = control->font,
.text = (char *) text,
.text_len = text_len,
};
if (!control->features->size) {
search_cache.features.a = 0;
}
shaper_cache_t *cache = Hash_FindElement (shaper->tab, &search_cache);
if (!cache) {
cache = shaper_cache_new (shaper);
cache->script = *control->script;
cache->features.size = control->features->size;
if (control->features->size) {
size_t feat_size = sizeof (hb_feature_t[control->features->size]);
cache->features.a = malloc (feat_size);
memcpy (cache->features.a, control->features->a, feat_size);
} else {
cache->features.a = 0;
}
cache->font = control->font;
cache->text_len = text_len;
cache->text = malloc (cache->text_len + 1);
strncpy (cache->text, text, text_len);
cache->text[text_len] = 0;
cache->buffer = hb_buffer_create ();
hb_buffer_allocation_successful (cache->buffer);
Hash_AddElement (shaper->tab, cache);
auto buffer = cache->buffer;
auto hb_font = shaper_find_font (shaper, control->font);
auto direction = cache->script.direction;
auto script = cache->script.script;
auto language = cache->script.language;
auto features = &cache->features;
hb_buffer_reset (cache->buffer);
hb_buffer_set_direction (buffer, direction | HB_DIRECTION_LTR);
hb_buffer_set_script (buffer, script);
hb_buffer_set_language (buffer, language);
hb_buffer_add_utf8 (buffer, text, cache->text_len, 0, cache->text_len);
hb_shape (hb_font, buffer, features->a, features->size);
} else {
// remove from the unused buffers list if there, else move to head
// of used buffers list (via link call below)
shaper_unlink_cache (cache);
}
shaper_link_cache (shaper, cache);
unsigned c;
shaped_glyphs_t glyphs = {
.glyphInfo = hb_buffer_get_glyph_infos (cache->buffer, &c),
.glyphPos = hb_buffer_get_glyph_positions (cache->buffer, &c),
};
glyphs.count = c;
return glyphs;
}

49
libs/ui/text.c
View file

@ -38,6 +38,7 @@
#include "QF/ui/font.h"
#include "QF/ui/passage.h"
#include "QF/ui/shaper.h"
#include "QF/ui/text.h"
#include "QF/ui/view.h"
@ -116,7 +117,8 @@ static view_resize_f text_flow_funcs[] = {
static void
layout_glyphs (glyphnode_t *node, font_t *font, unsigned glpyhCount,
hb_glyph_info_t *glyphInfo, hb_glyph_position_t *glyphPos)
const hb_glyph_info_t *glyphInfo,
const hb_glyph_position_t *glyphPos)
{
int x = 0, y = 0;
for (unsigned k = 0; k < glpyhCount; k++) {
@ -320,7 +322,8 @@ Text_PassageView (text_system_t textsys, font_t *font, passage_t *passage)
view_t
Text_StringView (text_system_t textsys, view_t parent,
font_t *font, const char *str, uint32_t len,
script_component_t *sc, featureset_t *fs)
script_component_t *sc, featureset_t *fs,
text_shaper_t *shaper)
{
auto reg = textsys.reg;
uint32_t c_glyphs = textsys.text_base + text_glyphs;
@ -328,37 +331,25 @@ Text_StringView (text_system_t textsys, view_t parent,
glyphnode_t *glyph_nodes = 0;
glyphnode_t **head = &glyph_nodes;
hb_font_t *fnt = hb_ft_font_create (font->face, 0);
hb_buffer_t *buffer = hb_buffer_create ();
hb_buffer_allocation_successful (buffer);
hb_script_t script = HB_SCRIPT_LATIN;
text_dir_e direction = text_right_down;
hb_language_t language = hb_language_from_string ("en", 2);
script_component_t script = {
.script = sc ? sc->script : HB_SCRIPT_LATIN,
.direction = sc ? sc->direction : text_right_down,
.language = sc ? sc->language : hb_language_from_string ("en", 2),
};
featureset_t text_features = DARRAY_STATIC_INIT (0);
featureset_t *features = &text_features;
if (sc) {
script = sc->script;
language = sc->language;
direction = sc->direction;
}
if (fs) {
features = fs;
}
shaping_t shaping = {
.script = &script,
.features = fs ? fs : &text_features,
.font = font,
};
uint32_t glyph_count = 0;
hb_buffer_reset (buffer);
hb_buffer_set_direction (buffer, direction | HB_DIRECTION_LTR);
hb_buffer_set_script (buffer, script);
hb_buffer_set_language (buffer, language);
hb_buffer_add_utf8 (buffer, str, len, 0, len);
hb_shape (fnt, buffer, features->a, features->size);
unsigned c;
auto glyphInfo = hb_buffer_get_glyph_infos (buffer, &c);
auto glyphPos = hb_buffer_get_glyph_positions (buffer, &c);
auto shaped_glyphs = Shaper_ShapeText (shaper, &shaping, str, len);
unsigned c = shaped_glyphs.count;
auto glyphInfo = shaped_glyphs.glyphInfo;
auto glyphPos = shaped_glyphs.glyphPos;
*head = alloca (sizeof (glyphnode_t));
**head = (glyphnode_t) {
@ -387,8 +378,6 @@ Text_StringView (text_system_t textsys, view_t parent,
.count = glyph_count,
};
Ent_SetComponent (stringview.id, c_passage_glyphs, reg, &glyphset);
hb_buffer_destroy (buffer);
hb_font_destroy (fnt);
return stringview;
}