使用FreeType实现矢量字体的粗体、斜体、描边、阴影效果

古城微笑少年丶 2021-09-19 10:30 823阅读 0赞

## 前言： ##

Freetype是一个跨平台、开源的字体渲染器，网上很多文章介绍，本人就不啰嗦了。本文重点在于实现文章标题所属的各种效果，不是Freetype的基本使用方法介绍文档，所以对于Freetype不熟悉的同学们请先学习下Freetype的基本用法，才可以使用本文中所提及的方法。

## 正文： ##

用FreeType实现矢量字体的粗体、斜体、描边、阴影效果不是一件容易的事，本人认为皆因Freetype的接口太过于底层化，Freetype没有对其进行上层包装，所以要实现这些对于软件/游戏来说的基本效果，都是件挺麻烦的事情。不过，问题总是会有解决方法的，这些效果的实现，请听本人一个个道来：

### 1.      加粗 ###

加粗可以使用FreeType中的一个API来实现FT\_Outline\_Embolden，但是这个API不支持水平垂直方向加粗量的分别设置，所以，需要参照FT\_Outline\_Embolden的实现重新编写一个函数，GDI++已经做了这个事情，引用它的代码：

// 就是FT\_Outline\_Embolden  
FT\_Error Old\_FT\_Outline\_Embolden( FT\_Outline\*  outline, FT\_Pos strength )  
\{  
    FT\_Vector\*    points;  
    FT\_Vector    v\_prev, v\_first, v\_next, v\_cur;  
    FT\_Angle    rotate, angle\_in, angle\_out;  
    FT\_Int        c, n, first;  
    FT\_Int        orientation;  
  
    if ( !outline )  
        return FT\_Err\_Invalid\_Argument;  
  
    strength /= 2;  
    if ( strength == 0 )  
        return FT\_Err\_Ok;  
  
    orientation = FT\_Outline\_Get\_Orientation( outline );  
    if ( orientation == FT\_ORIENTATION\_NONE )  
    \{  
        if ( outline->n\_contours )  
            return FT\_Err\_Invalid\_Argument;  
        else  
            return FT\_Err\_Ok;  
    \}  
  
    if ( orientation == FT\_ORIENTATION\_TRUETYPE )  
        rotate = -FT\_ANGLE\_PI2;  
    else  
        rotate = FT\_ANGLE\_PI2;  
  
    points = outline->points;  
  
    first = 0;  
    for ( c = 0; c < outline->n\_contours; c++ )  
    \{  
        int  last = outline->contours\[c\];  
  
        v\_first = points\[first\];  
        v\_prev  = points\[last\];  
        v\_cur   = v\_first;  
  
        for ( n = first; n <= last; n++ )  
        \{  
            FT\_Vector    in, out;  
            FT\_Angle    angle\_diff;  
            FT\_Pos        d;  
            FT\_Fixed    scale;  
  
            if ( n < last )  
                v\_next = points\[n + 1\];  
            else  
                v\_next = v\_first;  
  
            /\* compute the in and out vectors \*/  
            in.x = v\_cur.x - v\_prev.x;  
            in.y = v\_cur.y - v\_prev.y;  
  
            out.x = v\_next.x - v\_cur.x;  
            out.y = v\_next.y - v\_cur.y;  
  
            angle\_in   = FT\_Atan2( in.x, in.y );  
            angle\_out  = FT\_Atan2( out.x, out.y );  
            angle\_diff = FT\_Angle\_Diff( angle\_in, angle\_out );  
            scale      = FT\_Cos( angle\_diff / 2 );  
  
            if ( scale < 0x4000L && scale > -0x4000L )  
                in.x = in.y = 0;  
            else  
            \{  
                d = FT\_DivFix( strength, scale );  
  
                FT\_Vector\_From\_Polar( &in, d, angle\_in + angle\_diff / 2 - rotate );  
            \}  
  
            outline->points\[n\].x = v\_cur.x + strength + in.x;  
            //伀偙傟傪僐儊儞僩傾僂僩偟偨偩偗  
            //outline->points\[n\].y = v\_cur.y + strength + in.y;  
  
            v\_prev = v\_cur;  
            v\_cur  = v\_next;  
        \}  
  
        first = last + 1;  
    \}  
  
    return FT\_Err\_Ok;  
\}  
  
