path: root/src/vkvg_fonts.c

// Copyright (c) 2018-2026 Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
//
// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
#include "vkvg_fonts.h"
#include "vkvg_context_internal.h"
#include "vkvg_device_internal.h"
#include "vkvg_surface_internal.h"

#include "vkh.h"

#include <stdlib.h>
#include <locale.h>
#include <string.h>
#include <wchar.h>

#ifdef VKVG_USE_FREETYPE
#define CHECK_FACE_FLAG(flags, flag, buffer) \
do { \
        if ((flags) & (flag)) { \
            if (buffer[0] != '\0') strcat(buffer, " | "); \
            strcat(buffer, #flag); \
    } \
} while (0)

    /**
     * Converts face_flags bitmask to a human-readable string.
     * Make sure the output buffer is large enough (e.g., 512 bytes).
     */
    void ft_face_flags_to_string(FT_Long face_flags, char* out_str, size_t max_len) {
    if (!out_str || max_len == 0) return;
    out_str[0] = '\0';

    CHECK_FACE_FLAG(face_flags, FT_FACE_FLAG_SCALABLE, out_str);
    CHECK_FACE_FLAG(face_flags, FT_FACE_FLAG_FIXED_SIZES, out_str);
    CHECK_FACE_FLAG(face_flags, FT_FACE_FLAG_FIXED_WIDTH, out_str);
    CHECK_FACE_FLAG(face_flags, FT_FACE_FLAG_SFNT, out_str);
    CHECK_FACE_FLAG(face_flags, FT_FACE_FLAG_HORIZONTAL, out_str);
    CHECK_FACE_FLAG(face_flags, FT_FACE_FLAG_VERTICAL, out_str);
    CHECK_FACE_FLAG(face_flags, FT_FACE_FLAG_KERNING, out_str);
    CHECK_FACE_FLAG(face_flags, FT_FACE_FLAG_MULTIPLE_MASTERS, out_str);
    CHECK_FACE_FLAG(face_flags, FT_FACE_FLAG_GLYPH_NAMES, out_str);
    CHECK_FACE_FLAG(face_flags, FT_FACE_FLAG_EXTERNAL_STREAM, out_str);
    CHECK_FACE_FLAG(face_flags, FT_FACE_FLAG_HINTER, out_str);
    CHECK_FACE_FLAG(face_flags, FT_FACE_FLAG_CID_KEYED, out_str);
    CHECK_FACE_FLAG(face_flags, FT_FACE_FLAG_TRICKY, out_str);
    CHECK_FACE_FLAG(face_flags, FT_FACE_FLAG_COLOR, out_str);

    if (out_str[0] == '\0') {
        strncpy(out_str, "NONE", max_len);
    }
}
#define FT_CHECK_RES(f)                                                             \
{                                                                                   \
        FT_Error res = (f);                                                             \
        if (res) {                                                                      \
            char tmp[1024];                                                             \
            ft_face_flags_to_string (face->face->face_flags, tmp, 1024);                \
            LOGE("FreeType error is 0x%x in %s at line %d, flags: %s\n", res, __FILE__, __LINE__, tmp);\
            free(font);                                                                 \
            return (VkvgFont)&_vkvg_status_null_pointer;                                \
    }                                                                               \
}
#else
#define STBTT_assert(x) ((void)0)
#define STB_TRUETYPE_IMPLEMENTATION
#include "stb_truetype.h"
#endif

static int defaultFontCharSize = 12 << 6;

static inline const char* get_face_family_name (FontFace face) {
#ifdef VKVG_USE_FREETYPE
    return face->face->family_name;
#else
    int length = 0;
    const char *name_ptr = stbtt_GetFontNameString(&face->stbInfo, &length, 1, 0, 0, 1);
    return name_ptr;
#endif
}
static inline uint32_t get_face_glyph_count (FontFace face) {
#ifdef VKVG_USE_FREETYPE
    return face->face->num_glyphs;
#else
    return face->stbInfo.numGlyphs;
#endif
}
void _fonts_cache_update_font_descriptor_set (VkvgDevice dev) {
    VkDescriptorImageInfo descSrcTex = vkh_image_get_descriptor(dev->fontCache->texture, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
    VkWriteDescriptorSet  writeDescriptorSet = {.sType           = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
                                                .dstSet          = dev->fontCache->dsFont,
                                                .dstBinding      = 0,
                                                .descriptorCount = 1,
                                                .descriptorType  = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
                                                .pImageInfo      = &descSrcTex};
    vkUpdateDescriptorSets(dev->vkDev, 1, &writeDescriptorSet, 0, NULL);
}
void _fonts_cache_create(VkvgDevice dev, const char* fontDirs) {
    font_cache_t* cache = (font_cache_t*)calloc(1, sizeof(font_cache_t));

    dev->fontCache = cache;

    if (dev->threadAware)
        mtx_init(&cache->mutex, mtx_plain);

#ifdef VKVG_USE_FONTCONFIG
    if (!FcInit()) {
        LOGE("Font config initialisation failed\n");
        dev->status = VKVG_STATUS_DEVICE_ERROR;
        free(cache);
        return;
    }
    if (fontDirs) {
        const char* minimal_blank_config =
            "<?xml version=\"1.0\"?>"
            "<!DOCTYPE fontconfig SYSTEM \"fonts.dtd\">"
            "<fontconfig>"
            "  <cachedir>/tmp/vkvg-fc-cache</cachedir>"
            "</fontconfig>";
        cache->config = FcConfigCreate();
        if (!cache->config) {
            LOGE("Failed to create custom Fontconfig configuration.\n");
            dev->status = VKVG_STATUS_DEVICE_ERROR;
            free(cache);
            return;
        }
        if (!FcConfigParseAndLoadFromMemory(cache->config, (const FcChar8*)minimal_blank_config, FcTrue)) {
            LOGE ("Error: Failed to scan fonts in directory.\n");
            FcConfigDestroy(cache->config);
            dev->status = VKVG_STATUS_DEVICE_ERROR;
            free(cache);
            return;
        }

        const char *start = fontDirs;
        const char *end;
        char fontDir[1024];

        while (start && *start != '\0') {
            end = strchr(start, ',');
            size_t len = end ? (size_t)(end - start) : strlen(start);
            strncpy(fontDir, start, len);
            fontDir[len] = '\0';

            if (!FcConfigAppFontAddDir(cache->config, (FcChar8*)fontDir))
                LOG(VKVG_LOG_DEBUG, "Failed to add '%s' to Fontconfig configuration.\n", fontDir);

            start = end ? end + 1 : NULL;
        }
        if (!FcConfigBuildFonts(cache->config)) {
            LOGE ("Error: Failed to scan fonts in directory.\n");
            FcConfigDestroy(cache->config);
            dev->status = VKVG_STATUS_DEVICE_ERROR;
            free(cache);
            return;
        }

        FcConfigSetCurrent(cache->config);
    } else {
        cache->config = FcConfigGetCurrent();
        if (!cache->config) {
            LOGE(
                "Font config initialisation failed, consider using 'FONTCONFIG_PATH' and 'FONTCONFIG_FILE' environmane\
                           variables to point to 'fonts.conf' needed for FontConfig startup");
            dev->status = VKVG_STATUS_DEVICE_ERROR;
            free(cache);
            return;
        }
        cache->fcReqElts = FcObjectSetBuild(FC_FAMILY, FC_STYLE, FC_FILE, FC_INDEX, (char *)0);
    }
#endif

#ifdef VKVG_USE_FREETYPE
    FT_CHECK_RESULT(FT_Init_FreeType(&cache->library));
#endif

#if defined(VKVG_LCD_FONT_FILTER) && defined(FT_CONFIG_OPTION_SUBPIXEL_RENDERING)
    FT_CHECK_RESULT(FT_Library_SetLcdFilter(cache->library, FT_LCD_FILTER_LIGHT));
    cache->texFormat    = FB_COLOR_FORMAT;
    cache->texPixelSize = 4;
#else
    cache->texFormat    = VK_FORMAT_R8_UNORM;
    cache->texPixelSize = 1;
#endif

    cache->texPages = array_create_tex_page_t(FONT_CACHE_INIT_LAYERS);
    for (int i = 0; i < FONT_CACHE_INIT_LAYERS; ++i) {
        array_add_tex_page_t(&cache->texPages, (tex_page_t){array_create_TexRef(10), 0.f});
    }
    cache->texture   = vkh_tex2d_array_create(
        dev->vkhDev, cache->texFormat, FONT_PAGE_SIZE, FONT_PAGE_SIZE, FONT_CACHE_INIT_LAYERS, VKH_MEMORY_USAGE_GPU_ONLY,
        VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);

    vkh_image_create_view (cache->texture, VK_IMAGE_VIEW_TYPE_2D_ARRAY, VK_IMAGE_ASPECT_COLOR_BIT);

    cache->uploadFence = vkh_fence_create(dev->vkhDev);

    const VkDescriptorPoolSize descriptorPoolSize = {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1};
    VkDescriptorPoolCreateInfo descriptorPoolCreateInfo = {.sType   = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
                                                           .maxSets = 2,
                                                           .flags   = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
                                                           .poolSizeCount = 1,
                                                           .pPoolSizes    = &descriptorPoolSize};
    VK_CHECK_RESULT(vkCreateDescriptorPool(dev->vkDev, &descriptorPoolCreateInfo, NULL, &cache->descriptorPool));

    VkDescriptorSetAllocateInfo descriptorSetAllocateInfo = {.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
                                                             .descriptorPool     = cache->descriptorPool,
                                                             .descriptorSetCount = 1,
                                                             .pSetLayouts        = &dev->dslFont};
    VK_CHECK_RESULT(vkAllocateDescriptorSets(dev->vkDev, &descriptorSetAllocateInfo, &cache->dsFont));

    _fonts_cache_update_font_descriptor_set(dev);

    const uint32_t buffLength = FONT_PAGE_SIZE * FONT_PAGE_SIZE * cache->texPixelSize;

    vkh_buffer_init(dev->vkhDev, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VKH_MEMORY_USAGE_CPU_TO_GPU, buffLength, &cache->buff,
                    true);

    cache->cmd = vkh_cmd_buff_create(dev->vkhDev, dev->cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);

    // Set texture cache initial layout to shaderReadOnly to prevent error msg if cache is not fill
    const VkImageSubresourceRange subres = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, FONT_CACHE_INIT_LAYERS};
    vkh_cmd_begin(cache->cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
    vkh_image_set_layout_subres(cache->cmd, cache->texture, subres, VK_IMAGE_LAYOUT_UNDEFINED,
                                VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
                                VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
    VK_CHECK_RESULT(vkEndCommandBuffer(cache->cmd));
    _device_submit_cmd(dev, &cache->cmd, cache->uploadFence);

    cache->hostBuff = (uint8_t*)malloc(buffLength);

    cache->fontBuffers = array_create_FontBuffer(4);

#if defined(DEBUG) && defined(VKVG_DBG_UTILS)
    vkh_device_set_object_name(dev->vkhDev, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t)cache->descriptorPool,
                               "Font cache Descriptor Pool");
    vkh_device_set_object_name(dev->vkhDev, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t)cache->dsFont, "Cache DescSet FONT");
#endif
}
void _font_buffer_destroy (font_cache_t* cache, FontBuffer fontBuffer) {
    LOG(VKVG_LOG_FONT, "FontBuffer destroy\n");
    free(fontBuffer->buffer);
    array_destroy_FontFace(&fontBuffer->faces);
    array_del_FontBuffer(&cache->fontBuffers, fontBuffer);
    free(fontBuffer);
}
void _font_face_destroy (VkvgFont font) {
    FontFace face = font->face;
    LOG(VKVG_LOG_FONT, "FontFace destroy: %s\n", get_face_family_name(face));
    array_destroy_VkvgFont(&face->sizes);
    array_destroy_uint64_t(&face->queryHashes);
    array_del_FontFace(&face->fontBuffer->faces, face);

#ifdef VKVG_USE_HARFBUZZ
    hb_font_destroy(face->hb_font);
#endif

#ifdef VKVG_USE_FREETYPE
    mtx_destroy(&face->mutex);
    FT_Done_Face(face->face);
#endif

    if (face->fontBuffer->faces.count == 0) {
        _font_buffer_destroy(font->dev->fontCache, face->fontBuffer);
    }
    free(face);
}
void _font_cache_destroy(VkvgDevice dev) {
    font_cache_t* cache = (font_cache_t*)dev->fontCache;

    free(cache->hostBuff);

    FontBuffer* buffs = cache->fontBuffers.elements;
    for (int i = 0; i < cache->fontBuffers.count; ++i) {
        FontFace* faces = buffs[i]->faces.elements;
        for (int j = 0; j < buffs[i]->faces.count; ++j) {
            VkvgFont *fonts = faces[j]->sizes.elements;
            for (int k = 0; k < faces[j]->sizes.count; ++k) {
                //while (vkvg_font_get_reference_count(fonts[k]) > 0)
                    vkvg_font_destroy(fonts[k]);
            }
        }
    }
    array_destroy_FontBuffer(&cache->fontBuffers);

    vkDestroyDescriptorPool(dev->vkDev, cache->descriptorPool, NULL);

    LOG(VKVG_LOG_FONT, "Font pages in cache: %d\n", cache->texPages.count);
    for (int i = 0; i < cache->texPages.count; ++i) {
        tex_page_t *p = &cache->texPages.elements[i];
        int freeLines = 0;
        for (int j = 0; j < p->lines.count; ++j) {
#if DEBUG
            if (p->lines.elements[j]->released)
                freeLines++;
#endif
            free(p->lines.elements[j]);
        }
        LOG(VKVG_LOG_FONT, "\t%d: lines: %d \tpenY: %f released lines: %d\n", i, p->lines.count, p->penY, freeLines);
        array_destroy_TexRef(&p->lines);
    }
    array_destroy_tex_page_t(&cache->texPages);

    vkh_buffer_reset(&cache->buff);
    vkh_image_destroy(cache->texture);
    // vkFreeCommandBuffers(dev->vkDev,dev->cmdPool, 1, &cache->cmd);
    vkDestroyFence(dev->vkDev, cache->uploadFence, NULL);
#ifdef VKVG_USE_FREETYPE
    FT_Done_FreeType(cache->library);
#endif
#ifdef VKVG_USE_FONTCONFIG
    FcObjectSetDestroy(cache->fcReqElts);
    FcConfigDestroy(cache->config);
    FcFini();
#endif

    if (dev->threadAware)
        mtx_destroy(&cache->mutex);

    free(dev->fontCache);
}
/// increase layer count of 2d texture array used as font cache.
void _increase_font_tex_array(VkvgDevice dev) {
    LOG(VKVG_LOG_FONT, "_increase_font_tex_array\n");

    font_cache_t* cache = dev->fontCache;

    vkWaitForFences(dev->vkDev, 1, &cache->uploadFence, VK_TRUE, UINT64_MAX);
    ResetFences(dev->vkDev, 1, &cache->uploadFence);

    vkResetCommandBuffer(cache->cmd, 0);

    uint8_t oldSize = cache->texPages.count;
    for (int i = 0; i < FONT_CACHE_INIT_LAYERS; ++i) {
        tex_page_t tp = (tex_page_t){array_create_TexRef(10), 0.f};
        if (array_add_tex_page_t(&cache->texPages, tp) < 0)
            array_destroy_TexRef(&tp.lines);
    }
    uint8_t newSize = cache->texPages.count;

    VkhImage newImg  = vkh_tex2d_array_create(
        dev->vkhDev, cache->texFormat, FONT_PAGE_SIZE, FONT_PAGE_SIZE, newSize, VKH_MEMORY_USAGE_GPU_ONLY,
        VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
    vkh_image_create_view(newImg, VK_IMAGE_VIEW_TYPE_2D_ARRAY, VK_IMAGE_ASPECT_COLOR_BIT);

    VkImageSubresourceRange subresNew = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, newSize};
    VkImageSubresourceRange subres    = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, oldSize};

    vkh_cmd_begin(cache->cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);

    vkh_image_set_layout_subres(cache->cmd, newImg, subresNew, VK_IMAGE_LAYOUT_UNDEFINED,
                                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                VK_PIPELINE_STAGE_TRANSFER_BIT);
    vkh_image_set_layout_subres(cache->cmd, cache->texture, subres, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
                                VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                VK_PIPELINE_STAGE_TRANSFER_BIT);

    VkImageCopy cregion = {.srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, oldSize},
                           .dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, oldSize},
                           .extent         = {FONT_PAGE_SIZE, FONT_PAGE_SIZE, 1}};

    vkCmdCopyImage(cache->cmd, vkh_image_get_vkimage(cache->texture), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                   vkh_image_get_vkimage(newImg), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &cregion);

    vkh_image_set_layout_subres(cache->cmd, newImg, subresNew, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                                VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_PIPELINE_STAGE_TRANSFER_BIT,
                                VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
    vkh_image_set_layout_subres(cache->cmd, cache->texture, subres, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                                VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_PIPELINE_STAGE_TRANSFER_BIT,
                                VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);

    VK_CHECK_RESULT(vkEndCommandBuffer(cache->cmd));

    _device_submit_cmd(dev, &cache->cmd, cache->uploadFence);
    vkWaitForFences(dev->vkDev, 1, &cache->uploadFence, VK_TRUE, UINT64_MAX);

    vkh_image_destroy(cache->texture);

    cache->texture   = newImg;

    _device_wait_idle(dev);

    _fonts_cache_update_font_descriptor_set(dev);
}
// flush font stagging buffer to cache texture array
// Trigger stagging buffer to be uploaded in font cache. Groupping upload improve performances.
void _flush_chars_to_tex(VkvgFont f) {
    font_cache_t* cache = f->dev->fontCache;
    if (cache->stagingX == 0) // no char in stagging buff to flush
        return;
    tex_ref_t l = *f->texLines.elements[f->texLines.count - 1];

    LOG(VKVG_LOG_FONT, "_flush_chars_to_tex pen(%d, %d)\n", f->penX, l.penY);
    vkWaitForFences(f->dev->vkDev, 1, &cache->uploadFence, VK_TRUE, UINT64_MAX);
    ResetFences(f->dev->vkDev, 1, &cache->uploadFence);

    vkResetCommandBuffer(cache->cmd, 0);

    memcpy(vkh_buffer_get_mapped_pointer(&cache->buff), cache->hostBuff,
           (uint64_t)l.height * FONT_PAGE_SIZE * cache->texPixelSize);

    vkh_cmd_begin(cache->cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);

    VkImageSubresourceRange subres = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, l.pageIdx, 1};
    vkh_image_set_layout_subres(cache->cmd, cache->texture, subres, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
                                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                VK_PIPELINE_STAGE_TRANSFER_BIT);

    VkBufferImageCopy bufferCopyRegion = {.imageSubresource  = {VK_IMAGE_ASPECT_COLOR_BIT, 0, l.pageIdx, 1},
                                          .bufferRowLength   = FONT_PAGE_SIZE,
                                          .bufferImageHeight = l.height,
                                          .imageOffset       = {f->penX, l.penY, 0},
                                          .imageExtent = {cache->stagingX, l.height, 1}};

    vkCmdCopyBufferToImage(cache->cmd, cache->buff.buffer, vkh_image_get_vkimage(cache->texture),
                           VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &bufferCopyRegion);

    vkh_image_set_layout_subres(cache->cmd, cache->texture, subres, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                                VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_PIPELINE_STAGE_TRANSFER_BIT,
                                VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);

    VK_CHECK_RESULT(vkEndCommandBuffer(cache->cmd));

    _device_submit_cmd(f->dev, &cache->cmd, cache->uploadFence);

    f->penX += cache->stagingX;
    cache->stagingX = 0;
    memset(cache->hostBuff, 0, (uint64_t)FONT_PAGE_SIZE * FONT_PAGE_SIZE * cache->texPixelSize);
}

