From e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Wed, 17 Apr 2019 06:17:24 +0200 Subject: ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat --- source/blender/blenfont/intern/blf_font.c | 1804 +++++++++++++++-------------- 1 file changed, 905 insertions(+), 899 deletions(-) (limited to 'source/blender/blenfont/intern/blf_font.c') diff --git a/source/blender/blenfont/intern/blf_font.c b/source/blender/blenfont/intern/blf_font.c index 06904ee36b6..ae406b103a7 100644 --- a/source/blender/blenfont/intern/blf_font.c +++ b/source/blender/blenfont/intern/blf_font.c @@ -25,7 +25,6 @@ * Also low level functions for managing \a FontBLF. */ - #include #include #include @@ -83,128 +82,130 @@ static SpinLock ft_lib_mutex; */ static void blf_batch_draw_init(void) { - GPUVertFormat format = {0}; - g_batch.pos_loc = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 4, GPU_FETCH_FLOAT); - g_batch.tex_loc = GPU_vertformat_attr_add(&format, "tex", GPU_COMP_F32, 4, GPU_FETCH_FLOAT); - g_batch.col_loc = GPU_vertformat_attr_add(&format, "col", GPU_COMP_U8, 4, GPU_FETCH_INT_TO_FLOAT_UNIT); + GPUVertFormat format = {0}; + g_batch.pos_loc = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 4, GPU_FETCH_FLOAT); + g_batch.tex_loc = GPU_vertformat_attr_add(&format, "tex", GPU_COMP_F32, 4, GPU_FETCH_FLOAT); + g_batch.col_loc = GPU_vertformat_attr_add( + &format, "col", GPU_COMP_U8, 4, GPU_FETCH_INT_TO_FLOAT_UNIT); - g_batch.verts = GPU_vertbuf_create_with_format_ex(&format, GPU_USAGE_STREAM); - GPU_vertbuf_data_alloc(g_batch.verts, BLF_BATCH_DRAW_LEN_MAX); + g_batch.verts = GPU_vertbuf_create_with_format_ex(&format, GPU_USAGE_STREAM); + GPU_vertbuf_data_alloc(g_batch.verts, BLF_BATCH_DRAW_LEN_MAX); - GPU_vertbuf_attr_get_raw_data(g_batch.verts, g_batch.pos_loc, &g_batch.pos_step); - GPU_vertbuf_attr_get_raw_data(g_batch.verts, g_batch.tex_loc, &g_batch.tex_step); - GPU_vertbuf_attr_get_raw_data(g_batch.verts, g_batch.col_loc, &g_batch.col_step); - g_batch.glyph_len = 0; + GPU_vertbuf_attr_get_raw_data(g_batch.verts, g_batch.pos_loc, &g_batch.pos_step); + GPU_vertbuf_attr_get_raw_data(g_batch.verts, g_batch.tex_loc, &g_batch.tex_step); + GPU_vertbuf_attr_get_raw_data(g_batch.verts, g_batch.col_loc, &g_batch.col_step); + g_batch.glyph_len = 0; - g_batch.batch = GPU_batch_create_ex(GPU_PRIM_POINTS, g_batch.verts, NULL, GPU_BATCH_OWNS_VBO); + g_batch.batch = GPU_batch_create_ex(GPU_PRIM_POINTS, g_batch.verts, NULL, GPU_BATCH_OWNS_VBO); } static void blf_batch_draw_exit(void) { - GPU_BATCH_DISCARD_SAFE(g_batch.batch); + GPU_BATCH_DISCARD_SAFE(g_batch.batch); } void blf_batch_draw_vao_clear(void) { - if (g_batch.batch) { - GPU_batch_vao_cache_clear(g_batch.batch); - } + if (g_batch.batch) { + GPU_batch_vao_cache_clear(g_batch.batch); + } } void blf_batch_draw_begin(FontBLF *font) { - if (g_batch.batch == NULL) { - blf_batch_draw_init(); - } - - const bool font_changed = (g_batch.font != font); - const bool simple_shader = ((font->flags & (BLF_ROTATION | BLF_MATRIX | BLF_ASPECT)) == 0); - const bool shader_changed = (simple_shader != g_batch.simple_shader); - - g_batch.active = g_batch.enabled && simple_shader; - - if (simple_shader) { - /* Offset is applied to each glyph. */ - g_batch.ofs[0] = floorf(font->pos[0]); - g_batch.ofs[1] = floorf(font->pos[1]); - } - else { - /* Offset is baked in modelview mat. */ - zero_v2(g_batch.ofs); - } - - if (g_batch.active) { - float gpumat[4][4]; - GPU_matrix_model_view_get(gpumat); - - bool mat_changed = (memcmp(gpumat, g_batch.mat, sizeof(g_batch.mat)) != 0); - - if (mat_changed) { - /* Modelviewmat is no longer the same. - * Flush cache but with the previous mat. */ - GPU_matrix_push(); - GPU_matrix_set(g_batch.mat); - } - - /* flush cache if config is not the same. */ - if (mat_changed || font_changed || shader_changed) { - blf_batch_draw(); - g_batch.simple_shader = simple_shader; - g_batch.font = font; - } - else { - /* Nothing changed continue batching. */ - return; - } - - if (mat_changed) { - GPU_matrix_pop(); - /* Save for next memcmp. */ - memcpy(g_batch.mat, gpumat, sizeof(g_batch.mat)); - } - } - else { - /* flush cache */ - blf_batch_draw(); - g_batch.font = font; - g_batch.simple_shader = simple_shader; - } + if (g_batch.batch == NULL) { + blf_batch_draw_init(); + } + + const bool font_changed = (g_batch.font != font); + const bool simple_shader = ((font->flags & (BLF_ROTATION | BLF_MATRIX | BLF_ASPECT)) == 0); + const bool shader_changed = (simple_shader != g_batch.simple_shader); + + g_batch.active = g_batch.enabled && simple_shader; + + if (simple_shader) { + /* Offset is applied to each glyph. */ + g_batch.ofs[0] = floorf(font->pos[0]); + g_batch.ofs[1] = floorf(font->pos[1]); + } + else { + /* Offset is baked in modelview mat. */ + zero_v2(g_batch.ofs); + } + + if (g_batch.active) { + float gpumat[4][4]; + GPU_matrix_model_view_get(gpumat); + + bool mat_changed = (memcmp(gpumat, g_batch.mat, sizeof(g_batch.mat)) != 0); + + if (mat_changed) { + /* Modelviewmat is no longer the same. + * Flush cache but with the previous mat. */ + GPU_matrix_push(); + GPU_matrix_set(g_batch.mat); + } + + /* flush cache if config is not the same. */ + if (mat_changed || font_changed || shader_changed) { + blf_batch_draw(); + g_batch.simple_shader = simple_shader; + g_batch.font = font; + } + else { + /* Nothing changed continue batching. */ + return; + } + + if (mat_changed) { + GPU_matrix_pop(); + /* Save for next memcmp. */ + memcpy(g_batch.mat, gpumat, sizeof(g_batch.mat)); + } + } + else { + /* flush cache */ + blf_batch_draw(); + g_batch.font = font; + g_batch.simple_shader = simple_shader; + } } void blf_batch_draw(void) { - if (g_batch.glyph_len == 0) - return; + if (g_batch.glyph_len == 0) + return; - GPU_blend(true); - GPU_blend_set_func_separate(GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA); + GPU_blend(true); + GPU_blend_set_func_separate( + GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA); - /* We need to flush widget base first to ensure correct ordering. */ - UI_widgetbase_draw_cache_flush(); + /* We need to flush widget base first to ensure correct ordering. */ + UI_widgetbase_draw_cache_flush(); - GPU_texture_bind(g_batch.tex_bind_state, 0); - GPU_vertbuf_data_len_set(g_batch.verts, g_batch.glyph_len); - GPU_vertbuf_use(g_batch.verts); /* send data */ + GPU_texture_bind(g_batch.tex_bind_state, 0); + GPU_vertbuf_data_len_set(g_batch.verts, g_batch.glyph_len); + GPU_vertbuf_use(g_batch.verts); /* send data */ - eGPUBuiltinShader shader = (g_batch.simple_shader) ? GPU_SHADER_TEXT_SIMPLE : GPU_SHADER_TEXT; - GPU_batch_program_set_builtin(g_batch.batch, shader); - GPU_batch_uniform_1i(g_batch.batch, "glyph", 0); - GPU_batch_draw(g_batch.batch); + eGPUBuiltinShader shader = (g_batch.simple_shader) ? GPU_SHADER_TEXT_SIMPLE : GPU_SHADER_TEXT; + GPU_batch_program_set_builtin(g_batch.batch, shader); + GPU_batch_uniform_1i(g_batch.batch, "glyph", 0); + GPU_batch_draw(g_batch.batch); - GPU_blend(false); + GPU_blend(false); - /* restart to 1st vertex data pointers */ - GPU_vertbuf_attr_get_raw_data(g_batch.verts, g_batch.pos_loc, &g_batch.pos_step); - GPU_vertbuf_attr_get_raw_data(g_batch.verts, g_batch.tex_loc, &g_batch.tex_step); - GPU_vertbuf_attr_get_raw_data(g_batch.verts, g_batch.col_loc, &g_batch.col_step); - g_batch.glyph_len = 0; + /* restart to 1st vertex data pointers */ + GPU_vertbuf_attr_get_raw_data(g_batch.verts, g_batch.pos_loc, &g_batch.pos_step); + GPU_vertbuf_attr_get_raw_data(g_batch.verts, g_batch.tex_loc, &g_batch.tex_step); + GPU_vertbuf_attr_get_raw_data(g_batch.verts, g_batch.col_loc, &g_batch.col_step); + g_batch.glyph_len = 0; } static void blf_batch_draw_end(void) { - if (!g_batch.active) { - blf_batch_draw(); - } + if (!g_batch.active) { + blf_batch_draw(); + } } /** \} */ @@ -213,81 +214,81 @@ static void blf_batch_draw_end(void) int blf_font_init(void) { - memset(&g_batch, 0, sizeof(g_batch)); - BLI_spin_init(&ft_lib_mutex); - return FT_Init_FreeType(&ft_lib); + memset(&g_batch, 0, sizeof(g_batch)); + BLI_spin_init(&ft_lib_mutex); + return FT_Init_FreeType(&ft_lib); } void blf_font_exit(void) { - FT_Done_FreeType(ft_lib); - BLI_spin_end(&ft_lib_mutex); - blf_batch_draw_exit(); + FT_Done_FreeType(ft_lib); + BLI_spin_end(&ft_lib_mutex); + blf_batch_draw_exit(); } void blf_font_size(FontBLF *font, unsigned int size, unsigned int dpi) { - GlyphCacheBLF *gc; - FT_Error err; - - gc = blf_glyph_cache_find(font, size, dpi); - if (gc) { - font->glyph_cache = gc; - /* Optimization: do not call FT_Set_Char_Size if size did not change. */ - if (font->size == size && font->dpi == dpi) - return; - } - - err = FT_Set_Char_Size(font->face, 0, (FT_F26Dot6)(size * 64), dpi, dpi); - if (err) { - /* FIXME: here we can go through the fixed size and choice a close one */ - printf("The current font don't support the size, %u and dpi, %u\n", size, dpi); - return; - } - - font->size = size; - font->dpi = dpi; - - if (!gc) { - gc = blf_glyph_cache_new(font); - if (gc) - font->glyph_cache = gc; - else - font->glyph_cache = NULL; - } + GlyphCacheBLF *gc; + FT_Error err; + + gc = blf_glyph_cache_find(font, size, dpi); + if (gc) { + font->glyph_cache = gc; + /* Optimization: do not call FT_Set_Char_Size if size did not change. */ + if (font->size == size && font->dpi == dpi) + return; + } + + err = FT_Set_Char_Size(font->face, 0, (FT_F26Dot6)(size * 64), dpi, dpi); + if (err) { + /* FIXME: here we can go through the fixed size and choice a close one */ + printf("The current font don't support the size, %u and dpi, %u\n", size, dpi); + return; + } + + font->size = size; + font->dpi = dpi; + + if (!gc) { + gc = blf_glyph_cache_new(font); + if (gc) + font->glyph_cache = gc; + else + font->glyph_cache = NULL; + } } static void blf_font_ensure_ascii_table(FontBLF *font) { - GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; - - /* build ascii on demand */ - if (glyph_ascii_table['0'] == NULL) { - GlyphBLF *g; - unsigned int i; - for (i = 0; i < 256; i++) { - g = blf_glyph_search(font->glyph_cache, i); - if (!g) { - FT_UInt glyph_index = FT_Get_Char_Index(font->face, i); - g = blf_glyph_add(font, glyph_index, i); - } - glyph_ascii_table[i] = g; - } - } + GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; + + /* build ascii on demand */ + if (glyph_ascii_table['0'] == NULL) { + GlyphBLF *g; + unsigned int i; + for (i = 0; i < 256; i++) { + g = blf_glyph_search(font->glyph_cache, i); + if (!g) { + FT_UInt glyph_index = FT_Get_Char_Index(font->face, i); + g = blf_glyph_add(font, glyph_index, i); + } + glyph_ascii_table[i] = g; + } + } } static void blf_font_ensure_ascii_kerning(FontBLF *font, const FT_UInt kern_mode) { - KerningCacheBLF *kc = font->kerning_cache; + KerningCacheBLF *kc = font->kerning_cache; - font->kerning_mode = kern_mode; + font->kerning_mode = kern_mode; - if (!kc || kc->mode != kern_mode) { - font->kerning_cache = kc = blf_kerning_cache_find(font); - if (!kc) { - font->kerning_cache = kc = blf_kerning_cache_new(font); - } - } + if (!kc || kc->mode != kern_mode) { + font->kerning_cache = kc = blf_kerning_cache_find(font); + if (!kc) { + font->kerning_cache = kc = blf_kerning_cache_new(font); + } + } } /* Fast path for runs of ASCII characters. Given that common UTF-8 @@ -298,528 +299,518 @@ static void blf_font_ensure_ascii_kerning(FontBLF *font, const FT_UInt kern_mode /* Note, * blf_font_ensure_ascii_table(font); must be called before this macro */ -#define BLF_UTF8_NEXT_FAST(_font, _g, _str, _i, _c, _glyph_ascii_table) \ - if (((_c) = (_str)[_i]) < 0x80) { \ - _g = (_glyph_ascii_table)[_c]; \ - _i++; \ - } \ - else if ((_c = BLI_str_utf8_as_unicode_step(_str, &(_i))) != BLI_UTF8_ERR) { \ - if ((_g = blf_glyph_search((_font)->glyph_cache, _c)) == NULL) { \ - _g = blf_glyph_add(_font, \ - FT_Get_Char_Index((_font)->face, _c), _c); \ - } \ - } (void)0 - - -#define BLF_KERNING_VARS(_font, _has_kerning, _kern_mode) \ - const bool _has_kerning = FT_HAS_KERNING((_font)->face) != 0; \ - const FT_UInt _kern_mode = (_has_kerning == 0) ? 0 : \ - (((_font)->flags & BLF_KERNING_DEFAULT) ? \ - ft_kerning_default : (FT_UInt)FT_KERNING_UNFITTED) \ +#define BLF_UTF8_NEXT_FAST(_font, _g, _str, _i, _c, _glyph_ascii_table) \ + if (((_c) = (_str)[_i]) < 0x80) { \ + _g = (_glyph_ascii_table)[_c]; \ + _i++; \ + } \ + else if ((_c = BLI_str_utf8_as_unicode_step(_str, &(_i))) != BLI_UTF8_ERR) { \ + if ((_g = blf_glyph_search((_font)->glyph_cache, _c)) == NULL) { \ + _g = blf_glyph_add(_font, FT_Get_Char_Index((_font)->face, _c), _c); \ + } \ + } \ + (void)0 + +#define BLF_KERNING_VARS(_font, _has_kerning, _kern_mode) \ + const bool _has_kerning = FT_HAS_KERNING((_font)->face) != 0; \ + const FT_UInt _kern_mode = (_has_kerning == 0) ? 0 : \ + (((_font)->flags & BLF_KERNING_DEFAULT) ? \ + ft_kerning_default : \ + (FT_UInt)FT_KERNING_UNFITTED) /* Note, * blf_font_ensure_ascii_kerning(font, kern_mode); must be called before this macro */ #define BLF_KERNING_STEP_FAST(_font, _kern_mode, _g_prev, _g, _c_prev, _c, _pen_x) \ -{ \ - if (_g_prev) { \ - FT_Vector _delta; \ - if (_c_prev < 0x80 && _c < 0x80) { \ - _pen_x += (_font)->kerning_cache->table[_c][_c_prev]; \ - } \ - else if (FT_Get_Kerning((_font)->face, \ - (_g_prev)->idx, \ - (_g)->idx, \ - _kern_mode, \ - &(_delta)) == 0) \ - { \ - _pen_x += (int)_delta.x >> 6; \ - } \ - } \ -} (void)0 - -#define BLF_KERNING_STEP(_font, _kern_mode, _g_prev, _g, _delta, _pen_x) \ -{ \ - if (_g_prev) { \ - _delta.x = _delta.y = 0; \ - if (FT_Get_Kerning((_font)->face, \ - (_g_prev)->idx, \ - (_g)->idx, \ - _kern_mode, \ - &(_delta)) == 0) \ - { \ - _pen_x += (int)_delta.x >> 6; \ - } \ - } \ -} (void)0 + { \ + if (_g_prev) { \ + FT_Vector _delta; \ + if (_c_prev < 0x80 && _c < 0x80) { \ + _pen_x += (_font)->kerning_cache->table[_c][_c_prev]; \ + } \ + else if (FT_Get_Kerning((_font)->face, (_g_prev)->idx, (_g)->idx, _kern_mode, &(_delta)) == \ + 0) { \ + _pen_x += (int)_delta.x >> 6; \ + } \ + } \ + } \ + (void)0 + +#define BLF_KERNING_STEP(_font, _kern_mode, _g_prev, _g, _delta, _pen_x) \ + { \ + if (_g_prev) { \ + _delta.x = _delta.y = 0; \ + if (FT_Get_Kerning((_font)->face, (_g_prev)->idx, (_g)->idx, _kern_mode, &(_delta)) == 0) { \ + _pen_x += (int)_delta.x >> 6; \ + } \ + } \ + } \ + (void)0 static void blf_font_draw_ex( - FontBLF *font, const char *str, size_t len, struct ResultBLF *r_info, - int pen_y) + FontBLF *font, const char *str, size_t len, struct ResultBLF *r_info, int pen_y) { - unsigned int c, c_prev = BLI_UTF8_ERR; - GlyphBLF *g, *g_prev = NULL; - int pen_x = 0; - size_t i = 0; - GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; + unsigned int c, c_prev = BLI_UTF8_ERR; + GlyphBLF *g, *g_prev = NULL; + int pen_x = 0; + size_t i = 0; + GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; - if (len == 0) { - /* early output, don't do any IMM OpenGL. */ - return; - } + if (len == 0) { + /* early output, don't do any IMM OpenGL. */ + return; + } - BLF_KERNING_VARS(font, has_kerning, kern_mode); + BLF_KERNING_VARS(font, has_kerning, kern_mode); - blf_font_ensure_ascii_table(font); - blf_font_ensure_ascii_kerning(font, kern_mode); + blf_font_ensure_ascii_table(font); + blf_font_ensure_ascii_kerning(font, kern_mode); - blf_batch_draw_begin(font); + blf_batch_draw_begin(font); - while ((i < len) && str[i]) { - BLF_UTF8_NEXT_FAST(font, g, str, i, c, glyph_ascii_table); + while ((i < len) && str[i]) { + BLF_UTF8_NEXT_FAST(font, g, str, i, c, glyph_ascii_table); - if (UNLIKELY(c == BLI_UTF8_ERR)) - break; - if (UNLIKELY(g == NULL)) - continue; - if (has_kerning) - BLF_KERNING_STEP_FAST(font, kern_mode, g_prev, g, c_prev, c, pen_x); + if (UNLIKELY(c == BLI_UTF8_ERR)) + break; + if (UNLIKELY(g == NULL)) + continue; + if (has_kerning) + BLF_KERNING_STEP_FAST(font, kern_mode, g_prev, g, c_prev, c, pen_x); - /* do not return this loop if clipped, we want every character tested */ - blf_glyph_render(font, g, (float)pen_x, (float)pen_y); + /* do not return this loop if clipped, we want every character tested */ + blf_glyph_render(font, g, (float)pen_x, (float)pen_y); - pen_x += g->advance_i; - g_prev = g; - c_prev = c; - } + pen_x += g->advance_i; + g_prev = g; + c_prev = c; + } - blf_batch_draw_end(); + blf_batch_draw_end(); - if (r_info) { - r_info->lines = 1; - r_info->width = pen_x; - } + if (r_info) { + r_info->lines = 1; + r_info->width = pen_x; + } } void blf_font_draw(FontBLF *font, const char *str, size_t len, struct ResultBLF *r_info) { - blf_font_draw_ex(font, str, len, r_info, 0); + blf_font_draw_ex(font, str, len, r_info, 0); } /* faster version of blf_font_draw, ascii only for view dimensions */ static void blf_font_draw_ascii_ex( - FontBLF *font, const char *str, size_t len, struct ResultBLF *r_info, - int pen_y) + FontBLF *font, const char *str, size_t len, struct ResultBLF *r_info, int pen_y) { - unsigned int c, c_prev = BLI_UTF8_ERR; - GlyphBLF *g, *g_prev = NULL; - int pen_x = 0; - GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; + unsigned int c, c_prev = BLI_UTF8_ERR; + GlyphBLF *g, *g_prev = NULL; + int pen_x = 0; + GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; - BLF_KERNING_VARS(font, has_kerning, kern_mode); + BLF_KERNING_VARS(font, has_kerning, kern_mode); - blf_font_ensure_ascii_table(font); - blf_font_ensure_ascii_kerning(font, kern_mode); + blf_font_ensure_ascii_table(font); + blf_font_ensure_ascii_kerning(font, kern_mode); - blf_batch_draw_begin(font); + blf_batch_draw_begin(font); - while ((c = *(str++)) && len--) { - BLI_assert(c < 128); - if ((g = glyph_ascii_table[c]) == NULL) - continue; - if (has_kerning) - BLF_KERNING_STEP_FAST(font, kern_mode, g_prev, g, c_prev, c, pen_x); + while ((c = *(str++)) && len--) { + BLI_assert(c < 128); + if ((g = glyph_ascii_table[c]) == NULL) + continue; + if (has_kerning) + BLF_KERNING_STEP_FAST(font, kern_mode, g_prev, g, c_prev, c, pen_x); - /* do not return this loop if clipped, we want every character tested */ - blf_glyph_render(font, g, (float)pen_x, (float)pen_y); + /* do not return this loop if clipped, we want every character tested */ + blf_glyph_render(font, g, (float)pen_x, (float)pen_y); - pen_x += g->advance_i; - g_prev = g; - c_prev = c; - } + pen_x += g->advance_i; + g_prev = g; + c_prev = c; + } - blf_batch_draw_end(); + blf_batch_draw_end(); - if (r_info) { - r_info->lines = 1; - r_info->width = pen_x; - } + if (r_info) { + r_info->lines = 1; + r_info->width = pen_x; + } } void blf_font_draw_ascii(FontBLF *font, const char *str, size_t len, struct ResultBLF *r_info) { - blf_font_draw_ascii_ex(font, str, len, r_info, 0); + blf_font_draw_ascii_ex(font, str, len, r_info, 0); } /* use fixed column width, but an utf8 character may occupy multiple columns */ int blf_font_draw_mono(FontBLF *font, const char *str, size_t len, int cwidth) { - unsigned int c; - GlyphBLF *g; - int col, columns = 0; - int pen_x = 0, pen_y = 0; - size_t i = 0; - GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; + unsigned int c; + GlyphBLF *g; + int col, columns = 0; + int pen_x = 0, pen_y = 0; + size_t i = 0; + GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; - blf_font_ensure_ascii_table(font); + blf_font_ensure_ascii_table(font); - blf_batch_draw_begin(font); + blf_batch_draw_begin(font); - while ((i < len) && str[i]) { - BLF_UTF8_NEXT_FAST(font, g, str, i, c, glyph_ascii_table); + while ((i < len) && str[i]) { + BLF_UTF8_NEXT_FAST(font, g, str, i, c, glyph_ascii_table); - if (UNLIKELY(c == BLI_UTF8_ERR)) - break; - if (UNLIKELY(g == NULL)) - continue; + if (UNLIKELY(c == BLI_UTF8_ERR)) + break; + if (UNLIKELY(g == NULL)) + continue; - /* do not return this loop if clipped, we want every character tested */ - blf_glyph_render(font, g, (float)pen_x, (float)pen_y); + /* do not return this loop if clipped, we want every character tested */ + blf_glyph_render(font, g, (float)pen_x, (float)pen_y); - col = BLI_wcwidth((wchar_t)c); - if (col < 0) - col = 1; + col = BLI_wcwidth((wchar_t)c); + if (col < 0) + col = 1; - columns += col; - pen_x += cwidth * col; - } + columns += col; + pen_x += cwidth * col; + } - blf_batch_draw_end(); + blf_batch_draw_end(); - return columns; + return columns; } /* Sanity checks are done by BLF_draw_buffer() */ static void blf_font_draw_buffer_ex( - FontBLF *font, const char *str, size_t len, struct ResultBLF *r_info, - int pen_y) + FontBLF *font, const char *str, size_t len, struct ResultBLF *r_info, int pen_y) { - unsigned int c, c_prev = BLI_UTF8_ERR; - GlyphBLF *g, *g_prev = NULL; - int pen_x = (int)font->pos[0]; - int pen_y_basis = (int)font->pos[1] + pen_y; - size_t i = 0; - GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; - - /* buffer specific vars */ - FontBufInfoBLF *buf_info = &font->buf_info; - const float *b_col_float = buf_info->col_float; - const unsigned char *b_col_char = buf_info->col_char; - int chx, chy; - int y, x; - - BLF_KERNING_VARS(font, has_kerning, kern_mode); - - blf_font_ensure_ascii_table(font); - blf_font_ensure_ascii_kerning(font, kern_mode); - - /* another buffer specific call for color conversion */ - - while ((i < len) && str[i]) { - BLF_UTF8_NEXT_FAST(font, g, str, i, c, glyph_ascii_table); - - if (UNLIKELY(c == BLI_UTF8_ERR)) - break; - if (UNLIKELY(g == NULL)) - continue; - if (has_kerning) - BLF_KERNING_STEP_FAST(font, kern_mode, g_prev, g, c_prev, c, pen_x); - - chx = pen_x + ((int)g->pos_x); - chy = pen_y_basis + g->height; - - if (g->pitch < 0) { - pen_y = pen_y_basis + (g->height - (int)g->pos_y); - } - else { - pen_y = pen_y_basis - (g->height - (int)g->pos_y); - } - - if ((chx + g->width) >= 0 && chx < buf_info->w && (pen_y + g->height) >= 0 && pen_y < buf_info->h) { - /* don't draw beyond the buffer bounds */ - int width_clip = g->width; - int height_clip = g->height; - int yb_start = g->pitch < 0 ? 0 : g->height - 1; - - if (width_clip + chx > buf_info->w) - width_clip -= chx + width_clip - buf_info->w; - if (height_clip + pen_y > buf_info->h) - height_clip -= pen_y + height_clip - buf_info->h; - - /* drawing below the image? */ - if (pen_y < 0) { - yb_start += (g->pitch < 0) ? -pen_y : pen_y; - height_clip += pen_y; - pen_y = 0; - } - - if (buf_info->fbuf) { - int yb = yb_start; - for (y = ((chy >= 0) ? 0 : -chy); y < height_clip; y++) { - for (x = ((chx >= 0) ? 0 : -chx); x < width_clip; x++) { - const char a_byte = *(g->bitmap + x + (yb * g->pitch)); - if (a_byte) { - const float a = (a_byte / 255.0f) * b_col_float[3]; - const size_t buf_ofs = ( - ((size_t)(chx + x) + ((size_t)(pen_y + y) * (size_t)buf_info->w)) * - (size_t)buf_info->ch); - float *fbuf = buf_info->fbuf + buf_ofs; - - if (a >= 1.0f) { - fbuf[0] = b_col_float[0]; - fbuf[1] = b_col_float[1]; - fbuf[2] = b_col_float[2]; - fbuf[3] = 1.0f; - } - else { - fbuf[0] = (b_col_float[0] * a) + (fbuf[0] * (1.0f - a)); - fbuf[1] = (b_col_float[1] * a) + (fbuf[1] * (1.0f - a)); - fbuf[2] = (b_col_float[2] * a) + (fbuf[2] * (1.0f - a)); - fbuf[3] = MIN2(fbuf[3] + a, 1.0f); /* clamp to 1.0 */ - } - } - } - - if (g->pitch < 0) - yb++; - else - yb--; - } - } - - if (buf_info->cbuf) { - int yb = yb_start; - for (y = ((chy >= 0) ? 0 : -chy); y < height_clip; y++) { - for (x = ((chx >= 0) ? 0 : -chx); x < width_clip; x++) { - const char a_byte = *(g->bitmap + x + (yb * g->pitch)); - - if (a_byte) { - const float a = (a_byte / 255.0f) * b_col_float[3]; - const size_t buf_ofs = ( - ((size_t)(chx + x) + ((size_t)(pen_y + y) * (size_t)buf_info->w)) * - (size_t)buf_info->ch); - unsigned char *cbuf = buf_info->cbuf + buf_ofs; - - if (a >= 1.0f) { - cbuf[0] = b_col_char[0]; - cbuf[1] = b_col_char[1]; - cbuf[2] = b_col_char[2]; - cbuf[3] = 255; - } - else { - cbuf[0] = (unsigned char)((b_col_char[0] * a) + (cbuf[0] * (1.0f - a))); - cbuf[1] = (unsigned char)((b_col_char[1] * a) + (cbuf[1] * (1.0f - a))); - cbuf[2] = (unsigned char)((b_col_char[2] * a) + (cbuf[2] * (1.0f - a))); - cbuf[3] = (unsigned char)MIN2((int)cbuf[3] + (int)(a * 255), 255); /* clamp to 255 */ - } - } - } - - if (g->pitch < 0) - yb++; - else - yb--; - } - } - } - - pen_x += g->advance_i; - g_prev = g; - c_prev = c; - } - - if (r_info) { - r_info->lines = 1; - r_info->width = pen_x; - } + unsigned int c, c_prev = BLI_UTF8_ERR; + GlyphBLF *g, *g_prev = NULL; + int pen_x = (int)font->pos[0]; + int pen_y_basis = (int)font->pos[1] + pen_y; + size_t i = 0; + GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; + + /* buffer specific vars */ + FontBufInfoBLF *buf_info = &font->buf_info; + const float *b_col_float = buf_info->col_float; + const unsigned char *b_col_char = buf_info->col_char; + int chx, chy; + int y, x; + + BLF_KERNING_VARS(font, has_kerning, kern_mode); + + blf_font_ensure_ascii_table(font); + blf_font_ensure_ascii_kerning(font, kern_mode); + + /* another buffer specific call for color conversion */ + + while ((i < len) && str[i]) { + BLF_UTF8_NEXT_FAST(font, g, str, i, c, glyph_ascii_table); + + if (UNLIKELY(c == BLI_UTF8_ERR)) + break; + if (UNLIKELY(g == NULL)) + continue; + if (has_kerning) + BLF_KERNING_STEP_FAST(font, kern_mode, g_prev, g, c_prev, c, pen_x); + + chx = pen_x + ((int)g->pos_x); + chy = pen_y_basis + g->height; + + if (g->pitch < 0) { + pen_y = pen_y_basis + (g->height - (int)g->pos_y); + } + else { + pen_y = pen_y_basis - (g->height - (int)g->pos_y); + } + + if ((chx + g->width) >= 0 && chx < buf_info->w && (pen_y + g->height) >= 0 && + pen_y < buf_info->h) { + /* don't draw beyond the buffer bounds */ + int width_clip = g->width; + int height_clip = g->height; + int yb_start = g->pitch < 0 ? 0 : g->height - 1; + + if (width_clip + chx > buf_info->w) + width_clip -= chx + width_clip - buf_info->w; + if (height_clip + pen_y > buf_info->h) + height_clip -= pen_y + height_clip - buf_info->h; + + /* drawing below the image? */ + if (pen_y < 0) { + yb_start += (g->pitch < 0) ? -pen_y : pen_y; + height_clip += pen_y; + pen_y = 0; + } + + if (buf_info->fbuf) { + int yb = yb_start; + for (y = ((chy >= 0) ? 0 : -chy); y < height_clip; y++) { + for (x = ((chx >= 0) ? 0 : -chx); x < width_clip; x++) { + const char a_byte = *(g->bitmap + x + (yb * g->pitch)); + if (a_byte) { + const float a = (a_byte / 255.0f) * b_col_float[3]; + const size_t buf_ofs = (((size_t)(chx + x) + + ((size_t)(pen_y + y) * (size_t)buf_info->w)) * + (size_t)buf_info->ch); + float *fbuf = buf_info->fbuf + buf_ofs; + + if (a >= 1.0f) { + fbuf[0] = b_col_float[0]; + fbuf[1] = b_col_float[1]; + fbuf[2] = b_col_float[2]; + fbuf[3] = 1.0f; + } + else { + fbuf[0] = (b_col_float[0] * a) + (fbuf[0] * (1.0f - a)); + fbuf[1] = (b_col_float[1] * a) + (fbuf[1] * (1.0f - a)); + fbuf[2] = (b_col_float[2] * a) + (fbuf[2] * (1.0f - a)); + fbuf[3] = MIN2(fbuf[3] + a, 1.0f); /* clamp to 1.0 */ + } + } + } + + if (g->pitch < 0) + yb++; + else + yb--; + } + } + + if (buf_info->cbuf) { + int yb = yb_start; + for (y = ((chy >= 0) ? 0 : -chy); y < height_clip; y++) { + for (x = ((chx >= 0) ? 0 : -chx); x < width_clip; x++) { + const char a_byte = *(g->bitmap + x + (yb * g->pitch)); + + if (a_byte) { + const float a = (a_byte / 255.0f) * b_col_float[3]; + const size_t buf_ofs = (((size_t)(chx + x) + + ((size_t)(pen_y + y) * (size_t)buf_info->w)) * + (size_t)buf_info->ch); + unsigned char *cbuf = buf_info->cbuf + buf_ofs; + + if (a >= 1.0f) { + cbuf[0] = b_col_char[0]; + cbuf[1] = b_col_char[1]; + cbuf[2] = b_col_char[2]; + cbuf[3] = 255; + } + else { + cbuf[0] = (unsigned char)((b_col_char[0] * a) + (cbuf[0] * (1.0f - a))); + cbuf[1] = (unsigned char)((b_col_char[1] * a) + (cbuf[1] * (1.0f - a))); + cbuf[2] = (unsigned char)((b_col_char[2] * a) + (cbuf[2] * (1.0f - a))); + cbuf[3] = (unsigned char)MIN2((int)cbuf[3] + (int)(a * 255), + 255); /* clamp to 255 */ + } + } + } + + if (g->pitch < 0) + yb++; + else + yb--; + } + } + } + + pen_x += g->advance_i; + g_prev = g; + c_prev = c; + } + + if (r_info) { + r_info->lines = 1; + r_info->width = pen_x; + } } -void blf_font_draw_buffer( - FontBLF *font, const char *str, size_t len, struct ResultBLF *r_info) +void blf_font_draw_buffer(FontBLF *font, const char *str, size_t len, struct ResultBLF *r_info) { - blf_font_draw_buffer_ex(font, str, len, r_info, 0); + blf_font_draw_buffer_ex(font, str, len, r_info, 0); } -static bool blf_font_width_to_strlen_glyph_process( - FontBLF *font, const bool has_kerning, const FT_UInt kern_mode, - const uint c_prev, const uint c, GlyphBLF *g_prev, GlyphBLF *g, - int *pen_x, const int width_i) +static bool blf_font_width_to_strlen_glyph_process(FontBLF *font, + const bool has_kerning, + const FT_UInt kern_mode, + const uint c_prev, + const uint c, + GlyphBLF *g_prev, + GlyphBLF *g, + int *pen_x, + const int width_i) { - if (UNLIKELY(c == BLI_UTF8_ERR)) { - return true; /* break the calling loop. */ - } - if (UNLIKELY(g == NULL)) { - return false; /* continue the calling loop. */ - } - if (has_kerning) { - BLF_KERNING_STEP_FAST(font, kern_mode, g_prev, g, c_prev, c, *pen_x); - } - - *pen_x += g->advance_i; - - return (*pen_x >= width_i); + if (UNLIKELY(c == BLI_UTF8_ERR)) { + return true; /* break the calling loop. */ + } + if (UNLIKELY(g == NULL)) { + return false; /* continue the calling loop. */ + } + if (has_kerning) { + BLF_KERNING_STEP_FAST(font, kern_mode, g_prev, g, c_prev, c, *pen_x); + } + + *pen_x += g->advance_i; + + return (*pen_x >= width_i); } -size_t blf_font_width_to_strlen(FontBLF *font, const char *str, size_t len, float width, float *r_width) +size_t blf_font_width_to_strlen( + FontBLF *font, const char *str, size_t len, float width, float *r_width) { - unsigned int c, c_prev; - GlyphBLF *g, *g_prev; - int pen_x, width_new; - size_t i, i_prev; - GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; - const int width_i = (int)width; - - BLF_KERNING_VARS(font, has_kerning, kern_mode); - - blf_font_ensure_ascii_table(font); - if (has_kerning) { - blf_font_ensure_ascii_kerning(font, kern_mode); - } - - for (i_prev = i = 0, width_new = pen_x = 0, g_prev = NULL, c_prev = 0; - (i < len) && str[i]; - i_prev = i, width_new = pen_x, c_prev = c, g_prev = g) - { - BLF_UTF8_NEXT_FAST(font, g, str, i, c, glyph_ascii_table); - - if (blf_font_width_to_strlen_glyph_process( - font, has_kerning, kern_mode, - c_prev, c, g_prev, g, - &pen_x, width_i)) - { - break; - } - } - - if (r_width) { - *r_width = (float)width_new; - } - - return i_prev; + unsigned int c, c_prev; + GlyphBLF *g, *g_prev; + int pen_x, width_new; + size_t i, i_prev; + GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; + const int width_i = (int)width; + + BLF_KERNING_VARS(font, has_kerning, kern_mode); + + blf_font_ensure_ascii_table(font); + if (has_kerning) { + blf_font_ensure_ascii_kerning(font, kern_mode); + } + + for (i_prev = i = 0, width_new = pen_x = 0, g_prev = NULL, c_prev = 0; (i < len) && str[i]; + i_prev = i, width_new = pen_x, c_prev = c, g_prev = g) { + BLF_UTF8_NEXT_FAST(font, g, str, i, c, glyph_ascii_table); + + if (blf_font_width_to_strlen_glyph_process( + font, has_kerning, kern_mode, c_prev, c, g_prev, g, &pen_x, width_i)) { + break; + } + } + + if (r_width) { + *r_width = (float)width_new; + } + + return i_prev; } -size_t blf_font_width_to_rstrlen(FontBLF *font, const char *str, size_t len, float width, float *r_width) +size_t blf_font_width_to_rstrlen( + FontBLF *font, const char *str, size_t len, float width, float *r_width) { - unsigned int c, c_prev; - GlyphBLF *g, *g_prev; - int pen_x, width_new; - size_t i, i_prev, i_tmp; - char *s, *s_prev; - GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; - const int width_i = (int)width; - - BLF_KERNING_VARS(font, has_kerning, kern_mode); - - blf_font_ensure_ascii_table(font); - if (has_kerning) { - blf_font_ensure_ascii_kerning(font, kern_mode); - } - - i = BLI_strnlen(str, len); - s = BLI_str_find_prev_char_utf8(str, &str[i]); - i = (size_t)((s != NULL) ? s - str : 0); - s_prev = BLI_str_find_prev_char_utf8(str, s); - i_prev = (size_t)((s_prev != NULL) ? s_prev - str : 0); - - i_tmp = i; - BLF_UTF8_NEXT_FAST(font, g, str, i_tmp, c, glyph_ascii_table); - for (width_new = pen_x = 0; - (s != NULL); - i = i_prev, s = s_prev, c = c_prev, g = g_prev, g_prev = NULL, width_new = pen_x) - { - s_prev = BLI_str_find_prev_char_utf8(str, s); - i_prev = (size_t)((s_prev != NULL) ? s_prev - str : 0); - - if (s_prev != NULL) { - i_tmp = i_prev; - BLF_UTF8_NEXT_FAST(font, g_prev, str, i_tmp, c_prev, glyph_ascii_table); - BLI_assert(i_tmp == i); - } - - if (blf_font_width_to_strlen_glyph_process( - font, has_kerning, kern_mode, - c_prev, c, g_prev, g, - &pen_x, width_i)) - { - break; - } - } - - if (r_width) { - *r_width = (float)width_new; - } - - return i; + unsigned int c, c_prev; + GlyphBLF *g, *g_prev; + int pen_x, width_new; + size_t i, i_prev, i_tmp; + char *s, *s_prev; + GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; + const int width_i = (int)width; + + BLF_KERNING_VARS(font, has_kerning, kern_mode); + + blf_font_ensure_ascii_table(font); + if (has_kerning) { + blf_font_ensure_ascii_kerning(font, kern_mode); + } + + i = BLI_strnlen(str, len); + s = BLI_str_find_prev_char_utf8(str, &str[i]); + i = (size_t)((s != NULL) ? s - str : 0); + s_prev = BLI_str_find_prev_char_utf8(str, s); + i_prev = (size_t)((s_prev != NULL) ? s_prev - str : 0); + + i_tmp = i; + BLF_UTF8_NEXT_FAST(font, g, str, i_tmp, c, glyph_ascii_table); + for (width_new = pen_x = 0; (s != NULL); + i = i_prev, s = s_prev, c = c_prev, g = g_prev, g_prev = NULL, width_new = pen_x) { + s_prev = BLI_str_find_prev_char_utf8(str, s); + i_prev = (size_t)((s_prev != NULL) ? s_prev - str : 0); + + if (s_prev != NULL) { + i_tmp = i_prev; + BLF_UTF8_NEXT_FAST(font, g_prev, str, i_tmp, c_prev, glyph_ascii_table); + BLI_assert(i_tmp == i); + } + + if (blf_font_width_to_strlen_glyph_process( + font, has_kerning, kern_mode, c_prev, c, g_prev, g, &pen_x, width_i)) { + break; + } + } + + if (r_width) { + *r_width = (float)width_new; + } + + return i; } static void blf_font_boundbox_ex( - FontBLF *font, const char *str, size_t len, rctf *box, struct ResultBLF *r_info, - int pen_y) + FontBLF *font, const char *str, size_t len, rctf *box, struct ResultBLF *r_info, int pen_y) { - unsigned int c, c_prev = BLI_UTF8_ERR; - GlyphBLF *g, *g_prev = NULL; - int pen_x = 0; - size_t i = 0; - GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; - - rctf gbox; - - BLF_KERNING_VARS(font, has_kerning, kern_mode); - - box->xmin = 32000.0f; - box->xmax = -32000.0f; - box->ymin = 32000.0f; - box->ymax = -32000.0f; - - blf_font_ensure_ascii_table(font); - blf_font_ensure_ascii_kerning(font, kern_mode); - - while ((i < len) && str[i]) { - BLF_UTF8_NEXT_FAST(font, g, str, i, c, glyph_ascii_table); - - if (UNLIKELY(c == BLI_UTF8_ERR)) - break; - if (UNLIKELY(g == NULL)) - continue; - if (has_kerning) - BLF_KERNING_STEP_FAST(font, kern_mode, g_prev, g, c_prev, c, pen_x); - - gbox.xmin = (float)pen_x; - gbox.xmax = (float)pen_x + g->advance; - gbox.ymin = g->box.ymin + (float)pen_y; - gbox.ymax = g->box.ymax + (float)pen_y; - - if (gbox.xmin < box->xmin) box->xmin = gbox.xmin; - if (gbox.ymin < box->ymin) box->ymin = gbox.ymin; - - if (gbox.xmax > box->xmax) box->xmax = gbox.xmax; - if (gbox.ymax > box->ymax) box->ymax = gbox.ymax; - - pen_x += g->advance_i; - g_prev = g; - c_prev = c; - } - - if (box->xmin > box->xmax) { - box->xmin = 0.0f; - box->ymin = 0.0f; - box->xmax = 0.0f; - box->ymax = 0.0f; - } - - if (r_info) { - r_info->lines = 1; - r_info->width = pen_x; - } + unsigned int c, c_prev = BLI_UTF8_ERR; + GlyphBLF *g, *g_prev = NULL; + int pen_x = 0; + size_t i = 0; + GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; + + rctf gbox; + + BLF_KERNING_VARS(font, has_kerning, kern_mode); + + box->xmin = 32000.0f; + box->xmax = -32000.0f; + box->ymin = 32000.0f; + box->ymax = -32000.0f; + + blf_font_ensure_ascii_table(font); + blf_font_ensure_ascii_kerning(font, kern_mode); + + while ((i < len) && str[i]) { + BLF_UTF8_NEXT_FAST(font, g, str, i, c, glyph_ascii_table); + + if (UNLIKELY(c == BLI_UTF8_ERR)) + break; + if (UNLIKELY(g == NULL)) + continue; + if (has_kerning) + BLF_KERNING_STEP_FAST(font, kern_mode, g_prev, g, c_prev, c, pen_x); + + gbox.xmin = (float)pen_x; + gbox.xmax = (float)pen_x + g->advance; + gbox.ymin = g->box.ymin + (float)pen_y; + gbox.ymax = g->box.ymax + (float)pen_y; + + if (gbox.xmin < box->xmin) + box->xmin = gbox.xmin; + if (gbox.ymin < box->ymin) + box->ymin = gbox.ymin; + + if (gbox.xmax > box->xmax) + box->xmax = gbox.xmax; + if (gbox.ymax > box->ymax) + box->ymax = gbox.ymax; + + pen_x += g->advance_i; + g_prev = g; + c_prev = c; + } + + if (box->xmin > box->xmax) { + box->xmin = 0.0f; + box->ymin = 0.0f; + box->xmax = 0.0f; + box->ymax = 0.0f; + } + + if (r_info) { + r_info->lines = 1; + r_info->width = pen_x; + } } -void blf_font_boundbox(FontBLF *font, const char *str, size_t len, rctf *r_box, struct ResultBLF *r_info) +void blf_font_boundbox( + FontBLF *font, const char *str, size_t len, rctf *r_box, struct ResultBLF *r_info) { - blf_font_boundbox_ex(font, str, len, r_box, r_info, 0); + blf_font_boundbox_ex(font, str, len, r_box, r_info, 0); } - /* -------------------------------------------------------------------- */ /** \name Word-Wrap Support * \{ */ - /** * Generic function to add word-wrap support for other existing functions. * @@ -830,377 +821,392 @@ void blf_font_boundbox(FontBLF *font, const char *str, size_t len, rctf *r_box, * (color, bold, switching fonts... etc). */ static void blf_font_wrap_apply( - FontBLF *font, const char *str, size_t len, struct ResultBLF *r_info, - void (*callback)(FontBLF *font, const char *str, size_t len, int pen_y, void *userdata), - void *userdata) + FontBLF *font, + const char *str, + size_t len, + struct ResultBLF *r_info, + void (*callback)(FontBLF *font, const char *str, size_t len, int pen_y, void *userdata), + void *userdata) { - unsigned int c; - GlyphBLF *g, *g_prev = NULL; - FT_Vector delta; - int pen_x = 0, pen_y = 0; - size_t i = 0; - GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; - int lines = 0; - int pen_x_next = 0; - - BLF_KERNING_VARS(font, has_kerning, kern_mode); - - struct WordWrapVars { - int wrap_width; - size_t start, last[2]; - } wrap = {font->wrap_width != -1 ? font->wrap_width : INT_MAX, 0, {0, 0}}; - - blf_font_ensure_ascii_table(font); - // printf("%s wrapping (%d, %d) `%s`:\n", __func__, len, strlen(str), str); - while ((i < len) && str[i]) { - - /* wrap vars */ - size_t i_curr = i; - bool do_draw = false; - - BLF_UTF8_NEXT_FAST(font, g, str, i, c, glyph_ascii_table); - - if (UNLIKELY(c == BLI_UTF8_ERR)) - break; - if (UNLIKELY(g == NULL)) - continue; - if (has_kerning) - BLF_KERNING_STEP(font, kern_mode, g_prev, g, delta, pen_x); - - /** - * Implementation Detail (utf8). - * - * Take care with single byte offsets here, - * since this is utf8 we can't be sure a single byte is a single character. - * - * This is _only_ done when we know for sure the character is ascii (newline or a space). - */ - pen_x_next = pen_x + g->advance_i; - if (UNLIKELY((pen_x_next >= wrap.wrap_width) && (wrap.start != wrap.last[0]))) { - do_draw = true; - } - else if (UNLIKELY(((i < len) && str[i]) == 0)) { - /* need check here for trailing newline, else we draw it */ - wrap.last[0] = i + ((g->c != '\n') ? 1 : 0); - wrap.last[1] = i; - do_draw = true; - } - else if (UNLIKELY(g->c == '\n')) { - wrap.last[0] = i_curr + 1; - wrap.last[1] = i; - do_draw = true; - } - else if (UNLIKELY(g->c != ' ' && (g_prev ? g_prev->c == ' ' : false))) { - wrap.last[0] = i_curr; - wrap.last[1] = i_curr; - } - - if (UNLIKELY(do_draw)) { - // printf("(%03d..%03d) `%.*s`\n", - // wrap.start, wrap.last[0], (wrap.last[0] - wrap.start) - 1, &str[wrap.start]); - - callback(font, &str[wrap.start], (wrap.last[0] - wrap.start) - 1, pen_y, userdata); - wrap.start = wrap.last[0]; - i = wrap.last[1]; - pen_x = 0; - pen_y -= font->glyph_cache->glyph_height_max; - g_prev = NULL; - lines += 1; - continue; - } - - pen_x = pen_x_next; - g_prev = g; - } - - // printf("done! lines: %d, width, %d\n", lines, pen_x_next); - - if (r_info) { - r_info->lines = lines; - /* width of last line only (with wrapped lines) */ - r_info->width = pen_x_next; - } + unsigned int c; + GlyphBLF *g, *g_prev = NULL; + FT_Vector delta; + int pen_x = 0, pen_y = 0; + size_t i = 0; + GlyphBLF **glyph_ascii_table = font->glyph_cache->glyph_ascii_table; + int lines = 0; + int pen_x_next = 0; + + BLF_KERNING_VARS(font, has_kerning, kern_mode); + + struct WordWrapVars { + int wrap_width; + size_t start, last[2]; + } wrap = {font->wrap_width != -1 ? font->wrap_width : INT_MAX, 0, {0, 0}}; + + blf_font_ensure_ascii_table(font); + // printf("%s wrapping (%d, %d) `%s`:\n", __func__, len, strlen(str), str); + while ((i < len) && str[i]) { + + /* wrap vars */ + size_t i_curr = i; + bool do_draw = false; + + BLF_UTF8_NEXT_FAST(font, g, str, i, c, glyph_ascii_table); + + if (UNLIKELY(c == BLI_UTF8_ERR)) + break; + if (UNLIKELY(g == NULL)) + continue; + if (has_kerning) + BLF_KERNING_STEP(font, kern_mode, g_prev, g, delta, pen_x); + + /** + * Implementation Detail (utf8). + * + * Take care with single byte offsets here, + * since this is utf8 we can't be sure a single byte is a single character. + * + * This is _only_ done when we know for sure the character is ascii (newline or a space). + */ + pen_x_next = pen_x + g->advance_i; + if (UNLIKELY((pen_x_next >= wrap.wrap_width) && (wrap.start != wrap.last[0]))) { + do_draw = true; + } + else if (UNLIKELY(((i < len) && str[i]) == 0)) { + /* need check here for trailing newline, else we draw it */ + wrap.last[0] = i + ((g->c != '\n') ? 1 : 0); + wrap.last[1] = i; + do_draw = true; + } + else if (UNLIKELY(g->c == '\n')) { + wrap.last[0] = i_curr + 1; + wrap.last[1] = i; + do_draw = true; + } + else if (UNLIKELY(g->c != ' ' && (g_prev ? g_prev->c == ' ' : false))) { + wrap.last[0] = i_curr; + wrap.last[1] = i_curr; + } + + if (UNLIKELY(do_draw)) { + // printf("(%03d..%03d) `%.*s`\n", + // wrap.start, wrap.last[0], (wrap.last[0] - wrap.start) - 1, &str[wrap.start]); + + callback(font, &str[wrap.start], (wrap.last[0] - wrap.start) - 1, pen_y, userdata); + wrap.start = wrap.last[0]; + i = wrap.last[1]; + pen_x = 0; + pen_y -= font->glyph_cache->glyph_height_max; + g_prev = NULL; + lines += 1; + continue; + } + + pen_x = pen_x_next; + g_prev = g; + } + + // printf("done! lines: %d, width, %d\n", lines, pen_x_next); + + if (r_info) { + r_info->lines = lines; + /* width of last line only (with wrapped lines) */ + r_info->width = pen_x_next; + } } /* blf_font_draw__wrap */ -static void blf_font_draw__wrap_cb(FontBLF *font, const char *str, size_t len, int pen_y, void *UNUSED(userdata)) +static void blf_font_draw__wrap_cb( + FontBLF *font, const char *str, size_t len, int pen_y, void *UNUSED(userdata)) { - blf_font_draw_ex(font, str, len, NULL, pen_y); + blf_font_draw_ex(font, str, len, NULL, pen_y); } void blf_font_draw__wrap(FontBLF *font, const char *str, size_t len, struct ResultBLF *r_info) { - blf_font_wrap_apply(font, str, len, r_info, blf_font_draw__wrap_cb, NULL); + blf_font_wrap_apply(font, str, len, r_info, blf_font_draw__wrap_cb, NULL); } /* blf_font_boundbox__wrap */ -static void blf_font_boundbox_wrap_cb(FontBLF *font, const char *str, size_t len, int pen_y, void *userdata) +static void blf_font_boundbox_wrap_cb( + FontBLF *font, const char *str, size_t len, int pen_y, void *userdata) { - rctf *box = userdata; - rctf box_single; + rctf *box = userdata; + rctf box_single; - blf_font_boundbox_ex(font, str, len, &box_single, NULL, pen_y); - BLI_rctf_union(box, &box_single); + blf_font_boundbox_ex(font, str, len, &box_single, NULL, pen_y); + BLI_rctf_union(box, &box_single); } -void blf_font_boundbox__wrap(FontBLF *font, const char *str, size_t len, rctf *box, struct ResultBLF *r_info) +void blf_font_boundbox__wrap( + FontBLF *font, const char *str, size_t len, rctf *box, struct ResultBLF *r_info) { - box->xmin = 32000.0f; - box->xmax = -32000.0f; - box->ymin = 32000.0f; - box->ymax = -32000.0f; + box->xmin = 32000.0f; + box->xmax = -32000.0f; + box->ymin = 32000.0f; + box->ymax = -32000.0f; - blf_font_wrap_apply(font, str, len, r_info, blf_font_boundbox_wrap_cb, box); + blf_font_wrap_apply(font, str, len, r_info, blf_font_boundbox_wrap_cb, box); } /* blf_font_draw_buffer__wrap */ -static void blf_font_draw_buffer__wrap_cb(FontBLF *font, const char *str, size_t len, int pen_y, void *UNUSED(userdata)) +static void blf_font_draw_buffer__wrap_cb( + FontBLF *font, const char *str, size_t len, int pen_y, void *UNUSED(userdata)) { - blf_font_draw_buffer_ex(font, str, len, NULL, pen_y); + blf_font_draw_buffer_ex(font, str, len, NULL, pen_y); } -void blf_font_draw_buffer__wrap(FontBLF *font, const char *str, size_t len, struct ResultBLF *r_info) +void blf_font_draw_buffer__wrap(FontBLF *font, + const char *str, + size_t len, + struct ResultBLF *r_info) { - blf_font_wrap_apply(font, str, len, r_info, blf_font_draw_buffer__wrap_cb, NULL); + blf_font_wrap_apply(font, str, len, r_info, blf_font_draw_buffer__wrap_cb, NULL); } /** \} */ - -void blf_font_width_and_height( - FontBLF *font, const char *str, size_t len, - float *r_width, float *r_height, struct ResultBLF *r_info) +void blf_font_width_and_height(FontBLF *font, + const char *str, + size_t len, + float *r_width, + float *r_height, + struct ResultBLF *r_info) { - float xa, ya; - rctf box; - - if (font->flags & BLF_ASPECT) { - xa = font->aspect[0]; - ya = font->aspect[1]; - } - else { - xa = 1.0f; - ya = 1.0f; - } - - if (font->flags & BLF_WORD_WRAP) { - blf_font_boundbox__wrap(font, str, len, &box, r_info); - } - else { - blf_font_boundbox(font, str, len, &box, r_info); - } - *r_width = (BLI_rctf_size_x(&box) * xa); - *r_height = (BLI_rctf_size_y(&box) * ya); + float xa, ya; + rctf box; + + if (font->flags & BLF_ASPECT) { + xa = font->aspect[0]; + ya = font->aspect[1]; + } + else { + xa = 1.0f; + ya = 1.0f; + } + + if (font->flags & BLF_WORD_WRAP) { + blf_font_boundbox__wrap(font, str, len, &box, r_info); + } + else { + blf_font_boundbox(font, str, len, &box, r_info); + } + *r_width = (BLI_rctf_size_x(&box) * xa); + *r_height = (BLI_rctf_size_y(&box) * ya); } float blf_font_width(FontBLF *font, const char *str, size_t len, struct ResultBLF *r_info) { - float xa; - rctf box; - - if (font->flags & BLF_ASPECT) - xa = font->aspect[0]; - else - xa = 1.0f; - - if (font->flags & BLF_WORD_WRAP) { - blf_font_boundbox__wrap(font, str, len, &box, r_info); - } - else { - blf_font_boundbox(font, str, len, &box, r_info); - } - return BLI_rctf_size_x(&box) * xa; + float xa; + rctf box; + + if (font->flags & BLF_ASPECT) + xa = font->aspect[0]; + else + xa = 1.0f; + + if (font->flags & BLF_WORD_WRAP) { + blf_font_boundbox__wrap(font, str, len, &box, r_info); + } + else { + blf_font_boundbox(font, str, len, &box, r_info); + } + return BLI_rctf_size_x(&box) * xa; } float blf_font_height(FontBLF *font, const char *str, size_t len, struct ResultBLF *r_info) { - float ya; - rctf box; - - if (font->flags & BLF_ASPECT) - ya = font->aspect[1]; - else - ya = 1.0f; - - if (font->flags & BLF_WORD_WRAP) { - blf_font_boundbox__wrap(font, str, len, &box, r_info); - } - else { - blf_font_boundbox(font, str, len, &box, r_info); - } - return BLI_rctf_size_y(&box) * ya; + float ya; + rctf box; + + if (font->flags & BLF_ASPECT) + ya = font->aspect[1]; + else + ya = 1.0f; + + if (font->flags & BLF_WORD_WRAP) { + blf_font_boundbox__wrap(font, str, len, &box, r_info); + } + else { + blf_font_boundbox(font, str, len, &box, r_info); + } + return BLI_rctf_size_y(&box) * ya; } float blf_font_fixed_width(FontBLF *font) { - const unsigned int c = ' '; - GlyphBLF *g = blf_glyph_search(font->glyph_cache, c); - if (!g) { - g = blf_glyph_add(font, FT_Get_Char_Index(font->face, c), c); - - /* if we don't find the glyph. */ - if (!g) { - return 0.0f; - } - } - - return g->advance; + const unsigned int c = ' '; + GlyphBLF *g = blf_glyph_search(font->glyph_cache, c); + if (!g) { + g = blf_glyph_add(font, FT_Get_Char_Index(font->face, c), c); + + /* if we don't find the glyph. */ + if (!g) { + return 0.0f; + } + } + + return g->advance; } -int blf_font_count_missing_chars(FontBLF *font, const char *str, const size_t len, int *r_tot_chars) +int blf_font_count_missing_chars(FontBLF *font, + const char *str, + const size_t len, + int *r_tot_chars) { - int missing = 0; - size_t i = 0; - - *r_tot_chars = 0; - while (i < len) { - unsigned int c; - - if ((c = str[i]) < 0x80) { - i++; - } - else if ((c = BLI_str_utf8_as_unicode_step(str, &i)) != BLI_UTF8_ERR) { - if (FT_Get_Char_Index((font)->face, c) == 0) { - missing++; - } - } - (*r_tot_chars)++; - } - return missing; + int missing = 0; + size_t i = 0; + + *r_tot_chars = 0; + while (i < len) { + unsigned int c; + + if ((c = str[i]) < 0x80) { + i++; + } + else if ((c = BLI_str_utf8_as_unicode_step(str, &i)) != BLI_UTF8_ERR) { + if (FT_Get_Char_Index((font)->face, c) == 0) { + missing++; + } + } + (*r_tot_chars)++; + } + return missing; } void blf_font_free(FontBLF *font) { - GlyphCacheBLF *gc; + GlyphCacheBLF *gc; - font->glyph_cache = NULL; - while ((gc = BLI_pophead(&font->cache))) { - blf_glyph_cache_free(gc); - } + font->glyph_cache = NULL; + while ((gc = BLI_pophead(&font->cache))) { + blf_glyph_cache_free(gc); + } - blf_kerning_cache_clear(font); + blf_kerning_cache_clear(font); - FT_Done_Face(font->face); - if (font->filename) - MEM_freeN(font->filename); - if (font->name) - MEM_freeN(font->name); - MEM_freeN(font); + FT_Done_Face(font->face); + if (font->filename) + MEM_freeN(font->filename); + if (font->name) + MEM_freeN(font->name); + MEM_freeN(font); } static void blf_font_fill(FontBLF *font) { - font->aspect[0] = 1.0f; - font->aspect[1] = 1.0f; - font->aspect[2] = 1.0f; - font->pos[0] = 0.0f; - font->pos[1] = 0.0f; - font->angle = 0.0f; - - for (int i = 0; i < 16; i++) - font->m[i] = 0; - - /* annoying bright color so we can see where to add BLF_color calls */ - font->color[0] = 255; - font->color[1] = 255; - font->color[2] = 0; - font->color[3] = 255; - - font->clip_rec.xmin = 0.0f; - font->clip_rec.xmax = 0.0f; - font->clip_rec.ymin = 0.0f; - font->clip_rec.ymax = 0.0f; - font->flags = 0; - font->dpi = 0; - font->size = 0; - BLI_listbase_clear(&font->cache); - BLI_listbase_clear(&font->kerning_caches); - font->glyph_cache = NULL; - font->kerning_cache = NULL; + font->aspect[0] = 1.0f; + font->aspect[1] = 1.0f; + font->aspect[2] = 1.0f; + font->pos[0] = 0.0f; + font->pos[1] = 0.0f; + font->angle = 0.0f; + + for (int i = 0; i < 16; i++) + font->m[i] = 0; + + /* annoying bright color so we can see where to add BLF_color calls */ + font->color[0] = 255; + font->color[1] = 255; + font->color[2] = 0; + font->color[3] = 255; + + font->clip_rec.xmin = 0.0f; + font->clip_rec.xmax = 0.0f; + font->clip_rec.ymin = 0.0f; + font->clip_rec.ymax = 0.0f; + font->flags = 0; + font->dpi = 0; + font->size = 0; + BLI_listbase_clear(&font->cache); + BLI_listbase_clear(&font->kerning_caches); + font->glyph_cache = NULL; + font->kerning_cache = NULL; #if BLF_BLUR_ENABLE - font->blur = 0; + font->blur = 0; #endif - font->tex_size_max = -1; - - font->buf_info.fbuf = NULL; - font->buf_info.cbuf = NULL; - font->buf_info.w = 0; - font->buf_info.h = 0; - font->buf_info.ch = 0; - font->buf_info.col_init[0] = 0; - font->buf_info.col_init[1] = 0; - font->buf_info.col_init[2] = 0; - font->buf_info.col_init[3] = 0; - - font->ft_lib = ft_lib; - font->ft_lib_mutex = &ft_lib_mutex; + font->tex_size_max = -1; + + font->buf_info.fbuf = NULL; + font->buf_info.cbuf = NULL; + font->buf_info.w = 0; + font->buf_info.h = 0; + font->buf_info.ch = 0; + font->buf_info.col_init[0] = 0; + font->buf_info.col_init[1] = 0; + font->buf_info.col_init[2] = 0; + font->buf_info.col_init[3] = 0; + + font->ft_lib = ft_lib; + font->ft_lib_mutex = &ft_lib_mutex; } FontBLF *blf_font_new(const char *name, const char *filename) { - FontBLF *font; - FT_Error err; - char *mfile; - - font = (FontBLF *)MEM_callocN(sizeof(FontBLF), "blf_font_new"); - err = FT_New_Face(ft_lib, filename, 0, &font->face); - if (err) { - MEM_freeN(font); - return NULL; - } - - err = FT_Select_Charmap(font->face, ft_encoding_unicode); - if (err) { - printf("Can't set the unicode character map!\n"); - FT_Done_Face(font->face); - MEM_freeN(font); - return NULL; - } - - mfile = blf_dir_metrics_search(filename); - if (mfile) { - err = FT_Attach_File(font->face, mfile); - if (err) { - fprintf(stderr, "FT_Attach_File failed to load '%s' with error %d\n", filename, (int)err); - } - MEM_freeN(mfile); - } - - font->name = BLI_strdup(name); - font->filename = BLI_strdup(filename); - blf_font_fill(font); - return font; + FontBLF *font; + FT_Error err; + char *mfile; + + font = (FontBLF *)MEM_callocN(sizeof(FontBLF), "blf_font_new"); + err = FT_New_Face(ft_lib, filename, 0, &font->face); + if (err) { + MEM_freeN(font); + return NULL; + } + + err = FT_Select_Charmap(font->face, ft_encoding_unicode); + if (err) { + printf("Can't set the unicode character map!\n"); + FT_Done_Face(font->face); + MEM_freeN(font); + return NULL; + } + + mfile = blf_dir_metrics_search(filename); + if (mfile) { + err = FT_Attach_File(font->face, mfile); + if (err) { + fprintf(stderr, "FT_Attach_File failed to load '%s' with error %d\n", filename, (int)err); + } + MEM_freeN(mfile); + } + + font->name = BLI_strdup(name); + font->filename = BLI_strdup(filename); + blf_font_fill(font); + return font; } void blf_font_attach_from_mem(FontBLF *font, const unsigned char *mem, int mem_size) { - FT_Open_Args open; + FT_Open_Args open; - open.flags = FT_OPEN_MEMORY; - open.memory_base = (const FT_Byte *)mem; - open.memory_size = mem_size; - FT_Attach_Stream(font->face, &open); + open.flags = FT_OPEN_MEMORY; + open.memory_base = (const FT_Byte *)mem; + open.memory_size = mem_size; + FT_Attach_Stream(font->face, &open); } FontBLF *blf_font_new_from_mem(const char *name, const unsigned char *mem, int mem_size) { - FontBLF *font; - FT_Error err; - - font = (FontBLF *)MEM_callocN(sizeof(FontBLF), "blf_font_new_from_mem"); - err = FT_New_Memory_Face(ft_lib, mem, mem_size, 0, &font->face); - if (err) { - MEM_freeN(font); - return NULL; - } - - err = FT_Select_Charmap(font->face, ft_encoding_unicode); - if (err) { - printf("Can't set the unicode character map!\n"); - FT_Done_Face(font->face); - MEM_freeN(font); - return NULL; - } - - font->name = BLI_strdup(name); - font->filename = NULL; - blf_font_fill(font); - return font; + FontBLF *font; + FT_Error err; + + font = (FontBLF *)MEM_callocN(sizeof(FontBLF), "blf_font_new_from_mem"); + err = FT_New_Memory_Face(ft_lib, mem, mem_size, 0, &font->face); + if (err) { + MEM_freeN(font); + return NULL; + } + + err = FT_Select_Charmap(font->face, ft_encoding_unicode); + if (err) { + printf("Can't set the unicode character map!\n"); + FT_Done_Face(font->face); + MEM_freeN(font); + return NULL; + } + + font->name = BLI_strdup(name); + font->filename = NULL; + blf_font_fill(font); + return font; } -- cgit v1.2.3