dl_free_type.h

浏览该文件的文档.

#pragma once
 
#ifndef DL_DISABLE_RENDER
#include <vector>
#include <string>
#include <unordered_map>
#include <cassert>
 
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_STROKER_H
 
#include "io/dl_log.h"
#include "memory/dl_code_cvt.h"
#include "dl_font.h"
#include "base/dl_color.h"
#include "io/dl_file.h"
 
namespace dl
{ 
    constexpr size_t NUM_MAX_FONT = 16;
class FreeType
{
public:
    // 某字体某大小的属性
    struct Property
    {
        float _ascent; // 基线上方
        float _descent;// 基线下方
        float _linegap;// 行空白
        float GetLinespace() const
        {
            return _ascent - _descent + _linegap;
        }
    };
 
    // 表示水平的一段连续数据
    struct Span
    {
        int _x;
        int _y;
        int _w;
        int _coverage;// 为uint8_t透明度
 
        Span(){}
        Span(int x, int y, int w, int coverage): 
            _x(x), _y(y), _w(w), _coverage(coverage)
        {}
    };
    // 渲染器回调，写入Span
    static void RasterCallback(int y, int count, const FT_Span* spans, void* user)
    {
        std::vector<Span>* sptr = (std::vector<Span>*)user;
        for (int i = 0; i < count; ++i)
            sptr->push_back(Span(spans[i].x, y, spans[i].len, spans[i].coverage));
    }
    // 设置光栅参数，且渲染描边
    void RenderSpans(FT_Library& library, FT_Outline* outline, std::vector<Span>* spans)
    {
        FT_Raster_Params params;
        memset(&params, 0, sizeof(params));
        params.flags = FT_RASTER_FLAG_AA | FT_RASTER_FLAG_DIRECT;
        params.gray_spans = RasterCallback;
        params.user = spans;
 
        FT_Outline_Render(library, outline, &params);
    }
    struct CharRect
    {
        float _xMin;
        float _xMax;
        float _yMin;
        float _yMax;
 
        CharRect() {}
        CharRect(float left, float top, float right, float bottom): 
            _xMin(left), _xMax(right), _yMin(top), _yMax(bottom) 
        {}
 
        void Include(int x, int y)
        {
            _xMin = (std::min)(_xMin, float(x));
            _yMin = (std::min)(_yMin, float(y));
            _xMax = (std::max)(_xMax, float(x));
            _yMax = (std::max)(_yMax, float(y));
        }
 
        float Width() { return _xMax - _xMin + 1; }
        float Height() { return _yMax - _yMin + 1; }
    };
 
    FreeType()
    {
        if (FT_Init_FreeType(&_library))
        {
            log_err0("FreeType初始化失败！");
            _library = nullptr;
        }
        _vecBuffer.resize(NUM_MAX_FONT);
    }

    size_t LoadFace(std::string_view path_name)
    {
        if (_vecFace.size() >= NUM_MAX_FONT)
        {
            log_err0("字体数加载超过上限！你可以修改 NUM_MAX_FONT值来支持更多。");
            return -1;
        }
        Buffer& buf =_vecBuffer[_vecFace.size()];
        buf = File::GetBuffer(path_name);
        if (buf.empty())
            return -1;
        FT_Face face;
        if (FT_New_Memory_Face(_library, (FT_Byte*)buf.data(), (FT_Long)buf.size(), 
            0, &face))
        {
            log_err("字体文件加载失败: {}", path_name);
            return -1;
        }
        assert(FT_IS_SCALABLE(face));
 
        //打印一些属性
        log_msg("成功加载一个字体：{}，{}", _vecFace.size(), path_name);
        log_("名称：{}", face->family_name);// 不是utf8
        log_("字形数：{}", face->num_glyphs);
        //debug(format("包围盒：({}, {})，({}, {})",
        //  face->bbox.xMin, face->bbox.xMax,
        //  face->bbox.yMin, face->bbox.yMax));
        _vecFace.push_back(face);
        _vecProperty.push_back({});
        return _vecFace.size() - 1;
    }
 