/// Start a new line in font cache, increase texture layer count if needed.
void _init_next_line_in_tex_cache(VkvgFont f) {
    font_cache_t* cache = f->dev->fontCache;

    for (int i = 0; i < cache->texPages.count; ++i) {
        tex_page_t* page = &cache->texPages.elements[i];
        //search free lines
        for (int j = 0; j < page->lines.count; ++j) {
            if (page->lines.elements[j]->released &&
                page->lines.elements[j]->height == f->height) {
                // reuse freed line
                TexRef lp = page->lines.elements[j];
                lp->released = false;
                array_add_TexRef(&f->texLines, lp);
                f->penX    = 0;
                LOG(VKVG_LOG_FONT, "Reusing page %d line %d for %s\n", i, j, get_face_family_name(f->face));
                return;
            }
        }
        if (page->penY + f->height >= FONT_PAGE_SIZE)
            continue;

        TexRef l = (TexRef)calloc(1, sizeof(tex_ref_t));
        l->height = f->height;
        l->pageIdx = (unsigned char)i;
        l->penY    = page->penY;
        array_add_TexRef(&f->texLines, l);
        array_add_TexRef(&page->lines, l);
        f->penX    = 0;
        page->penY += f->height;
        LOG(VKVG_LOG_FONT, "Create new line %d on page %d for %s\n", page->lines.count -1, i, get_face_family_name(f->face));
        return;
    }
    _flush_chars_to_tex(f);
    _increase_font_tex_array(f->dev);
    _init_next_line_in_tex_cache(f);
}
/*void _font_cache_update_context_descset(VkvgContext ctx) {
    if (ctx->fontCacheImg)
        vkh_image_destroy(ctx->fontCacheImg);

    LOCK_FONTCACHE(ctx->dev)

    ctx->fontCacheImg = ctx->dev->fontCache->texture;
    vkh_image_reference(ctx->fontCacheImg);

    _update_descriptor_set(ctx, ctx->fontCacheImg, ctx->dsFont);

    UNLOCK_FONTCACHE(ctx->dev)
}*/
// create a new char entry and put glyph in stagging buffer, ready for upload.
glyph_ref _put_glyph_in_cache(VkvgDevice dev, VkvgFont font, uint32_t gindex) {
#ifdef VKVG_USE_FREETYPE
    #if defined(VKVG_LCD_FONT_FILTER) && defined(FT_CONFIG_OPTION_SUBPIXEL_RENDERING)
    FT_CHECK_RESULT(FT_Load_Glyph(f->face, gindex, FT_LOAD_TARGET_NORMAL));
    FT_CHECK_RESULT(FT_Render_Glyph(f->face->glyph, FT_RENDER_MODE_LCD));
    #else
    FT_Error res = FT_Load_Glyph(font->face->face, gindex, FT_LOAD_RENDER);
    if (res) {
        LOGW("FT_Load_Glyph error 0x%x for glyph index %d\n", res, gindex);
        if (font->charLookup[0].texRef) // return default glyph ref 0
            return font->charLookup[0];
        // try upload default glyph 0 in cache
        res = FT_Load_Glyph(font->face->face, 0, FT_LOAD_RENDER);
        if (res) {
            LOGE("Fatal: FT_Load_Glyph error 0x%x for default glyph 0\n", res);
            font->status = VKVG_STATUS_INVALID_FONT;
            return (glyph_ref) {0};
        }
    }
    #endif

    FT_GlyphSlot   slot          = font->face->face->glyph;
    FT_Bitmap      bmp           = slot->bitmap;
    uint32_t       bmpByteWidth  = bmp.width;
    uint32_t       bmpPixelWidth = bmp.width;
    uint32_t       bmpRows       = bmp.rows;
    unsigned char* buffer        = bmp.buffer;

    #if defined(VKVG_LCD_FONT_FILTER) && defined(FT_CONFIG_OPTION_SUBPIXEL_RENDERING)
    bmpPixelWidth /= 3;
    #endif
#else
    stbtt_fontinfo* pStbInfo = &font->face->stbInfo;
    int             c_x1, c_y1, c_x2, c_y2;
    stbtt_GetGlyphBitmapBox(pStbInfo, gindex, font->scale, font->scale, &c_x1, &c_y1, &c_x2, &c_y2);
    uint32_t bmpByteWidth  = c_x2 - c_x1;
    uint32_t bmpPixelWidth = bmpByteWidth;
    uint32_t bmpRows       = c_y2 - c_y1;
#endif
    uint8_t* data = dev->fontCache->hostBuff;
    if (dev->fontCache->stagingX + font->penX + bmpPixelWidth > FONT_PAGE_SIZE) {
        _flush_chars_to_tex(font);
        _init_next_line_in_tex_cache(font);
    }

    glyph_ref cr   = {font->texLines.elements[font->texLines.count - 1]};
    int       penX = dev->fontCache->stagingX;

#ifdef VKVG_USE_FREETYPE
    for (uint32_t y = 0; y < bmpRows; y++) {
        for (uint32_t x = 0; x < bmpPixelWidth; x++) {
#if defined(VKVG_LCD_FONT_FILTER) && defined(FT_CONFIG_OPTION_SUBPIXEL_RENDERING)
            unsigned char r = buffer[y * bmp.pitch + x * 3];
            unsigned char g = buffer[y * bmp.pitch + x * 3 + 1];
            unsigned char b = buffer[y * bmp.pitch + x * 3 + 2];

            data[(penX + x + y * FONT_PAGE_SIZE) * 4]     = b;
            data[(penX + x + y * FONT_PAGE_SIZE) * 4 + 1] = g;
            data[(penX + x + y * FONT_PAGE_SIZE) * 4 + 2] = r;
            data[(penX + x + y * FONT_PAGE_SIZE) * 4 + 3] = (r + g + b) / 3;
#else
            data[penX + x + y * FONT_PAGE_SIZE] = buffer[x + y * bmpPixelWidth];
#endif
        }
    }
    cr.bmpDiff.x = (int16_t)slot->bitmap_left;
    cr.bmpDiff.y = (int16_t)slot->bitmap_top;
    cr.advance   = slot->advance;
#else
    int advance;
    int lsb;
    stbtt_GetGlyphHMetrics(pStbInfo, gindex, &advance, &lsb);
    stbtt_MakeGlyphBitmap(pStbInfo, data + penX, bmpPixelWidth, bmpRows, FONT_PAGE_SIZE, font->scale, font->scale, gindex);
    cr.bmpDiff.x = (int16_t)c_x1;
    cr.bmpDiff.y = (int16_t)-c_y1;
    cr.advance   = (vec2){(uint32_t)roundf(font->scale * advance) << 6, 0};
#endif
    vec4 uvBounds = {{(float)(penX + font->penX)},
                     {0.f},
                     {(float)bmpPixelWidth},
                     {(float)bmpRows}};
    cr.bounds    = uvBounds;
    dev->fontCache->stagingX += bmpPixelWidth;
    return cr;
}
vkvg_inline glyph_ref get_cached_glyph (VkvgDevice dev, VkvgFont font, uint32_t gIndex) {
    glyph_ref gr;
    if (vkvg_unlikely (gIndex > get_face_glyph_count(font->face))) {
        LOGW("glyph index out of bounds: idx:%d glyphsCount: %d\n", gIndex, get_face_glyph_count(font->face));
        if (!font->charLookup[0].texRef) // load default glyph 0
            font->charLookup[0] = _put_glyph_in_cache(dev, font, 0);
        return font->charLookup[0]; // set default glyph for index
    }
    if (!font->charLookup[gIndex].texRef)
        font->charLookup[gIndex] = _put_glyph_in_cache(dev, font, gIndex);
    return font->charLookup[gIndex];
}