// 垂直加粗  
FT\_Error Vert\_FT\_Outline\_Embolden( FT\_Outline\*  outline, FT\_Pos strength )  
\{  
    FT\_Vector\*    points;  
    FT\_Vector    v\_prev, v\_first, v\_next, v\_cur;  
    FT\_Angle    rotate, angle\_in, angle\_out;  
    FT\_Int        c, n, first;  
    FT\_Int        orientation;  
  
    if ( !outline )  
        return FT\_Err\_Invalid\_Argument;  
  
    strength /= 2;  
    if ( strength == 0 )  
        return FT\_Err\_Ok;  
  
    orientation = FT\_Outline\_Get\_Orientation( outline );  
    if ( orientation == FT\_ORIENTATION\_NONE )  
    \{  
        if ( outline->n\_contours )  
            return FT\_Err\_Invalid\_Argument;  
        else  
            return FT\_Err\_Ok;  
    \}  
  
    if ( orientation == FT\_ORIENTATION\_TRUETYPE )  
        rotate = -FT\_ANGLE\_PI2;  
    else  
        rotate = FT\_ANGLE\_PI2;  
  
    points = outline->points;  
  
    first = 0;  
    for ( c = 0; c < outline->n\_contours; c++ )  
    \{  
        int  last = outline->contours\[c\];  
  
        v\_first = points\[first\];  
        v\_prev  = points\[last\];  
        v\_cur   = v\_first;  
  
        for ( n = first; n <= last; n++ )  
        \{  
            FT\_Vector    in, out;  
            FT\_Angle    angle\_diff;  
            FT\_Pos        d;  
            FT\_Fixed    scale;  
  
            if ( n < last )  
                v\_next = points\[n + 1\];  
            else  
                v\_next = v\_first;  
  
            /\* compute the in and out vectors \*/  
            in.x = v\_cur.x - v\_prev.x;  
            in.y = v\_cur.y - v\_prev.y;  
  
            out.x = v\_next.x - v\_cur.x;  
            out.y = v\_next.y - v\_cur.y;  
  
            angle\_in   = FT\_Atan2( in.x, in.y );  
            angle\_out  = FT\_Atan2( out.x, out.y );  
            angle\_diff = FT\_Angle\_Diff( angle\_in, angle\_out );  
            scale      = FT\_Cos( angle\_diff / 2 );  
  
            if ( scale < 0x4000L && scale > -0x4000L )  
                in.x = in.y = 0;  
            else  
            \{  
                d = FT\_DivFix( strength, scale );  
  
                FT\_Vector\_From\_Polar( &in, d, angle\_in + angle\_diff / 2 - rotate );  
            \}  
  
            //outline->points\[n\].x = v\_cur.x + strength + in.x;  
            //仾偙傟傪僐儊儞僩傾僂僩偟偨偩偗  
            outline->points\[n\].y = v\_cur.y + strength + in.y;  
  
            v\_prev = v\_cur;  
            v\_cur  = v\_next;  
        \}  
  
        first = last + 1;  
    \}  
  
    return FT\_Err\_Ok;  
\}  
  
// 新的加粗函数  
FT\_Error New\_FT\_Outline\_Embolden( FT\_Outline\*  outline, FT\_Pos str\_h, FT\_Pos str\_v )  
\{  
    if ( !outline ) return FT\_Err\_Invalid\_Argument;  
    int orientation = FT\_Outline\_Get\_Orientation( outline );  
    if ( orientation == FT\_ORIENTATION\_NONE )  
        if ( outline->n\_contours ) return FT\_Err\_Invalid\_Argument;  
    Vert\_FT\_Outline\_Embolden( outline, str\_v );  
    Old\_FT\_Outline\_Embolden( outline, str\_h );  
    return FT\_Err\_Ok;  
\}  
  