    CharImage* GetChar(const CharInfo& info)
    {
        //错误输出
        auto fn_debug = [&](std::string_view str)
        {
            log_err("{}：{}，{}，{}，{}",
                str, info._font, std::to_string(info._ch), info._size, info._outline);
        };
 
        if (info._font >= _vecFace.size())
        {
            fn_debug("字体id越界");
            return nullptr;
        }
 
        const char32_t& ch = info._ch;
        const size_t& size = info._size;
        const size_t& outline = info._outline;
 
        FT_Face ft_face = _vecFace[info._font];
        if (FT_Select_Charmap(ft_face, FT_ENCODING_UNICODE))
        {
            fn_debug("设置编码失败");
            return nullptr;
        }
 
        if (FT_Set_Char_Size(ft_face, FT_F26Dot6(size << 6), FT_F26Dot6(size << 6), 72, 72))
        {
            fn_debug("设置字体大小失败");
            return nullptr;
        }
 
        FT_UInt gindex = FT_Get_Char_Index(ft_face, ch);
        if (FT_Load_Glyph(ft_face, gindex, FT_LOAD_NO_BITMAP))
        {
            fn_debug("字形加载失败");
            return nullptr;
        }
        if (ft_face->glyph->format != FT_GLYPH_FORMAT_OUTLINE)
        {
            fn_debug("不支持描边");
            return nullptr;
        }
        //渲染到 spans
        std::vector<Span> spans;
        RenderSpans(_library, &ft_face->glyph->outline, &spans);
 
        //接下来渲染到 spans_outline
        std::vector<Span> spans_outline;
 
        //设置画笔
        FT_Stroker stroker;
        FT_Stroker_New(_library, &stroker);
        FT_Stroker_Set(stroker,
            (int)(outline * 64),
            FT_STROKER_LINECAP_ROUND,
            FT_STROKER_LINEJOIN_ROUND,
            0);
 
        FT_Glyph glyph;
        if (FT_Get_Glyph(ft_face->glyph, &glyph))
        {
            fn_debug("获取字形失败");
            return nullptr;
        }
 
        FT_Glyph_StrokeBorder(&glyph, stroker, 0, 1);
        if (glyph->format == FT_GLYPH_FORMAT_OUTLINE)
        {
            //绘制outline到 outline_spans
            FT_Outline* o =
                &reinterpret_cast<FT_OutlineGlyph>(glyph)->outline;
            RenderSpans(_library, o, &spans_outline);
        }
 
        //清理后面无需用到的资源
        FT_Stroker_Done(stroker);
        FT_Done_Glyph(glyph);
 
        if (spans.empty())
        {
            fn_debug("spans为空（或许打印了控制字符）");
            return nullptr;
        }
        //计算二者包围盒（描边更大）
        CharRect rect(
            float(spans.front()._x),
            float(spans.front()._y),
            float(spans.front()._x),
            float(spans.front()._y));
        for (Span& s : spans)
        {
            rect.Include(s._x, s._y);
            rect.Include(s._x + s._w - 1, s._y);
        }
        for (Span& s : spans_outline)
        {
            rect.Include(s._x, s._y);
            rect.Include(s._x + s._w - 1, s._y);
        }
 
        //获得必要的属性
        unsigned img_w = (unsigned)rect.Width();
        unsigned img_h = (unsigned)rect.Height();
 
 
        //分配图像内存，以0颜色
        Image* img_outline = Img::Create({ img_w ,img_h }, ColorDef::NONE);
        Image* img = Img::Create({ img_w ,img_h }, ColorDef::NONE);
 
        //这里取得image buffer指针来赋值
        uint32_t* p_lock = img_outline->GetData();
 
        //复制到img_outline
        for (Span& s : spans_outline)
        {
            for (int w = 0; w < s._w; ++w)
            {
                size_t y = (size_t)(img_h - 1 - (s._y - rect._yMin));
                size_t index = (size_t)(y * img_w + s._x - rect._xMin + w);
                p_lock[index] = uint32_t(s._coverage) << 24 | 0x00ffffff;
            }
        }
        //复制到img
        p_lock = img->GetData();
        for (Span& s : spans)
        {
            for (int w = 0; w < s._w; ++w)
            {
                size_t y = (size_t)(img_h - 1 - (s._y - rect._yMin));
                size_t index = (size_t)(y * img_w + s._x - rect._xMin + w);
                p_lock[index] = uint32_t(s._coverage) << 24 | 0x00ffffff;
            }
        }
            
        float bearingX = float(ft_face->glyph->metrics.horiBearingX >> 6);
        float bearingY = float(ft_face->glyph->metrics.horiBearingY >> 6);
        float advance = float(ft_face->glyph->advance.x >> 6);
 
        CharImage* ret = new CharImage;
        
        ret->_advance = advance;
        ret->_bearingX = bearingX;
        ret->_bearingY = bearingY;
        ret->_image = img;
        ret->_imageOutline = img_outline;
 
        Property& prop = _vecProperty[info._font][info._size];
        prop._ascent = float(ft_face->size->metrics.ascender >> 6);
        prop._descent = float(ft_face->size->metrics.descender >> 6);
        prop._linegap = 0;
        //prop._linegap = float(ft_face->size->metrics.y_ppem >> 6);
 
        return ret;
    }
 
 
    size_t GetFontSize()
    {
        return _vecFace.size();
    }
 
    const Property& GetProperty(size_t font, unsigned size)
    {
        std::unordered_map<int, Property>& vec = _vecProperty[font];
        auto iter = vec.find(size);
        if (iter == vec.end())
        {
            log_err0("不应该出现的情况！");
            return _vecProperty[font][size];
        }
        return iter->second;
    }
 
    ~FreeType()
    {
        for (auto& iter : _vecFace)
            FT_Done_Face(iter);
        FT_Done_FreeType(_library);
    }
private:
    FT_Library _library;
    std::vector<Buffer> _vecBuffer;
    std::vector<FT_Face> _vecFace;
    std::vector<std::unordered_map<int, Property>> _vecProperty;
};
 
extern FreeType* g_freetype;
 
}
#endif