bool try_get_font_face_from_query_hash(font_cache_t* cache, uint64_t queryHash, FontFace *const face) {
    *face = NULL;
    FontBuffer* buffs = cache->fontBuffers.elements;
    for (int i = 0; i < cache->fontBuffers.count; ++i) {
        FontFace* faces = buffs[i]->faces.elements;
        for (int j = 0; j < buffs[i]->faces.count; ++j) {
            uint64_t* queries = faces[j]->queryHashes.elements;
            for (int k = 0; k < faces[j]->queryHashes.count; ++k) {
                if (queries[k] == queryHash) {
                    *face = faces[j];
                    return true;
                }
            }
        }
    }
    return false;
}
bool try_get_font_buffer_from_path_hash(font_cache_t* cache, uint64_t pathHash, FontBuffer *const fontBuff) {
    *fontBuff = NULL;
    for (int i = 0; i < cache->fontBuffers.count; ++i) {
        if (cache->fontBuffers.elements[i]->fontPathHash == pathHash) {
            *fontBuff = cache->fontBuffers.elements[i];
            return true;
        }

    }
    return false;
}
bool try_create_font_face_from_path (VkvgDevice dev, const char *fontFile, int faceIndex, FontFace *const face) {
    font_cache_t* cache = dev->fontCache;
    uint64_t fontFileHash = fnv1a_64_str(fontFile);
    FontBuffer buffPtr = NULL;

    if (try_get_font_buffer_from_path_hash(cache, fontFileHash, &buffPtr)) {
        for (int f = 0; f < buffPtr->faces.count; ++f) {
            if (buffPtr->faces.elements[f]->faceIndex == faceIndex) {
                *face = buffPtr->faces.elements[f];
                return true;
            }
        }
        LOG(VKVG_LOG_FONT, "Font buffer without a face\n");
    } else {
        FILE *file = fopen(fontFile, "rb");
        if (!file) {
            LOGE("Error opening font file: %s\n", fontFile);
            return false;
        }
        buffPtr = (FontBuffer)calloc(1, sizeof(vkvg_font_buffer_t));
        buffPtr->fontPathHash = fontFileHash;

        fseek(file, 0, SEEK_END);
        buffPtr->bufferSize = ftell(file);
        fseek(file, 0, SEEK_SET);
        buffPtr->buffer = malloc(buffPtr->bufferSize);

        if (!buffPtr->buffer) {
            LOGE("Error opening font file: %s\n", fontFile);
            fclose(file);
            free(buffPtr);
            return false;
        }
        unsigned long readBytes = fread(buffPtr->buffer, 1, buffPtr->bufferSize, file);
        fclose(file);
        if (readBytes != buffPtr->bufferSize) {
            LOGE("Error reading font file: %s\n", fontFile);
            free(buffPtr->buffer);
            free(buffPtr);
            return false;
        }

        buffPtr->faces = array_create_FontFace(2);
        array_add_FontBuffer(&cache->fontBuffers, buffPtr);
    }

    FontFace newFace = (FontFace)calloc(1, sizeof(vkvg_font_face_t));
    newFace->fontBuffer = buffPtr;
    newFace->queryHashes = array_create_uint64_t(2);
    newFace->faceIndex = faceIndex;

#ifdef VKVG_USE_FREETYPE
    if (dev->threadAware)
        mtx_init(&newFace->mutex, mtx_plain);
    FT_Error res = FT_New_Memory_Face(cache->library, buffPtr->buffer, buffPtr->bufferSize, faceIndex, &newFace->face);
    if (res) {
        LOGE("FreeType error 0x%x creating memory face in %s at line %d\n", res, __FILE__, __LINE__);
        return false;
    }
#ifdef VKVG_USE_HARFBUZZ
    newFace->hb_font = hb_ft_font_create(newFace->face, NULL);
#endif
#else
    int font_count = stbtt_GetNumberOfFonts(buffPtr->buffer);
    int offset = stbtt_GetFontOffsetForIndex(buffPtr->buffer, faceIndex & 0xFFFF);//variable font not handled by stbtt
    int result = stbtt_InitFont(&newFace->stbInfo, buffPtr->buffer, offset < 0 ? 0 : offset);
    if (!result) {
        LOGE("stbtt_InitFont error 0x%x creating face in %s at line %d\n", result, __FILE__, __LINE__);
        return false;
    }
#endif
    array_add_FontFace(&buffPtr->faces, newFace);
    *face = newFace;
    return true;
}