// 让一个字体槽加粗，并且填充其他的大小属性  
void New\_GlyphSlot\_Embolden( FT\_GlyphSlot  slot , const Vector2Float &embolden)  
\{  
    if(embolden == Vector2Float::ZERO)  
        return;  
    FT\_Library  library = slot->library;  
    FT\_Face     face    = slot->face;  
    FT\_Error    error;  
    FT\_Pos      xstr = embolden.x, ystr = embolden.y;  
  
  
    if ( slot->format != FT\_GLYPH\_FORMAT\_OUTLINE &&  
        slot->format != FT\_GLYPH\_FORMAT\_BITMAP )  
        return;  
  
    if ( slot->format == FT\_GLYPH\_FORMAT\_OUTLINE )  
    \{  
        FT\_BBox oldBox;  
        FT\_Outline\_Get\_CBox(&slot->outline , &oldBox);  
        error = New\_FT\_Outline\_Embolden( &slot->outline, xstr , ystr);  
        if ( error )  
            return;  
  
        FT\_BBox newBox;  
        FT\_Outline\_Get\_CBox(&slot->outline , &newBox);  
        xstr = (newBox.xMax - newBox.xMin) - (oldBox.xMax - oldBox.xMin);  
        ystr = (newBox.yMax - newBox.yMin) - (oldBox.yMax - oldBox.yMin);  
    \}  
    else if ( slot->format == FT\_GLYPH\_FORMAT\_BITMAP )  
    \{  
        xstr = FT\_PIX\_FLOOR( xstr );  
        if ( xstr == 0 )  
            xstr = 1 << 6;  
        ystr = FT\_PIX\_FLOOR( ystr );  
  
        error = FT\_Bitmap\_Embolden( library, &slot->bitmap, xstr, ystr );  
        if ( error )  
            return;  
    \}  
  
    if ( slot->advance.x )  
        slot->advance.x += xstr;  
  
    if ( slot->advance.y )  
        slot->advance.y += ystr;  
  
    slot->metrics.width        += xstr;  
    slot->metrics.height       += ystr;  
    slot->metrics.horiBearingY += ystr;  
    slot->metrics.horiAdvance  += xstr;  
    slot->metrics.vertBearingX -= xstr / 2;  
    slot->metrics.vertBearingY += ystr;  
    slot->metrics.vertAdvance  += ystr;  
  
    if ( slot->format == FT\_GLYPH\_FORMAT\_BITMAP )  
        slot->bitmap\_top += ystr >> 6;  
\}

2.      斜体

斜体在FreeType中可以通过矩阵变换来实现，只要把矩阵设置成一个切边矩阵就可以了，方法如下：

// 倾斜度，越大就越斜  
float lean = 0.5f;  
FT\_Matrix matrix;  
matrix.xx = 0x10000L;  
matrix.xy = lean \* 0x10000L;  
matrix.yx = 0;  
matrix.yy = 0x10000L;  
FT\_Set\_Transform( face, &matrix, 0 );

1.    
    3.      描边

网上有不少文章说描边其实很简单，就是上下左右各移动一个像素渲染一次，最后在中间再渲染一次就可以了。但是，这种方法只对于位图字体有效，对于矢量字体，效果就不好了，特别是大字体，1个像素只是很细的边界而已，对于很小的字体，1像素又显得太大。

这里提供另一种实现方案，使用的是Freetype的API：

1.  使用FT\_Stroker\_New创建一个笔触
2.  FT\_Stroker\_Set设置笔触为描边
3.  把Load后的glyph通过FT\_Glyph\_Copy拷贝一份出来
4.  对这个拷贝出来的glyph使用FT\_Glyph\_StrokeBorder设置成描边渲染
5.  使用FT\_Outline\_Render渲染这个描边的glyph，渲染前要设置FT\_Raster\_Params参数成：

FT\_Raster\_Params params;  
memset(&params, 0, sizeof(params));  
params.flags = FT\_RASTER\_FLAG\_AA | FT\_RASTER\_FLAG\_DIRECT;  
params.gray\_spans = RasterCallback;

1.  在回调函数RasterCallback中实现像素化到位图中
2.  对原来的glyph执行8操作，在回调函数RasterCallback中实现像素化到位图中，像素化过程使用alphablend的方式绘制上去
3.  把位图渲染到屏幕上或保存到文件中

这个方法是Freetype的一个example，只是很少有人注意而已，源码在这里http://www.freetype.org/freetype2/docs/tutorial/example2.cpp。

12. 阴影

阴影的实现就比较简单了，只要一个个像素偏移后多渲染几次就可以了，再次不多说。

本文转自博客园知识天地的博客，原文链接：[使用FreeType实现矢量字体的粗体、斜体、描边、阴影效果][FreeType]，如需转载请自行联系原博主。

[FreeType]: http://www.cnblogs.com/mfryf/p/3824702.html