bool try_get_or_create_font_face_from_query (VkvgDevice dev, const char* queryString, FontFace *const face,
                                            signed long** pCoords) {
    font_cache_t* cache = dev->fontCache;
    uint64_t queryHash = fnv1a_64_str(queryString);
    *face = NULL;

#ifdef VKVG_USE_FONTCONFIG
    if (try_get_font_face_from_query_hash(cache, queryHash, face)
#ifdef VKVG_USE_FREETYPE
        && (*face)->numAxis > 0
#endif
        )
        return true;

    FcPattern* request = FcNameParse((const FcChar8*)queryString);

    //FcPatternAddBool(request, FC_SCALABLE, FcTrue);
    //FcPatternAddString(request, FC_FONTFORMAT, (const FcChar8 *)"TrueType");
    FcConfigSubstitute(cache->config, request, FcMatchPattern);
    FcDefaultSubstitute(request);

    FcResult   result;
    FcPattern* font = FcFontMatch(cache->config, request, &result);

    if (font) {
        char *fontFile = NULL;
        int index = 0;
        FcPatternGetString (font, FC_FILE, 0, (FcChar8**)&fontFile);
        FcPatternGetInteger (font, FC_INDEX, 0, &index);

        if (!*face && !try_create_font_face_from_path(dev, fontFile, index, face))
            goto exit_failed;

        array_add_uint64_t (&(*face)->queryHashes, queryHash);

#if VKVG_USE_FREETYPE
        FT_Face ftface = (*face)->face;
        FT_MM_Var* mm_var = NULL;
        if (!FT_Get_MM_Var(ftface, &mm_var)) {
            int num_axes_retrieved = 0;
            FcChar8* var_string = NULL;
            if (FcPatternGetString(font, FC_FONT_VARIATIONS, 0, &var_string) == FcResultMatch) {
                FT_Fixed* coords = (FT_Fixed*)malloc(sizeof(FT_Fixed) * mm_var->num_axis);
                for (FT_UInt i = 0; i < mm_var->num_axis; i++) {
                    coords[i] = mm_var->axis[i].def;
                }
                char* token = strtok((char*)var_string, ",");
                while (token != NULL) {
                    char axis_name[5] = {0};
                    float axis_val = 0.0f;

                    // Parse out the 4-character tag and its companion numerical scalar value
                    if (sscanf(token, "%4[^=]=%f", axis_name, &axis_val) == 2) {
                        // Convert tag string directly to a 32-bit OpenType Tag integer
                        FT_Long target_tag = FT_MAKE_TAG(axis_name[0], axis_name[1], axis_name[2], axis_name[3]);

                               // Match our parsed tag against the axes array exposed by FreeType
                        for (FT_UInt i = 0; i < mm_var->num_axis; i++) {
                            if (mm_var->axis[i].tag == target_tag) {
                                // FreeType handles design positions in 16.16 Fixed Point formats
                                coords[i] = (FT_Fixed)(axis_val * 65536.0f);
                                break;
                            }
                        }
                    }
                    token = strtok(NULL, ",");
                }
                *pCoords = coords;
                (*face)->numAxis = mm_var->num_axis;
            }
            FT_Done_MM_Var(cache->library, mm_var);
        }

#endif

        FcPatternDestroy(request);
        FcPatternDestroy(font);
        return true;
    }
exit_failed:
    FcPatternDestroy(request);
    FcPatternDestroy(font);
#else
    if (try_get_font_face_from_query_hash(cache, queryHash, face))
        return true;
#endif
    return false;
}
bool try_get_font_size (FontFace face, uint32_t pt26_6, signed long* coords, VkvgFont *font) {
    *font = NULL;
    for (int i = 0; i < face->sizes.count; ++i) {
        VkvgFont f = face->sizes.elements[i];
        if (f->charSize == pt26_6) {
#ifdef VKVG_USE_FREETYPE
            if (coords) {
                for (int axe = 0; axe < face->numAxis; ++axe) {
                    if (f->coords[axe] != coords[axe])
                        return false;
                }
                free(coords);//coords matche, free new coords
            }
#endif
            *font = f;
            return true;
        }
    }
    return false;
}

#ifdef VKVG_USE_HARFBUZZ
// Get harfBuzz buffer for provided text.
hb_buffer_t* _get_hb_buffer(VkvgText textRun, const char* text, int length) {
    VkvgFont font = textRun->font;
    hb_buffer_t* buf = hb_buffer_create();
    hb_buffer_add_utf8 (buf, text, length, 0, length);
    hb_buffer_guess_segment_properties (buf);

    if (textRun->textDirection == VKVG_VERTICAL)
        hb_buffer_set_direction(buf, HB_DIRECTION_TTB);

    hb_shape(font->face->hb_font, buf, NULL, 0);

    if (hb_buffer_get_content_type(buf) != HB_BUFFER_CONTENT_TYPE_GLYPHS) {
        LOGW("HarfBuzz shaping failed: Buffer was not converted to glyphs.\n");
    }
    return buf;
}
#endif
void _font_lock_size (VkvgFont font) {
#ifdef VKVG_USE_FREETYPE
    FT_Face face = font->face->face;
    if (face->size != font->ftSize || font->face->coords != font->coords) {
        if (font->dev->threadAware)
            mtx_lock(&font->face->mutex);
        if (font->coords && font->face->coords != font->coords) {
            FT_Set_Var_Design_Coordinates(face, font->face->numAxis, font->coords);
            font->face->coords = font->coords;
        }
        FT_CHECK_RESULT(FT_Activate_Size(font->ftSize));
#ifdef VKVG_USE_HARFBUZZ
        hb_font_t* hbf = font->face->hb_font;
        hb_ft_font_changed(hbf);
        hb_font_set_ppem(hbf, font->ftSize->metrics.x_ppem, font->ftSize->metrics.y_ppem);
#endif
    }
#endif
}

// retrieve global font extends of context's current font as defined by FreeType
void _font_cache_font_extents(VkvgFont font, vkvg_font_extents_t* extents) {
#ifdef VKVG_USE_FREETYPE
    FT_Face face = font->face->face;
    /*_font_lock_size(ctx, font);
    if (face->size != font->ftSize) {
        mtx_lock(&font->face->mutex);
        FT_CHECK_RESULT(FT_Activate_Size(font->ftSize));
    }*/
    //FT_BBox*         bbox    = &face->bbox;
    //FT_Size_Metrics* metrics = &face->size->metrics;
    FT_Size_Metrics* metrics = &font->ftSize->metrics;

    extents->ascent  = (float)(FT_MulFix(face->ascender, metrics->y_scale) >> 6);   // metrics->ascender >> 6;
    extents->descent = -(float)(FT_MulFix(face->descender, metrics->y_scale) >> 6); // metrics->descender >> 6;
    extents->height  = (float)(FT_MulFix(face->height, metrics->y_scale) >> 6);     // metrics->height >> 6;
    /*extents->max_x_advance = (float)(bbox->xMax >> 6);
    extents->max_y_advance = (float)(bbox->yMax >> 6);*/
    extents->max_x_advance = (float)(FT_MulFix(face->max_advance_width, metrics->x_scale) >> 6);
    extents->max_y_advance = (float)(FT_MulFix(face->max_advance_height, metrics->y_scale) >> 6);

    /*if (ctx->dev->threadAware)
        mtx_unlock(&font->face->mutex);*/
#else
    extents->ascent  = font->ascent;
    extents->descent = font->descent;
    extents->height = font->ascent - font->descent + font->lineGap;
    extents->max_x_advance = 0; // TODO
    extents->max_y_advance = 0;
#endif
}
// compute text extends for provided string.
void _font_cache_text_extents(VkvgContext ctx, const char* text, int length, vkvg_text_extents_t* extents) {
    if (text == NULL) {
        memset(extents, 0, sizeof(vkvg_text_extents_t));
        return;
    }

    vkvg_text_run_t tr = {0};
    text_run_init(&tr, ctx->currentFont, ctx->textDirection, text, length);

    if (ctx->status)
        return;

    *extents = tr.extents;

    text_run_term(&tr);
}
// text is expected as utf8 encoded
void _font_cache_show_text(VkvgContext ctx, const char* text) {
    vkvg_text_run_t tr = {0};
    text_run_init(&tr, ctx->currentFont, ctx->textDirection, text, -1);

    if (ctx->status)
        return;

    text_run_render(&tr, ctx);
    text_run_term(&tr);
    //_show_texture(ctx); return;
}

// if length is < 0, text must be null terminated, else it contains glyph count
void text_run_init(VkvgText textRun, VkvgFont font, vkvg_direction_t textDirection, const char* text, int length) {
    textRun->font   = font;
    textRun->textDirection = textDirection;
    vkvg_font_reference (textRun->font);

    _font_lock_size(textRun->font);

#if defined(VKVG_USE_HARFBUZZ)
    textRun->hbBuf  = _get_hb_buffer(textRun, text, length);
    textRun->glyphs = hb_buffer_get_glyph_positions(textRun->hbBuf, &textRun->glyph_count);
#else

    size_t wsize;
    if (length < 0)
        wsize = mbstowcs(NULL, text, 0);
    else
        wsize = (size_t)length;
    wchar_t* tmp         = (wchar_t*)malloc((wsize + 1) * sizeof(wchar_t));
    textRun->glyph_count = mbstowcs(tmp, text, wsize);
    textRun->glyphs      = (vkvg_glyph_info_t*)malloc(textRun->glyph_count * sizeof(vkvg_glyph_info_t));
    for (unsigned int i = 0; i < textRun->glyph_count; i++) {
#ifdef VKVG_USE_FREETYPE
        uint32_t gIndex = FT_Get_Char_Index(textRun->font->face->face, tmp[i]);
#else
        uint32_t gIndex = stbtt_FindGlyphIndex(&textRun->font->face->stbInfo, tmp[i]);
#endif
        glyph_ref cr = get_cached_glyph(textRun->font->dev, textRun->font, gIndex);
        textRun->glyphs[i].codepoint = gIndex;
        textRun->glyphs[i].x_advance = cr.advance.x;
        textRun->glyphs[i].y_advance = cr.advance.y;
        textRun->glyphs[i].x_offset  = 0;
        textRun->glyphs[i].y_offset  = 0;
        /*textRun->glyphs[i].x_offset	 = cr->bmpDiff.x;
        textRun->glyphs[i].y_offset	 = cr->bmpDiff.y;*/
    }
    free(tmp);
#endif

#ifdef VKVG_USE_FREETYPE
    if (font->dev->threadAware)
        mtx_unlock(&textRun->font->face->mutex);
#endif

    float string_width_in_pixels = 0;
    for (uint32_t i = 0; i < textRun->glyph_count; ++i)
        string_width_in_pixels += (float)textRun->glyphs[i].x_advance / 64.f;
#ifdef VKVG_USE_FREETYPE
    FT_Size_Metrics* metrics = &textRun->font->ftSize->metrics;
    textRun->extents.height  = (float)(FT_MulFix(textRun->font->face->face->height, metrics->y_scale) >>
                                      6); // (metrics->ascender + metrics->descender) >> 6;
#else
    textRun->extents.height = textRun->font->ascent - textRun->font->descent + textRun->font->lineGap;
#endif
    textRun->extents.x_advance = string_width_in_pixels;
    if (textRun->glyph_count > 0) {
        textRun->extents.y_advance = (float)textRun->glyphs[textRun->glyph_count - 1].y_advance / 64.f;
        textRun->extents.x_bearing = -(float)textRun->glyphs[0].x_offset / 64.f;
        textRun->extents.y_bearing = -(float)textRun->glyphs[0].y_offset / 64.f;
    }

    textRun->extents.width = textRun->extents.x_advance;
}
void text_run_term(VkvgText textRun) {
#ifdef VKVG_USE_HARFBUZZ
    hb_buffer_destroy(textRun->hbBuf);
#else
    if (textRun->glyph_count > 0)
        free(textRun->glyphs);
#endif
    vkvg_font_destroy(textRun->font);
}

void text_run_render(VkvgText tr, VkvgContext ctx) {
    unsigned int glyph_count;
#ifdef VKVG_USE_HARFBUZZ
    hb_glyph_info_t* glyph_info = hb_buffer_get_glyph_infos(tr->hbBuf, &glyph_count);
#else
    vkvg_glyph_info_t* glyph_info = tr->glyphs;
    glyph_count                   = tr->glyph_count;
#endif
    VkvgFont f = tr->font;
    Vertex v   = {{0}, ctx->curColor, {0, 0, -1}};
    vec2   pen = {0, 0};

    if (!_current_path_is_empty(ctx))
        pen = _get_current_position(ctx);

    LOCK_FONTCACHE(ctx->dev)

    VkvgDevice dev = tr->font->dev;
    for (uint32_t i = 0; i < glyph_count; ++i) {
        glyph_ref cr = get_cached_glyph(dev, f, glyph_info[i].codepoint);

        if (vkvg_unlikely (f->status))
            break;

        vec2  p0       = {pen.x + cr.bmpDiff.x + (tr->glyphs[i].x_offset >> 6),
                          pen.y - cr.bmpDiff.y + (tr->glyphs[i].y_offset >> 6)};
        v.pos          = p0;

        VKVG_IBO_INDEX_TYPE firstIdx = (VKVG_IBO_INDEX_TYPE)(ctx->vertCount - ctx->curVertOffset);

        TexRef l = cr.texRef;
        float uvY = (float)l->penY;

        v.uv.x = cr.bounds.x;
        v.uv.y = uvY; // + cr.bounds.y
        v.uv.z = l->pageIdx;
        _add_vertex(ctx, v);

        v.pos.y += cr.bounds.height;
        v.uv.y += cr.bounds.height;
        _add_vertex(ctx, v);

        v.pos.x += cr.bounds.width;
        v.pos.y = p0.y;
        v.uv.x += cr.bounds.width;
        v.uv.y = uvY; // + cr.bounds.y;
        _add_vertex(ctx, v);

        v.pos.y += cr.bounds.height;
        v.uv.y += cr.bounds.height;
        _add_vertex(ctx, v);

        _add_tri_indices_for_rect(ctx, firstIdx);

        pen.x += (tr->glyphs[i].x_advance >> 6);
        pen.y -= (tr->glyphs[i].y_advance >> 6);
    }

    _finish_path(ctx);
    _add_point(ctx, pen.x, pen.y);
    _flush_chars_to_tex(tr->font);
    UNLOCK_FONTCACHE(ctx->dev)
    /*if (ctx->fontCacheImg != ctx->dev->fontCache->texture) {
        vkvg_flush(ctx);
        _font_cache_update_context_descset(ctx);
    }*/
}

#ifdef DEBUG
void _show_texture(vkvg_context* ctx) {
    Vertex vs[] = {{{0, 0}, 0, {0, 0, 0}},
                   {{0, FONT_PAGE_SIZE}, 0, {0, 1, 0}},
                   {{FONT_PAGE_SIZE, 0}, 0, {1, 0, 0}},
                   {{FONT_PAGE_SIZE, FONT_PAGE_SIZE}, 0, {1, 1, 0}}};

    VKVG_IBO_INDEX_TYPE firstIdx = (VKVG_IBO_INDEX_TYPE)(ctx->vertCount - ctx->curVertOffset);
    Vertex*             pVert    = &ctx->vertexCache[ctx->vertCount];
    memcpy(pVert, vs, 4 * sizeof(Vertex));
    ctx->vertCount += 4;

    _check_vertex_cache_size(ctx);

    _add_tri_indices_for_rect(ctx, firstIdx);
}
#endif

void* vkvg_font_get_face(VkvgFont font) {
#ifdef VKVG_USE_FREETYPE
    return font->face->face;
#else
    return &font->face->stbInfo;
#endif
}

VkvgFont _create_font_from_face (VkvgSurface surf, FontFace face, float pointSize, signed long* coords) {
    VkvgFont font = (VkvgFont)calloc(1, sizeof(vkvg_font_t));
    if (!font) {
        LOGE("Create font failed, no memory\n");
        return (VkvgFont)&_vkvg_status_no_memory;
    }

    font->face = face;
    VkvgDevice dev = surf->dev;

#ifdef VKVG_USE_FREETYPE
    if (dev->threadAware)
        mtx_lock(&font->face->mutex);
    if (face->numAxis && coords)
        font->coords = coords;
    font->charSize = (uint32_t)(pointSize * 64.f);;
    if (!(face->face->face_flags & FT_FACE_FLAG_SCALABLE) || !(face->face->face_flags & FT_FACE_FLAG_SFNT)) {
        char tmp[1024];
        ft_face_flags_to_string (face->face->face_flags, tmp, 1024);
        LOGW("Unsuported font flags: %s\n", tmp);
        if (dev->threadAware)
            mtx_lock(&font->face->mutex);
        free(font);
        return (VkvgFont)&_vkvg_status_null_pointer;
    } else {
        char tmp[1024];
        ft_face_flags_to_string (face->face->face_flags, tmp, 1024);
        LOG(VKVG_LOG_FONT, "loading %s\n\tflags: %s\n", face->face->family_name, tmp);
    }
    if (!face->sizes.size)
        face->sizes = array_create_VkvgFont(5);//new face,

    FT_CHECK_RES(FT_New_Size (face->face, &font->ftSize));
    FT_CHECK_RES(FT_Activate_Size(font->ftSize));
    //TODO:handle fixed sizes
    FT_CHECK_RES(FT_Set_Char_Size(face->face, 0, font->charSize, surf->hdpi, surf->vdpi));
    if (font->coords) {
        FT_Set_Var_Design_Coordinates(face->face, font->face->numAxis, font->coords);
        font->face->coords = font->coords;
    }
#ifdef VKVG_USE_HARFBUZZ
    hb_font_t* hbf = font->face->hb_font;
    hb_ft_font_changed(hbf);
    hb_font_set_ppem(hbf, font->ftSize->metrics.x_ppem, font->ftSize->metrics.y_ppem);
#endif

    font->charLookup = (glyph_ref*)calloc(face->face->num_glyphs, sizeof(glyph_ref));

    if (FT_IS_SCALABLE(face->face))
        font->height = face->face->size->metrics.height >> 6;
    else
        font->height = face->face->height >> 6;

    font->texLines = array_create_TexRef(2);

    if (dev->threadAware)
        mtx_lock(&font->face->mutex);
#else
    font->charSize       = pointSize;
    stbtt_GetFontVMetrics(&face->stbInfo, &font->ascent, &font->descent, &font->lineGap);
    font->charLookup     = (glyph_ref*)calloc(face->stbInfo.numGlyphs, sizeof(glyph_ref));
    font->scale          = stbtt_ScaleForMappingEmToPixels(&face->stbInfo, font->charSize * surf->vdpi / 72.f);
    font->height         = roundf(font->scale * (font->ascent - font->descent + font->lineGap));
    font->ascent         = roundf(font->scale * font->ascent);
    font->descent        = roundf(font->scale * font->descent);
    font->lineGap        = roundf(font->scale * font->lineGap);
#endif
    array_add_VkvgFont(&face->sizes, font);

    font->dev = dev;
    vkvg_device_reference(font->dev);

    _init_next_line_in_tex_cache(font);
    atomic_init(&font->references, 1);

    return font;
}

VkvgFont vkvg_font_create_from_file (VkvgSurface surf, const char* fontFilePath, int faceIndex, float pointSize) {
    FontFace face = NULL;
    if (!try_create_font_face_from_path(surf->dev, fontFilePath, faceIndex, &face) || !face) {
        return NULL;
    }
    return _create_font_from_face(surf, face, pointSize, NULL);
}
VkvgFont vkvg_font_create (VkvgSurface surf, const char* query, float pointSize) {
    uint32_t pt26_6 = (uint32_t)(pointSize * 64.f);
    VkvgFont font = NULL;
    FontFace face = NULL;
    signed long* coords = NULL;
    unsigned int numAxis = 0;
    if (try_get_or_create_font_face_from_query(surf->dev, query, &face, &coords)) {
        if (try_get_font_size(face, pt26_6, coords, &font)) {
            vkvg_font_reference(font);
            return font;
        }
    }
    if (!face)
        return NULL;

    return _create_font_from_face(surf, face, pointSize, coords);
}
VkvgFont vkvg_font_reference(VkvgFont font) {
    if (!vkvg_font_status(font))
        atomic_fetch_add_explicit(&font->references, 1, memory_order_relaxed);
    return font;
}
uint32_t vkvg_font_get_reference_count(VkvgFont font) {
    if (vkvg_font_status(font))
        return 0;
    return atomic_load_explicit(&font->references, memory_order_relaxed);
}
vkvg_status_t vkvg_font_status(VkvgFont font) { return !font ? VKVG_STATUS_NULL_POINTER : font->status; }
void vkvg_font_destroy(VkvgFont font) {
    if (vkvg_font_status(font))
        return;
    if (atomic_fetch_sub_explicit(&font->references, 1, memory_order_acq_rel) != 1)
        return;
    LOG(VKVG_LOG_FONT, "Font destroy: %s\n", get_face_family_name(font->face));
#ifdef VKVG_USE_FREETYPE
    FT_Done_Size(font->ftSize);
    if (font->coords)
        free(font->coords);
#endif

    for (int i = 0; i < font->texLines.count; ++i) {
        LOG(VKVG_LOG_FONT, "\treleased line %d of page %d\n", i, font->texLines.elements[i]->pageIdx);
        font->texLines.elements[i]->released = true;
    }
    array_destroy_TexRef(&font->texLines);

    array_del_VkvgFont(&font->face->sizes , font);

    if (font->face->sizes.count == 0)
        _font_face_destroy(font);
    free(font->charLookup);

    vkvg_device_destroy(font->dev);
    free(font);
    font = NULL;
}