自学教程：C++ FT_Outline_Get_CBox函数代码示例

bool TTBMFont::addFontGlyph(int fontnum,FT_UInt glyphIndex,wchar32_t chr) {	FT_Error error;	FT_Face face=fontFaces_[fontnum].face;	error = FT_Load_Glyph(face, glyphIndex, FT_LOAD_DEFAULT);	if (error)		return false;	int top, left, width, height;	if (face->glyph->format == FT_GLYPH_FORMAT_OUTLINE) {		FT_BBox bbox;		if (stroker) {			FT_Glyph glyph;			error = FT_Get_Glyph(face->glyph, &glyph);			if (error)				return false;			error = FT_Glyph_StrokeBorder(&glyph, stroker, false, true);			if (error)				return false;			FT_OutlineGlyph oGlyph = reinterpret_cast<FT_OutlineGlyph>(glyph);			FT_Outline_Get_CBox(&oGlyph->outline, &bbox);			FT_Done_Glyph(glyph);		}		else			FT_Outline_Get_CBox(&face->glyph->outline, &bbox);		bbox.xMin &= ~63;		bbox.yMin &= ~63;		bbox.xMax = (bbox.xMax + 63) & ~63;		bbox.yMax = (bbox.yMax + 63) & ~63;		width = (bbox.xMax - bbox.xMin) >> 6;		height = (bbox.yMax - bbox.yMin) >> 6;		top = bbox.yMax >> 6;		left = bbox.xMin >> 6;	} else if (face->glyph->format == FT_GLYPH_FORMAT_BITMAP) {

// 让一个字体槽加粗，并且填充其他的大小属性void New_GlyphSlot_Embolden( FT_GlyphSlot  slot, const FT_Pos str_x, const FT_Pos str_y){    FT_Library library;    FT_Face face;    FT_Error error;	FT_BBox newBox, oldBox;    FT_Pos xstr = (FT_Pos)str_x;	FT_Pos ystr = (FT_Pos)str_y;	CC_ASSERT(slot != NULL);	library = slot->library;	face    = slot->face;    if ( slot->format != FT_GLYPH_FORMAT_OUTLINE &&        slot->format != FT_GLYPH_FORMAT_BITMAP )        return;    if ( slot->format == FT_GLYPH_FORMAT_OUTLINE ) {        FT_Outline_Get_CBox(&slot->outline , &oldBox);        error = New_FT_Outline_Embolden( &slot->outline, xstr , ystr);        if ( error )            return;        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;}

  ft_outline_glyph_bbox( FT_Glyph  outline_glyph,                         FT_BBox*  bbox )  {    FT_OutlineGlyph  glyph = (FT_OutlineGlyph)outline_glyph;    FT_Outline_Get_CBox( &glyph->outline, bbox );  }

static PyObject*Py_Outline_get_cbox(Py_Outline* self, PyObject* args, PyObject* kwds){    FT_BBox bbox;    FT_Outline_Get_CBox(&self->x, &bbox);    return Py_BBox_cnew(&bbox, 1.0);}

  /* return the glyph's control box */  static void  ft_smooth_get_cbox( FT_Renderer   render,                      FT_GlyphSlot  slot,                      FT_BBox*      cbox )  {    FT_MEM_SET( cbox, 0, sizeof ( *cbox ) );    if ( slot->format == render->glyph_format )      FT_Outline_Get_CBox( &slot->outline, cbox );  }

/* convert a slot's glyph image into a bitmap */static FT_Errorft_smooth_render_generic( FT_Renderer       render,                          FT_GlyphSlot      slot,                          FT_Render_Mode    mode,                          const FT_Vector*  origin,                          FT_Render_Mode    required_mode ){    FT_Error     error;    FT_Outline*  outline = NULL;    FT_BBox      cbox;    FT_UInt      width, height, pitch;#ifndef FT_CONFIG_OPTION_SUBPIXEL_RENDERING    FT_UInt      height_org, width_org;#endif    FT_Bitmap*   bitmap;    FT_Memory    memory;    FT_Int       hmul = mode == FT_RENDER_MODE_LCD;    FT_Int       vmul = mode == FT_RENDER_MODE_LCD_V;    FT_Pos       x_shift, y_shift, x_left, y_top;    FT_Raster_Params  params;    /* check glyph image format */    if ( slot->format != render->glyph_format )    {        error = Smooth_Err_Invalid_Argument;        goto Exit;    }    /* check mode */    if ( mode != required_mode )        return Smooth_Err_Cannot_Render_Glyph;    outline = &slot->outline;    /* translate the outline to the new origin if needed */    if ( origin )        FT_Outline_Translate( outline, origin->x, origin->y );    /* compute the control box, and grid fit it */    FT_Outline_Get_CBox( outline, &cbox );    cbox.xMin = FT_PIX_FLOOR( cbox.xMin );    cbox.yMin = FT_PIX_FLOOR( cbox.yMin );    cbox.xMax = FT_PIX_CEIL( cbox.xMax );    cbox.yMax = FT_PIX_CEIL( cbox.yMax );    if ( cbox.xMin < 0 && cbox.xMax > FT_INT_MAX + cbox.xMin )    {        FT_ERROR(( "ft_smooth_render_generic: glyph too large:"                   " xMin = %d, xMax = %d/n",                   cbox.xMin >> 6, cbox.xMax >> 6 ));        return Smooth_Err_Raster_Overflow;    }

/* return the glyph's control box */staticvoid  ft_raster1_get_cbox(FT_Renderer render,                          FT_GlyphSlot slot,                          FT_BBox      *cbox){	MEM_Set(cbox, 0, sizeof(*cbox));	if(slot->format == render->glyph_format)	{		FT_Outline_Get_CBox(&slot->outline, cbox);	}}

Bitmap *outline_to_bitmap(ASS_Library *library, FT_Library ftlib,                          FT_Outline *outline, int bord){    Bitmap *bm;    int w, h;    int error;    FT_BBox bbox;    FT_Bitmap bitmap;    FT_Outline_Get_CBox(outline, &bbox);    // move glyph to origin (0, 0)    bbox.xMin &= ~63;    bbox.yMin &= ~63;    FT_Outline_Translate(outline, -bbox.xMin, -bbox.yMin);    // bitmap size    bbox.xMax = (bbox.xMax + 63) & ~63;    bbox.yMax = (bbox.yMax + 63) & ~63;    w = (bbox.xMax - bbox.xMin) >> 6;    h = (bbox.yMax - bbox.yMin) >> 6;    // pen offset    bbox.xMin >>= 6;    bbox.yMax >>= 6;    if (w * h > 8000000) {        ass_msg(library, MSGL_WARN, "Glyph bounding box too large: %dx%dpx",                w, h);        return NULL;    }    // allocate and set up bitmap    bm = alloc_bitmap(w + 2 * bord, h + 2 * bord);    bm->left = bbox.xMin - bord;    bm->top = -bbox.yMax - bord;    bitmap.width = w;    bitmap.rows = h;    bitmap.pitch = bm->stride;    bitmap.buffer = bm->buffer + bord + bm->stride * bord;    bitmap.num_grays = 256;    bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;    // render into target bitmap    if ((error = FT_Outline_Get_Bitmap(ftlib, outline, &bitmap))) {        ass_msg(library, MSGL_WARN, "Failed to rasterize glyph: %d/n", error);        ass_free_bitmap(bm);        return NULL;    }    return bm;}

void TTFont::getBounds(const wchar32_t *text, float letterSpacing, int *pminx, int *pminy, int *pmaxx, int *pmaxy) const{    float scalex = application_->getLogicalScaleX();    int minx = 0x7fffffff;    int miny = 0x7fffffff;    int maxx = -0x7fffffff;    int maxy = -0x7fffffff;    int size = 0;    for (const wchar32_t *t = text; *t; ++t, ++size)        ;    int x = 0, y = 0;    FT_UInt prev = 0;    for (int i = 0; i < size; ++i)	{        FT_UInt glyphIndex = FT_Get_Char_Index(face_, text[i]);        if (glyphIndex == 0)            continue;        if (FT_Load_Glyph(face_, glyphIndex, FT_LOAD_DEFAULT))			continue;        int top, left, width, height;        if (face_->glyph->format == FT_GLYPH_FORMAT_OUTLINE)        {            FT_BBox bbox;            FT_Outline_Get_CBox(&face_->glyph->outline, &bbox);            bbox.xMin &= ~63;            bbox.yMin &= ~63;            bbox.xMax  = (bbox.xMax + 63) & ~63;            bbox.yMax  = (bbox.yMax + 63) & ~63;            width  = (bbox.xMax - bbox.xMin) >> 6;            height = (bbox.yMax - bbox.yMin) >> 6;            top = bbox.yMax >> 6;            left = bbox.xMin >> 6;        }        else if (face_->glyph->format == FT_GLYPH_FORMAT_BITMAP)

/* * /brief Finish a drawing.  This only sets the horizontal advance according * to the glyph's bbox at the moment. */static void drawing_finish(ASS_Drawing *drawing, int raw_mode){    int i, offset;    FT_BBox bbox;    FT_Outline *ol = &drawing->glyph->outline;    // Close the last contour    drawing_close_shape(drawing);#if 0    // Dump points    for (i = 0; i < ol->n_points; i++) {        printf("point (%d, %d)/n", (int) ol->points[i].x,               (int) ol->points[i].y);    }    // Dump contours    for (i = 0; i < ol->n_contours; i++)        printf("contour %d/n", ol->contours[i]);#endif    ass_msg(drawing->library, MSGL_V,            "Parsed drawing with %d points and %d contours", ol->n_points,            ol->n_contours);    if (raw_mode)        return;    FT_Outline_Get_CBox(&drawing->glyph->outline, &bbox);    drawing->glyph->root.advance.x = d6_to_d16(bbox.xMax - bbox.xMin);    drawing->desc = double_to_d6(-drawing->pbo * drawing->scale_y);    drawing->asc = bbox.yMax - bbox.yMin + drawing->desc;    // Place it onto the baseline    offset = (bbox.yMax - bbox.yMin) + double_to_d6(-drawing->pbo *                                                    drawing->scale_y);    for (i = 0; i < ol->n_points; i++)        ol->points[i].y += offset;}

static FT_ErrorLoadTrueTypeChar(Font *fnt,                 int idx,                 Boolean hint,                 Boolean quiet){  FT_Error error;  int flags;  flags = FT_LOAD_DEFAULT;  if (hint)    flags |= FT_LOAD_FORCE_AUTOHINT;  error = FT_Load_Glyph(face, idx, flags);  if (!error)  {    if (fnt->efactor != 1.0 || fnt->slant != 0.0 )      FT_Outline_Transform(&face->glyph->outline, &matrix1);    if (fnt->rotate)    {      FT_Outline_Transform(&face->glyph->outline, &matrix2);      error = FT_Outline_Get_BBox(&face->glyph->outline, &bbox); /* we need the non-                                                                    grid-fitted bbox */      if (!error)        FT_Outline_Translate(&face->glyph->outline,                             face->glyph->metrics.vertBearingY - bbox.xMin,                             -fnt->y_offset * ppem * 64);    }  }  if (!error)    error = FT_Outline_Get_BBox(&face->glyph->outline, &bbox);  if (!error)  {    FT_Outline_Get_CBox(&face->glyph->outline, &bbox); /* for the case of BBox != CBox */    SetRasterArea(quiet);  }  return error;}

/* convert a slot's glyph image into a bitmap */staticFT_Error  ft_raster1_render(FT_Renderer render,                            FT_GlyphSlot slot,                            FT_UInt mode,                            FT_Vector    *origin){	FT_Error error;	FT_Outline  *outline;	FT_BBox cbox;	FT_UInt width, height, pitch;	FT_Bitmap   *bitmap;	FT_Memory memory;	FT_Raster_Params params;	/* check glyph image format */	if(slot->format != render->glyph_format)	{		error = FT_Err_Invalid_Argument;		goto Exit;	}	/* check rendering mode */	if(mode != ft_render_mode_mono)	{		/* raster1 is only capable of producing monochrome bitmaps */		if(render->clazz == &ft_raster1_renderer_class)		{			return FT_Err_Cannot_Render_Glyph;		}	}	else	{		/* raster5 is only capable of producing 5-gray-levels bitmaps */		if(render->clazz == &ft_raster5_renderer_class)		{			return FT_Err_Cannot_Render_Glyph;		}	}	outline = &slot->outline;	/* translate the outline to the new origin if needed */	if(origin)	{		FT_Outline_Translate(outline, origin->x, origin->y);	}	/* compute the control box, and grid fit it */	FT_Outline_Get_CBox(outline, &cbox);	cbox.xMin &= -64;	cbox.yMin &= -64;	cbox.xMax  = (cbox.xMax + 63) & - 64;	cbox.yMax  = (cbox.yMax + 63) & - 64;	width  = (cbox.xMax - cbox.xMin) >> 6;	height = (cbox.yMax - cbox.yMin) >> 6;	bitmap = &slot->bitmap;	memory = render->root.memory;	/* release old bitmap buffer */	if(slot->flags & ft_glyph_own_bitmap)	{		FREE(bitmap->buffer);		slot->flags &= ~ft_glyph_own_bitmap;	}	/* allocate new one, depends on pixel format */	if(!(mode & ft_render_mode_mono))	{		/* we pad to 32 bits, only for backwards compatibility with FT 1.x */		pitch = (width + 3) & - 4;		bitmap->pixel_mode = ft_pixel_mode_grays;		bitmap->num_grays  = 256;	}	else	{		pitch = (width + 7) >> 3;		bitmap->pixel_mode = ft_pixel_mode_mono;	}	bitmap->width = width;	bitmap->rows  = height;	bitmap->pitch = pitch;	if(ALLOC(bitmap->buffer, (FT_ULong)pitch * height))	{		goto Exit;	}	slot->flags |= ft_glyph_own_bitmap;	/* translate outline to render it into the bitmap */	FT_Outline_Translate(outline, -cbox.xMin, -cbox.yMin);	/* set up parameters */	params.target = bitmap;//.........这里部分代码省略.........

//.........这里部分代码省略.........    pfrslot->format     = FT_GLYPH_FORMAT_OUTLINE;    outline->n_points   = 0;    outline->n_contours = 0;    gps_offset          = face->header.gps_section_offset;    /* load the glyph outline (FT_LOAD_NO_RECURSE isn't supported) */    error = pfr_glyph_load( &slot->glyph, face->root.stream,                            gps_offset, gchar->gps_offset, gchar->gps_size );    if ( !error )    {      FT_BBox            cbox;      FT_Glyph_Metrics*  metrics = &pfrslot->metrics;      FT_Pos             advance;      FT_Int             em_metrics, em_outline;      FT_Bool            scaling;      scaling = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 );      /* copy outline data */      *outline = slot->glyph.loader->base.outline;      outline->flags &= ~FT_OUTLINE_OWNER;      outline->flags |= FT_OUTLINE_REVERSE_FILL;      if ( size && pfrsize->metrics.y_ppem < 24 )        outline->flags |= FT_OUTLINE_HIGH_PRECISION;      /* compute the advance vector */      metrics->horiAdvance = 0;      metrics->vertAdvance = 0;      advance    = gchar->advance;      em_metrics = face->phy_font.metrics_resolution;      em_outline = face->phy_font.outline_resolution;      if ( em_metrics != em_outline )        advance = FT_MulDiv( advance, em_outline, em_metrics );      if ( face->phy_font.flags & PFR_PHY_VERTICAL )        metrics->vertAdvance = advance;      else        metrics->horiAdvance = advance;      pfrslot->linearHoriAdvance = metrics->horiAdvance;      pfrslot->linearVertAdvance = metrics->vertAdvance;      /* make-up vertical metrics(?) */      metrics->vertBearingX = 0;      metrics->vertBearingY = 0;      /* Apply the font matrix, if any.                 */      /* TODO: Test existing fonts with unusual matrix  */      /* whether we have to adjust Units per EM.        */      {        FT_Matrix font_matrix;        font_matrix.xx = face->log_font.matrix[0] << 8;        font_matrix.yx = face->log_font.matrix[1] << 8;        font_matrix.xy = face->log_font.matrix[2] << 8;        font_matrix.yy = face->log_font.matrix[3] << 8;        FT_Outline_Transform( outline, &font_matrix );      }      /* scale when needed */      if ( scaling )      {        FT_Int      n;        FT_Fixed    x_scale = pfrsize->metrics.x_scale;        FT_Fixed    y_scale = pfrsize->metrics.y_scale;        FT_Vector*  vec     = outline->points;        /* scale outline points */        for ( n = 0; n < outline->n_points; n++, vec++ )        {          vec->x = FT_MulFix( vec->x, x_scale );          vec->y = FT_MulFix( vec->y, y_scale );        }        /* scale the advance */        metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );        metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );      }      /* compute the rest of the metrics */      FT_Outline_Get_CBox( outline, &cbox );      metrics->width        = cbox.xMax - cbox.xMin;      metrics->height       = cbox.yMax - cbox.yMin;      metrics->horiBearingX = cbox.xMin;      metrics->horiBearingY = cbox.yMax - metrics->height;    }  Exit:    return error;  }

/* convert a slot's glyph image into a bitmap */static FT_Errorft_raster1_render( FT_Renderer       render,                   FT_GlyphSlot      slot,                   FT_Render_Mode    mode,                   const FT_Vector*  origin ){    FT_Error     error;    FT_Outline*  outline;    FT_BBox      cbox, cbox0;    FT_UInt      width, height, pitch;    FT_Bitmap*   bitmap;    FT_Memory    memory;    FT_Raster_Params  params;    /* check glyph image format */    if ( slot->format != render->glyph_format )    {        error = Raster_Err_Invalid_Argument;        goto Exit;    }    /* check rendering mode */#ifndef FT_CONFIG_OPTION_PIC    if ( mode != FT_RENDER_MODE_MONO )    {        /* raster1 is only capable of producing monochrome bitmaps */        if ( render->clazz == &ft_raster1_renderer_class )            return Raster_Err_Cannot_Render_Glyph;    }    else    {        /* raster5 is only capable of producing 5-gray-levels bitmaps */        if ( render->clazz == &ft_raster5_renderer_class )            return Raster_Err_Cannot_Render_Glyph;    }#else /* FT_CONFIG_OPTION_PIC */    /* When PIC is enabled, we cannot get to the class object      */    /* so instead we check the final character in the class name   */    /* ("raster5" or "raster1"). Yes this is a hack.               */    /* The "correct" thing to do is have different render function */    /* for each of the classes.                                    */    if ( mode != FT_RENDER_MODE_MONO )    {        /* raster1 is only capable of producing monochrome bitmaps */        if ( render->clazz->root.module_name[6] == '1' )            return Raster_Err_Cannot_Render_Glyph;    }    else    {        /* raster5 is only capable of producing 5-gray-levels bitmaps */        if ( render->clazz->root.module_name[6] == '5' )            return Raster_Err_Cannot_Render_Glyph;    }#endif /* FT_CONFIG_OPTION_PIC */    outline = &slot->outline;    /* translate the outline to the new origin if needed */    if ( origin )        FT_Outline_Translate( outline, origin->x, origin->y );    /* compute the control box, and grid fit it */    FT_Outline_Get_CBox( outline, &cbox0 );    /* undocumented but confirmed: bbox values get rounded */#if 1    cbox.xMin = FT_PIX_ROUND( cbox0.xMin );    cbox.yMin = FT_PIX_ROUND( cbox0.yMin );    cbox.xMax = FT_PIX_ROUND( cbox0.xMax );    cbox.yMax = FT_PIX_ROUND( cbox0.yMax );#else    cbox.xMin = FT_PIX_FLOOR( cbox.xMin );    cbox.yMin = FT_PIX_FLOOR( cbox.yMin );    cbox.xMax = FT_PIX_CEIL( cbox.xMax );    cbox.yMax = FT_PIX_CEIL( cbox.yMax );#endif    /* in the event either width or height round to 0, */    /* try explicitly rounding up/down. In the case of */    /* glyphs containing only one very narrow feature, */    /* this give the drop-out compensation in the      */    /* in the scan conversion code to do its stuff.    */    width  = (FT_UInt)( ( cbox.xMax - cbox.xMin ) >> 6 );    if ( width == 0 )    {        cbox.xMin = FT_PIX_FLOOR( cbox0.xMin );        cbox.xMax = FT_PIX_CEIL( cbox0.xMax );        width  = (FT_UInt)( ( cbox.xMax - cbox.xMin ) >> 6 );    }

//.........这里部分代码省略.........          FT_Short   vertBearingY = 0;          FT_UShort  vertAdvance  = 0;          ( (SFNT_Service)face->sfnt )->get_metrics( face, 1,                                                     glyph_index,                                                     &vertBearingY,                                                     &vertAdvance );          metrics->vertBearingY = vertBearingY;          metrics->vertAdvance  = vertAdvance;        }        else        {          /* make up vertical ones */          if ( face->os2.version != 0xFFFFU )            metrics->vertAdvance = (FT_Pos)( face->os2.sTypoAscender -                                             face->os2.sTypoDescender );          else            metrics->vertAdvance = (FT_Pos)( face->horizontal.Ascender -                                             face->horizontal.Descender );        }        glyph->root.linearVertAdvance = metrics->vertAdvance;        glyph->root.format = FT_GLYPH_FORMAT_OUTLINE;        glyph->root.outline.flags = 0;        if ( size && size->root.metrics.y_ppem < 24 )          glyph->root.outline.flags |= FT_OUTLINE_HIGH_PRECISION;        glyph->root.outline.flags |= FT_OUTLINE_REVERSE_FILL;        /* apply the font matrix, if any */        if ( font_matrix.xx != 0x10000L || font_matrix.yy != 0x10000L ||             font_matrix.xy != 0        || font_matrix.yx != 0        )        {          FT_Outline_Transform( &glyph->root.outline, &font_matrix );          metrics->horiAdvance = FT_MulFix( metrics->horiAdvance,                                            font_matrix.xx );          metrics->vertAdvance = FT_MulFix( metrics->vertAdvance,                                            font_matrix.yy );        }        if ( font_offset.x || font_offset.y )        {          FT_Outline_Translate( &glyph->root.outline,                                font_offset.x,                                font_offset.y );          metrics->horiAdvance += font_offset.x;          metrics->vertAdvance += font_offset.y;        }        if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 || force_scaling )        {          /* scale the outline and the metrics */          FT_Int       n;          FT_Outline*  cur     = &glyph->root.outline;          FT_Vector*   vec     = cur->points;          FT_Fixed     x_scale = glyph->x_scale;          FT_Fixed     y_scale = glyph->y_scale;          /* First of all, scale the points */          if ( !hinting || !decoder.builder.hints_funcs )            for ( n = cur->n_points; n > 0; n--, vec++ )            {              vec->x = FT_MulFix( vec->x, x_scale );              vec->y = FT_MulFix( vec->y, y_scale );            }          /* Then scale the metrics */          metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );          metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );        }        /* compute the other metrics */        FT_Outline_Get_CBox( &glyph->root.outline, &cbox );        metrics->width  = cbox.xMax - cbox.xMin;        metrics->height = cbox.yMax - cbox.yMin;        metrics->horiBearingX = cbox.xMin;        metrics->horiBearingY = cbox.yMax;        if ( has_vertical_info )          metrics->vertBearingX = metrics->horiBearingX -                                    metrics->horiAdvance / 2;        else        {          if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )            ft_synthesize_vertical_metrics( metrics,                                            metrics->vertAdvance );        }      }    }    return error;  }

//.........这里部分代码省略.........    if (gindex > 0)      gindex--;    /* check that the glyph index is correct */    FT_ASSERT( gindex < face->phy_font.num_chars );    /* try to load an embedded bitmap */    if ( ( load_flags & ( FT_LOAD_NO_SCALE | FT_LOAD_NO_BITMAP ) ) == 0 )    {      error = pfr_slot_load_bitmap( slot, size, gindex );      if ( error == 0 )        goto Exit;    }    gchar               = face->phy_font.chars + gindex;    slot->root.format   = FT_GLYPH_FORMAT_OUTLINE;    outline->n_points   = 0;    outline->n_contours = 0;    gps_offset          = face->header.gps_section_offset;    /* load the glyph outline (FT_LOAD_NO_RECURSE isn't supported) */    error = pfr_glyph_load( &slot->glyph, face->root.stream,                            gps_offset, gchar->gps_offset, gchar->gps_size );    if ( !error )    {      FT_BBox            cbox;      FT_Glyph_Metrics*  metrics = &slot->root.metrics;      FT_Pos             advance;      FT_Int             em_metrics, em_outline;      FT_Bool            scaling;      scaling = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 );      /* copy outline data */      *outline = slot->glyph.loader->base.outline;      outline->flags &= ~FT_OUTLINE_OWNER;      outline->flags |= FT_OUTLINE_REVERSE_FILL;      if ( size && size->root.metrics.y_ppem < 24 )        outline->flags |= FT_OUTLINE_HIGH_PRECISION;      /* compute the advance vector */      metrics->horiAdvance = 0;      metrics->vertAdvance = 0;      advance    = gchar->advance;      em_metrics = face->phy_font.metrics_resolution;      em_outline = face->phy_font.outline_resolution;      if ( em_metrics != em_outline )        advance = FT_MulDiv( advance, em_outline, em_metrics );      if ( face->phy_font.flags & PFR_PHY_VERTICAL )        metrics->vertAdvance = advance;      else        metrics->horiAdvance = advance;      slot->root.linearHoriAdvance = metrics->horiAdvance;      slot->root.linearVertAdvance = metrics->vertAdvance;      /* make-up vertical metrics(?) */      metrics->vertBearingX = 0;      metrics->vertBearingY = 0;      /* scale when needed */      if ( scaling )      {        FT_Int      n;        FT_Fixed    x_scale = size->root.metrics.x_scale;        FT_Fixed    y_scale = size->root.metrics.y_scale;        FT_Vector*  vec     = outline->points;        /* scale outline points */        for ( n = 0; n < outline->n_points; n++, vec++ )        {          vec->x = FT_MulFix( vec->x, x_scale );          vec->y = FT_MulFix( vec->y, y_scale );        }        /* scale the advance */        metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );        metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );      }      /* compute the rest of the metrics */      FT_Outline_Get_CBox( outline, &cbox );      metrics->width        = cbox.xMax - cbox.xMin;      metrics->height       = cbox.yMax - cbox.yMin;      metrics->horiBearingX = cbox.xMin;      metrics->horiBearingY = cbox.yMax - metrics->height;    }  Exit:    return error;  }

void SkScalerContext_FreeType_Base::generateGlyphImage(    FT_Face face,    const SkGlyph& glyph,    const SkMatrix& bitmapTransform){    const bool doBGR = SkToBool(fRec.fFlags & SkScalerContext::kLCD_BGROrder_Flag);    const bool doVert = SkToBool(fRec.fFlags & SkScalerContext::kLCD_Vertical_Flag);    switch ( face->glyph->format ) {        case FT_GLYPH_FORMAT_OUTLINE: {            FT_Outline* outline = &face->glyph->outline;            int dx = 0, dy = 0;            if (fRec.fFlags & SkScalerContext::kSubpixelPositioning_Flag) {                dx = SkFixedToFDot6(glyph.getSubXFixed());                dy = SkFixedToFDot6(glyph.getSubYFixed());                // negate dy since freetype-y-goes-up and skia-y-goes-down                dy = -dy;            }            memset(glyph.fImage, 0, glyph.rowBytes() * glyph.fHeight);            if (SkMask::kLCD16_Format == glyph.fMaskFormat) {                FT_Outline_Translate(outline, dx, dy);                FT_Error err = FT_Render_Glyph(face->glyph, doVert ? FT_RENDER_MODE_LCD_V :                                                                     FT_RENDER_MODE_LCD);                if (err) {                    SK_TRACEFTR(err, "Could not render glyph.");                    return;                }                SkMask mask;                glyph.toMask(&mask);#ifdef SK_SHOW_TEXT_BLIT_COVERAGE                memset(mask.fImage, 0x80, mask.fBounds.height() * mask.fRowBytes);#endif                FT_GlyphSlotRec& ftGlyph = *face->glyph;                if (!SkIRect::Intersects(mask.fBounds,                                         SkIRect::MakeXYWH( ftGlyph.bitmap_left,                                                           -ftGlyph.bitmap_top,                                                            ftGlyph.bitmap.width,                                                            ftGlyph.bitmap.rows)))                {                    return;                }                // If the FT_Bitmap extent is larger, discard bits of the bitmap outside the mask.                // If the SkMask extent is larger, shrink mask to fit bitmap (clearing discarded).                unsigned char* origBuffer = ftGlyph.bitmap.buffer;                // First align the top left (origin).                if (-ftGlyph.bitmap_top < mask.fBounds.fTop) {                    int32_t topDiff = mask.fBounds.fTop - (-ftGlyph.bitmap_top);                    ftGlyph.bitmap.buffer += ftGlyph.bitmap.pitch * topDiff;                    ftGlyph.bitmap.rows -= topDiff;                    ftGlyph.bitmap_top = -mask.fBounds.fTop;                }                if (ftGlyph.bitmap_left < mask.fBounds.fLeft) {                    int32_t leftDiff = mask.fBounds.fLeft - ftGlyph.bitmap_left;                    ftGlyph.bitmap.buffer += leftDiff;                    ftGlyph.bitmap.width -= leftDiff;                    ftGlyph.bitmap_left = mask.fBounds.fLeft;                }                if (mask.fBounds.fTop < -ftGlyph.bitmap_top) {                    mask.fImage += mask.fRowBytes * (-ftGlyph.bitmap_top - mask.fBounds.fTop);                    mask.fBounds.fTop = -ftGlyph.bitmap_top;                }                if (mask.fBounds.fLeft < ftGlyph.bitmap_left) {                    mask.fImage += sizeof(uint16_t) * (ftGlyph.bitmap_left - mask.fBounds.fLeft);                    mask.fBounds.fLeft = ftGlyph.bitmap_left;                }                // Origins aligned, clean up the width and height.                int ftVertScale = (doVert ? 3 : 1);                int ftHoriScale = (doVert ? 1 : 3);                if (mask.fBounds.height() * ftVertScale < SkToInt(ftGlyph.bitmap.rows)) {                    ftGlyph.bitmap.rows = mask.fBounds.height() * ftVertScale;                }                if (mask.fBounds.width() * ftHoriScale < SkToInt(ftGlyph.bitmap.width)) {                    ftGlyph.bitmap.width = mask.fBounds.width() * ftHoriScale;                }                if (SkToInt(ftGlyph.bitmap.rows) < mask.fBounds.height() * ftVertScale) {                    mask.fBounds.fBottom = mask.fBounds.fTop + ftGlyph.bitmap.rows / ftVertScale;                }                if (SkToInt(ftGlyph.bitmap.width) < mask.fBounds.width() * ftHoriScale) {                    mask.fBounds.fRight = mask.fBounds.fLeft + ftGlyph.bitmap.width / ftHoriScale;                }                if (fPreBlend.isApplicable()) {                    copyFT2LCD16<true>(ftGlyph.bitmap, mask, doBGR,                                       fPreBlend.fR, fPreBlend.fG, fPreBlend.fB);                } else {                    copyFT2LCD16<false>(ftGlyph.bitmap, mask, doBGR,                                        fPreBlend.fR, fPreBlend.fG, fPreBlend.fB);                }                // Restore the buffer pointer so FreeType can properly free it.                ftGlyph.bitmap.buffer = origBuffer;            } else {                FT_BBox     bbox;                FT_Bitmap   target;                FT_Outline_Get_CBox(outline, &bbox);                /*//.........这里部分代码省略.........

  /* convert a slot's glyph image into a bitmap */  static FT_Error  ft_smooth_render( FT_Renderer   render,                    FT_GlyphSlot  slot,                    FT_UInt       mode,                    FT_Vector*    origin )  {    FT_Error     error;    FT_Outline*  outline = NULL;    FT_BBox      cbox;    FT_UInt      width, height, pitch;    FT_Bitmap*   bitmap;    FT_Memory    memory;    FT_Raster_Params  params;    /* check glyph image format */    if ( slot->format != render->glyph_format )    {      error = Smooth_Err_Invalid_Argument;      goto Exit;    }    /* check mode */    if ( mode != ft_render_mode_normal )      return Smooth_Err_Cannot_Render_Glyph;    outline = &slot->outline;    /* translate the outline to the new origin if needed */    if ( origin )      FT_Outline_Translate( outline, origin->x, origin->y );    /* compute the control box, and grid fit it */    FT_Outline_Get_CBox( outline, &cbox );    cbox.xMin &= -64;    cbox.yMin &= -64;    cbox.xMax  = ( cbox.xMax + 63 ) & -64;    cbox.yMax  = ( cbox.yMax + 63 ) & -64;    width  = ( cbox.xMax - cbox.xMin ) >> 6;    height = ( cbox.yMax - cbox.yMin ) >> 6;    bitmap = &slot->bitmap;    memory = render->root.memory;    /* release old bitmap buffer */    if ( slot->flags & FT_GLYPH_OWN_BITMAP )    {      FT_FREE( bitmap->buffer );      slot->flags &= ~FT_GLYPH_OWN_BITMAP;    }    /* allocate new one, depends on pixel format */    pitch = width;    bitmap->pixel_mode = ft_pixel_mode_grays;    bitmap->num_grays  = 256;    bitmap->width      = width;    bitmap->rows       = height;    bitmap->pitch      = pitch;    if ( FT_ALLOC( bitmap->buffer, (FT_ULong)pitch * height ) )      goto Exit;    slot->flags |= FT_GLYPH_OWN_BITMAP;    /* translate outline to render it into the bitmap */    FT_Outline_Translate( outline, -cbox.xMin, -cbox.yMin );    /* set up parameters */    params.target = bitmap;    params.source = outline;    params.flags  = ft_raster_flag_aa;    /* render outline into the bitmap */    error = render->raster_render( render->raster, &params );        FT_Outline_Translate( outline, cbox.xMin, cbox.yMin );    if ( error )      goto Exit;    slot->format      = ft_glyph_format_bitmap;    slot->bitmap_left = cbox.xMin >> 6;    slot->bitmap_top  = cbox.yMax >> 6;  Exit:    if ( outline && origin )      FT_Outline_Translate( outline, -origin->x, -origin->y );    return error;  }

//.........这里部分代码省略.........    /* for composite glyphs, return only left side bearing and */    /* advance width                                           */    if ( load_flags & FT_LOAD_NO_RECURSE )    {      FT_Slot_Internal  internal = cidglyph->internal;      cidglyph->metrics.horiBearingX =        FIXED_TO_INT( decoder.builder.left_bearing.x );      cidglyph->metrics.horiAdvance =        FIXED_TO_INT( decoder.builder.advance.x );      internal->glyph_matrix      = font_matrix;      internal->glyph_delta       = font_offset;      internal->glyph_transformed = 1;    }    else    {      FT_BBox            cbox;      FT_Glyph_Metrics*  metrics = &cidglyph->metrics;      FT_Vector          advance;      /* copy the _unscaled_ advance width */      metrics->horiAdvance =        FIXED_TO_INT( decoder.builder.advance.x );      cidglyph->linearHoriAdvance =        FIXED_TO_INT( decoder.builder.advance.x );      cidglyph->internal->glyph_transformed = 0;      /* make up vertical ones */      metrics->vertAdvance        = ( face->cid.font_bbox.yMax -                                      face->cid.font_bbox.yMin ) >> 16;      cidglyph->linearVertAdvance = metrics->vertAdvance;      cidglyph->format            = FT_GLYPH_FORMAT_OUTLINE;      if ( cidsize->metrics.y_ppem < 24 )        cidglyph->outline.flags |= FT_OUTLINE_HIGH_PRECISION;      /* apply the font matrix */      FT_Outline_Transform( &cidglyph->outline, &font_matrix );      FT_Outline_Translate( &cidglyph->outline,                            font_offset.x,                            font_offset.y );      advance.x = metrics->horiAdvance;      advance.y = 0;      FT_Vector_Transform( &advance, &font_matrix );      metrics->horiAdvance = advance.x + font_offset.x;      advance.x = 0;      advance.y = metrics->vertAdvance;      FT_Vector_Transform( &advance, &font_matrix );      metrics->vertAdvance = advance.y + font_offset.y;      if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 )      {        /* scale the outline and the metrics */        FT_Int       n;        FT_Outline*  cur = decoder.builder.base;        FT_Vector*   vec = cur->points;        FT_Fixed     x_scale = glyph->x_scale;        FT_Fixed     y_scale = glyph->y_scale;        /* First of all, scale the points */        if ( !hinting || !decoder.builder.hints_funcs )          for ( n = cur->n_points; n > 0; n--, vec++ )          {            vec->x = FT_MulFix( vec->x, x_scale );            vec->y = FT_MulFix( vec->y, y_scale );          }        /* Then scale the metrics */        metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );        metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );      }      /* compute the other metrics */      FT_Outline_Get_CBox( &cidglyph->outline, &cbox );      metrics->width  = cbox.xMax - cbox.xMin;      metrics->height = cbox.yMax - cbox.yMin;      metrics->horiBearingX = cbox.xMin;      metrics->horiBearingY = cbox.yMax;      if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )      {        /* make up vertical ones */        ft_synthesize_vertical_metrics( metrics,                                        metrics->vertAdvance );      }    }  Exit:    return error;  }

//.........这里部分代码省略.........        }      }      break;    default:      /* we don't support other formats (yet?) */      error = AF_Err_Unimplemented_Feature;    }  Hint_Metrics:    if ( depth == 0 )    {      FT_BBox    bbox;      FT_Vector  vvector;      vvector.x = slot->metrics.vertBearingX - slot->metrics.horiBearingX;      vvector.y = slot->metrics.vertBearingY - slot->metrics.horiBearingY;      vvector.x = FT_MulFix( vvector.x, metrics->scaler.x_scale );      vvector.y = FT_MulFix( vvector.y, metrics->scaler.y_scale );      /* transform the hinted outline if needed */      if ( loader->transformed )      {        FT_Outline_Transform( &gloader->base.outline, &loader->trans_matrix );        FT_Vector_Transform( &vvector, &loader->trans_matrix );      }#if 1      /* we must translate our final outline by -pp1.x and compute */      /* the new metrics                                           */      if ( loader->pp1.x )        FT_Outline_Translate( &gloader->base.outline, -loader->pp1.x, 0 );#endif      FT_Outline_Get_CBox( &gloader->base.outline, &bbox );      bbox.xMin = FT_PIX_FLOOR( bbox.xMin );      bbox.yMin = FT_PIX_FLOOR( bbox.yMin );      bbox.xMax = FT_PIX_CEIL(  bbox.xMax );      bbox.yMax = FT_PIX_CEIL(  bbox.yMax );      slot->metrics.width        = bbox.xMax - bbox.xMin;      slot->metrics.height       = bbox.yMax - bbox.yMin;      slot->metrics.horiBearingX = bbox.xMin;      slot->metrics.horiBearingY = bbox.yMax;      slot->metrics.vertBearingX = FT_PIX_FLOOR( bbox.xMin + vvector.x );      slot->metrics.vertBearingY = FT_PIX_FLOOR( bbox.yMax + vvector.y );      /* for mono-width fonts (like Andale, Courier, etc.) we need */      /* to keep the original rounded advance width; ditto for     */      /* digits if all have the same advance width                 */#if 0      if ( !FT_IS_FIXED_WIDTH( slot->face ) )        slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;      else        slot->metrics.horiAdvance = FT_MulFix( slot->metrics.horiAdvance,                                               x_scale );#else      if ( scaler->render_mode != FT_RENDER_MODE_LIGHT                      &&           ( FT_IS_FIXED_WIDTH( slot->face )                              ||             ( af_face_globals_is_digit( loader->globals, glyph_index ) &&               metrics->digits_have_same_width                          ) ) )      {        slot->metrics.horiAdvance = FT_MulFix( slot->metrics.horiAdvance,                                               metrics->scaler.x_scale );

  /* convert a slot's glyph image into a bitmap */  static FT_Error  ft_smooth_render_generic( FT_Renderer       render,                            FT_GlyphSlot      slot,                            FT_Render_Mode    mode,                            const FT_Vector*  origin,                            FT_Render_Mode    required_mode )  {    FT_Error     error;    FT_Outline*  outline = NULL;    FT_BBox      cbox;    FT_UInt      width, height, height_org, width_org, pitch;    FT_Bitmap*   bitmap;    FT_Memory    memory;    FT_Int       hmul = mode == FT_RENDER_MODE_LCD;    FT_Int       vmul = mode == FT_RENDER_MODE_LCD_V;    FT_Pos       x_shift, y_shift, x_left, y_top;    FT_Raster_Params  params;    /* check glyph image format */    if ( slot->format != render->glyph_format )    {      error = Smooth_Err_Invalid_Argument;      goto Exit;    }    /* check mode */    if ( mode != required_mode )      return Smooth_Err_Cannot_Render_Glyph;    outline = &slot->outline;    /* translate the outline to the new origin if needed */    if ( origin )      FT_Outline_Translate( outline, origin->x, origin->y );    /* compute the control box, and grid fit it */    FT_Outline_Get_CBox( outline, &cbox );    cbox.xMin = FT_PIX_FLOOR( cbox.xMin );    cbox.yMin = FT_PIX_FLOOR( cbox.yMin );    cbox.xMax = FT_PIX_CEIL( cbox.xMax );    cbox.yMax = FT_PIX_CEIL( cbox.yMax );    width  = (FT_UInt)( ( cbox.xMax - cbox.xMin ) >> 6 );    height = (FT_UInt)( ( cbox.yMax - cbox.yMin ) >> 6 );    bitmap = &slot->bitmap;    memory = render->root.memory;    width_org  = width;    height_org = height;    /* release old bitmap buffer */    if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )    {      FT_FREE( bitmap->buffer );      slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;    }    /* allocate new one */    pitch = width;    if ( hmul )    {      width = width * 3;      pitch = FT_PAD_CEIL( width, 4 );    }    if ( vmul )      height *= 3;    x_shift = (FT_Int) cbox.xMin;    y_shift = (FT_Int) cbox.yMin;    x_left  = (FT_Int)( cbox.xMin >> 6 );    y_top   = (FT_Int)( cbox.yMax >> 6 );#ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING    if ( slot->library->lcd_filter_func )    {      FT_Int  extra = slot->library->lcd_extra;      if ( hmul )      {        x_shift -= 64 * ( extra >> 1 );        width   += 3 * extra;        pitch    = FT_PAD_CEIL( width, 4 );        x_left  -= extra >> 1;      }      if ( vmul )      {        y_shift -= 64 * ( extra >> 1 );        height  += 3 * extra;        y_top   += extra >> 1;      }    }

//.........这里部分代码省略.........      /* advance width                                           */      if ( load_flags & FT_LOAD_NO_RECURSE )      {        FT_Slot_Internal  internal = glyph->root.internal;        glyph->root.metrics.horiBearingX = decoder.builder.left_bearing.x;        glyph->root.metrics.horiAdvance  = decoder.builder.advance.x;        internal->glyph_matrix         = font_matrix;        internal->glyph_delta          = font_offset;        internal->glyph_transformed    = 1;      }      else      {        FT_BBox            cbox;        FT_Glyph_Metrics*  metrics = &glyph->root.metrics;        /* copy the _unscaled_ advance width */        metrics->horiAdvance          = decoder.builder.advance.x;        glyph->root.linearHoriAdvance = decoder.builder.advance.x;        glyph->root.internal->glyph_transformed = 0;        /* make up vertical metrics */        metrics->vertBearingX = 0;        metrics->vertBearingY = 0;        metrics->vertAdvance  = 0;        glyph->root.linearVertAdvance = 0;        glyph->root.format = ft_glyph_format_outline;        if ( size && size->root.metrics.y_ppem < 24 )          glyph->root.outline.flags |= ft_outline_high_precision;        /* apply the font matrix */        FT_Outline_Transform( &glyph->root.outline, &font_matrix );        FT_Outline_Translate( &glyph->root.outline,                              font_offset.x,                              font_offset.y );        if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 )        {          /* scale the outline and the metrics */          FT_Int       n;          FT_Outline*  cur = decoder.builder.base;          FT_Vector*   vec = cur->points;          FT_Fixed     x_scale = glyph->x_scale;          FT_Fixed     y_scale = glyph->y_scale;          /* First of all, scale the points */          if ( !hinting )            for ( n = cur->n_points; n > 0; n--, vec++ )            {              vec->x = FT_MulFix( vec->x, x_scale );              vec->y = FT_MulFix( vec->y, y_scale );            }          FT_Outline_Get_CBox( &glyph->root.outline, &cbox );          /* Then scale the metrics */          metrics->horiAdvance  = FT_MulFix( metrics->horiAdvance,  x_scale );          metrics->vertAdvance  = FT_MulFix( metrics->vertAdvance,  y_scale );          metrics->vertBearingX = FT_MulFix( metrics->vertBearingX, x_scale );          metrics->vertBearingY = FT_MulFix( metrics->vertBearingY, y_scale );          if ( hinting )          {            metrics->horiAdvance = ( metrics->horiAdvance + 32 ) & -64;            metrics->vertAdvance = ( metrics->vertAdvance + 32 ) & -64;            metrics->vertBearingX = ( metrics->vertBearingX + 32 ) & -64;            metrics->vertBearingY = ( metrics->vertBearingY + 32 ) & -64;          }        }        /* compute the other metrics */        FT_Outline_Get_CBox( &glyph->root.outline, &cbox );        /* grid fit the bounding box if necessary */        if ( hinting )        {          cbox.xMin &= -64;          cbox.yMin &= -64;          cbox.xMax  = ( cbox.xMax + 63 ) & -64;          cbox.yMax  = ( cbox.yMax + 63 ) & -64;        }        metrics->width  = cbox.xMax - cbox.xMin;        metrics->height = cbox.yMax - cbox.yMin;        metrics->horiBearingX = cbox.xMin;        metrics->horiBearingY = cbox.yMax;      }    }    return error;  }

void TtfFont::PlotString(const std::string &str,                         SBezierList *sbl, Vector origin, Vector u, Vector v){    ssassert(fontFace != NULL, "Expected font face to be loaded");    FT_Pos dx = 0;    for(char32_t chr : ReadUTF8(str)) {        uint32_t gid = FT_Get_Char_Index(fontFace, chr);        if (gid == 0) {            dbp("freetype: CID-to-GID mapping for CID 0x%04x failed: %s; using CID as GID",                chr, ft_error_string(gid));        }        FT_F26Dot6 scale = fontFace->units_per_EM;        if(int fterr = FT_Set_Char_Size(fontFace, scale, scale, 72, 72)) {            dbp("freetype: cannot set character size: %s",                ft_error_string(fterr));            return;        }        /*         * Stupid hacks:         *  - if we want fake-bold, use FT_Outline_Embolden(). This actually looks         *    quite good.         *  - if we want fake-italic, apply a shear transform [1 s s 1 0 0] here using         *    FT_Set_Transform. This looks decent at small font sizes and bad at larger         *    ones, antialiasing mitigates this considerably though.         */        if(int fterr = FT_Load_Glyph(fontFace, gid, FT_LOAD_NO_BITMAP | FT_LOAD_NO_HINTING)) {            dbp("freetype: cannot load glyph (gid %d): %s",                gid, ft_error_string(fterr));            return;        }        /* A point that has x = xMin should be plotted at (dx0 + lsb); fix up         * our x-position so that the curve-generating code will put stuff         * at the right place.         *         * There's no point in getting the glyph BBox here - not only can it be         * needlessly slow sometimes, but because we're about to render a single glyph,         * what we want actually *is* the CBox.         *         * This is notwithstanding that this makes extremely little sense, this         * looks like a workaround for either mishandling the start glyph on a line,         * or as a really hacky pseudo-track-kerning (in which case it works better than         * one would expect! especially since most fonts don't set track kerning).         */        FT_BBox cbox;        FT_Outline_Get_CBox(&fontFace->glyph->outline, &cbox);        FT_Pos bx = dx - cbox.xMin;        // Yes, this is what FreeType calls left-side bearing.        // Then interchangeably uses that with "left-side bearing". Sigh.        bx += fontFace->glyph->metrics.horiBearingX;        OutlineData data = {};        data.origin  = origin;        data.u       = u;        data.v       = v;        data.beziers = sbl;        data.factor  = 1.0f/(float)scale;        data.bx      = bx;        if(int fterr = FT_Outline_Decompose(&fontFace->glyph->outline, &outline_funcs, &data)) {            dbp("freetype: bezier decomposition failed (gid %d): %s",                gid, ft_error_string(fterr));        }        // And we're done, so advance our position by the requested advance        // width, plus the user-requested extra advance.        dx += fontFace->glyph->advance.x;    }}

	GlyphData* getGlyphData(Font font, const unsigned int glyphIndex)	{		GlyphMap::iterator	it = font->mGlyphs.find(glyphIndex);		GlyphData*			tempGlyph = (it!= font->mGlyphs.end())?&it->second:0;		if (NULL==tempGlyph)		{			FT_Error		err = FT_Load_Glyph(font->ftFace, glyphIndex, FT_LOAD_NO_HINTING);			FT_GlyphSlot	ftGlyph = font->ftFace->glyph;			if (!err && ftGlyph)			{				err = FT_Render_Glyph(ftGlyph, FT_RENDER_MODE_NORMAL);				if (!err && ftGlyph->format == FT_GLYPH_FORMAT_BITMAP)				{					if (font->textureIDList.empty())					{						font->textureIDList.push_back(createTexture());						font->xOffset = font->yOffset = font->padding;					}					if (font->xOffset > (TEXTURE_WIDTH-font->glyphWidth))					{						font->xOffset = font->padding;						font->yOffset += font->glyphHeight;						if (font->yOffset > (TEXTURE_HEIGHT - font->glyphHeight))						{							font->textureIDList.push_back(createTexture());							font->yOffset = font->padding;						}					}					tempGlyph = &font->mGlyphs[glyphIndex];					tempGlyph->glTextureID = font->textureIDList.back();					FT_BBox bbox;					FT_Outline_Get_CBox(&(ftGlyph->outline), &bbox);					tempGlyph->xmin = (float)(bbox.xMin)/64.0f;					tempGlyph->ymin = (float)(bbox.yMin)/64.0f;					tempGlyph->xmax = (float)(bbox.xMax)/64.0f;					tempGlyph->ymax = (float)(bbox.yMax)/64.0f;					tempGlyph->xadvance = ftGlyph->advance.x/64.0f;					tempGlyph->yadvance = ftGlyph->advance.y/64.0f;					FT_Bitmap	bitmap = ftGlyph->bitmap;					tempGlyph->width  = bitmap.width;					tempGlyph->height = bitmap.rows;					if( tempGlyph->width && tempGlyph->height)					{						glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);						glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);						glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);						glPixelStorei(GL_UNPACK_ALIGNMENT, 1);						glBindTexture(GL_TEXTURE_2D, tempGlyph->glTextureID);						glTexSubImage2D(							GL_TEXTURE_2D, 0,							font->xOffset, font->yOffset,							tempGlyph->width, tempGlyph->height,							GL_ALPHA, GL_UNSIGNED_BYTE,							bitmap.buffer						);						glPopClientAttrib();					}					tempGlyph->u0 = (float)(font->xOffset)/(float)(TEXTURE_WIDTH);					tempGlyph->v0 = (float)(font->yOffset)/(float)(TEXTURE_HEIGHT);					tempGlyph->u1 = (float)(font->xOffset+tempGlyph->width) / (float)(TEXTURE_WIDTH);					tempGlyph->v1 = (float)(font->yOffset+tempGlyph->height) / (float)(TEXTURE_HEIGHT);					tempGlyph->xoffset = (float)ftGlyph->bitmap_left;					tempGlyph->yoffset = (float)ftGlyph->bitmap_top;					font->xOffset += tempGlyph->xmax - tempGlyph->xmin + font->padding;				}			}		}		return tempGlyph;	}

//.........这里部分代码省略.........          slot->lsb_delta = loader->pp1.x - pp1x;          slot->rsb_delta = loader->pp2.x - pp2x;        }      }      /* `light' mode uses integer advance widths */      /* but sets `lsb_delta' and `rsb_delta'     */      else      {        FT_Pos  pp1x = loader->pp1.x;        FT_Pos  pp2x = loader->pp2.x;        loader->pp1.x = FT_PIX_ROUND( pp1x );        loader->pp2.x = FT_PIX_ROUND( pp2x );        slot->lsb_delta = loader->pp1.x - pp1x;        slot->rsb_delta = loader->pp2.x - pp2x;      }      break;    default:      /* we don't support other formats (yet?) */      error = FT_THROW( Unimplemented_Feature );    }  Hint_Metrics:    {      FT_BBox    bbox;      FT_Vector  vvector;      vvector.x = slot->metrics.vertBearingX - slot->metrics.horiBearingX;      vvector.y = slot->metrics.vertBearingY - slot->metrics.horiBearingY;      vvector.x = FT_MulFix( vvector.x, style_metrics->scaler.x_scale );      vvector.y = FT_MulFix( vvector.y, style_metrics->scaler.y_scale );      /* transform the hinted outline if needed */      if ( loader->transformed )      {        FT_Outline_Transform( &gloader->base.outline, &loader->trans_matrix );        FT_Vector_Transform( &vvector, &loader->trans_matrix );      }      /* we must translate our final outline by -pp1.x and compute */      /* the new metrics                                           */      if ( loader->pp1.x )        FT_Outline_Translate( &gloader->base.outline, -loader->pp1.x, 0 );      FT_Outline_Get_CBox( &gloader->base.outline, &bbox );      bbox.xMin = FT_PIX_FLOOR( bbox.xMin );      bbox.yMin = FT_PIX_FLOOR( bbox.yMin );      bbox.xMax = FT_PIX_CEIL(  bbox.xMax );      bbox.yMax = FT_PIX_CEIL(  bbox.yMax );      slot->metrics.width        = bbox.xMax - bbox.xMin;      slot->metrics.height       = bbox.yMax - bbox.yMin;      slot->metrics.horiBearingX = bbox.xMin;      slot->metrics.horiBearingY = bbox.yMax;      slot->metrics.vertBearingX = FT_PIX_FLOOR( bbox.xMin + vvector.x );      slot->metrics.vertBearingY = FT_PIX_FLOOR( bbox.yMax + vvector.y );      /* for mono-width fonts (like Andale, Courier, etc.) we need */      /* to keep the original rounded advance width; ditto for     */      /* digits if all have the same advance width                 */      if ( scaler.render_mode != FT_RENDER_MODE_LIGHT                       &&           ( FT_IS_FIXED_WIDTH( slot->face )                              ||             ( af_face_globals_is_digit( loader->globals, glyph_index ) &&               style_metrics->digits_have_same_width                    ) ) )      {        slot->metrics.horiAdvance =          FT_MulFix( slot->metrics.horiAdvance,                     style_metrics->scaler.x_scale );        /* Set delta values to 0.  Otherwise code that uses them is */        /* going to ruin the fixed advance width.                   */        slot->lsb_delta = 0;        slot->rsb_delta = 0;      }      else      {        /* non-spacing glyphs must stay as-is */        if ( slot->metrics.horiAdvance )          slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;      }      slot->metrics.vertAdvance = FT_MulFix( slot->metrics.vertAdvance,                                             style_metrics->scaler.y_scale );      slot->metrics.horiAdvance = FT_PIX_ROUND( slot->metrics.horiAdvance );      slot->metrics.vertAdvance = FT_PIX_ROUND( slot->metrics.vertAdvance );      slot->format  = FT_GLYPH_FORMAT_OUTLINE;    }  Exit:    return error;  }

GlyphBLF *blf_glyph_add(FontBLF *font, unsigned int index, unsigned int c){	FT_GlyphSlot slot;	GlyphBLF *g;	FT_Error err;	FT_Bitmap bitmap, tempbitmap;	const bool is_sharp = (U.text_render & USER_TEXT_DISABLE_AA) != 0;	int flags = FT_LOAD_TARGET_NORMAL | FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;	FT_BBox bbox;	unsigned int key;	g = blf_glyph_search(font->glyph_cache, c);	if (g)		return g;	/* glyphs are dynamically created as needed by font rendering. this means that	 * to make font rendering thread safe we have to do locking here. note that this	 * must be a lock for the whole library and not just per font, because the font	 * renderer uses a shared buffer internally */	BLI_spin_lock(font->ft_lib_mutex);	/* search again after locking */	g = blf_glyph_search(font->glyph_cache, c);	if (g) {		BLI_spin_unlock(font->ft_lib_mutex);		return g;	}	if (font->flags & BLF_HINTING)		flags &= ~FT_LOAD_NO_HINTING;		if (is_sharp)		err = FT_Load_Glyph(font->face, (FT_UInt)index, FT_LOAD_TARGET_MONO);	else		err = FT_Load_Glyph(font->face, (FT_UInt)index, flags);  	if (err) {		BLI_spin_unlock(font->ft_lib_mutex);		return NULL;	}	/* get the glyph. */	slot = font->face->glyph;	if (is_sharp) {		err = FT_Render_Glyph(slot, FT_RENDER_MODE_MONO);		/* Convert result from 1 bit per pixel to 8 bit per pixel */		/* Accum errors for later, fine if not interested beyond "ok vs any error" */		FT_Bitmap_New(&tempbitmap);		err += FT_Bitmap_Convert(font->ft_lib, &slot->bitmap, &tempbitmap, 1); /* Does Blender use Pitch 1 always? It works so far */		err += FT_Bitmap_Copy(font->ft_lib, &tempbitmap, &slot->bitmap);		err += FT_Bitmap_Done(font->ft_lib, &tempbitmap);	}	else {		err = FT_Render_Glyph(slot, FT_RENDER_MODE_NORMAL);	}	if (err || slot->format != FT_GLYPH_FORMAT_BITMAP) {		BLI_spin_unlock(font->ft_lib_mutex);		return NULL;	}	g = (GlyphBLF *)MEM_callocN(sizeof(GlyphBLF), "blf_glyph_add");	g->c = c;	g->idx = (FT_UInt)index;	g->xoff = -1;	g->yoff = -1;	bitmap = slot->bitmap;	g->width = (int)bitmap.width;	g->height = (int)bitmap.rows;	if (g->width && g->height) {		if (is_sharp) {			/* Font buffer uses only 0 or 1 values, Blender expects full 0..255 range */			int i;			for (i = 0; i < (g->width * g->height); i++) {				bitmap.buffer[i] = bitmap.buffer[i] ? 255 : 0;			}		}		g->bitmap = (unsigned char *)MEM_mallocN((size_t)(g->width * g->height), "glyph bitmap");		memcpy((void *)g->bitmap, (void *)bitmap.buffer, (size_t)(g->width * g->height));	}	g->advance = ((float)slot->advance.x) / 64.0f;	g->advance_i = (int)g->advance;	g->pos_x = (float)slot->bitmap_left;	g->pos_y = (float)slot->bitmap_top;	g->pitch = slot->bitmap.pitch;	FT_Outline_Get_CBox(&(slot->outline), &bbox);	g->box.xmin = ((float)bbox.xMin) / 64.0f;	g->box.xmax = ((float)bbox.xMax) / 64.0f;	g->box.ymin = ((float)bbox.yMin) / 64.0f;	g->box.ymax = ((float)bbox.yMax) / 64.0f;	key = blf_hash(g->c);	BLI_addhead(&(font->glyph_cache->bucket[key]), g);//.........这里部分代码省略.........

//.........这里部分代码省略.........        internal->glyph_matrix      = font_matrix;        internal->glyph_delta       = font_offset;        internal->glyph_transformed = 1;      }      else      {        FT_BBox            cbox;        FT_Glyph_Metrics*  metrics = &t1glyph->metrics;        /* copy the _unscaled_ advance width */        metrics->horiAdvance =          FIXED_TO_INT( decoder.builder.advance.x );        t1glyph->linearHoriAdvance =          FIXED_TO_INT( decoder.builder.advance.x );        t1glyph->internal->glyph_transformed = 0;        if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )        {          /* make up vertical ones */          metrics->vertAdvance = ( face->type1.font_bbox.yMax -                                   face->type1.font_bbox.yMin ) >> 16;          t1glyph->linearVertAdvance = metrics->vertAdvance;        }        else        {          metrics->vertAdvance =            FIXED_TO_INT( decoder.builder.advance.y );          t1glyph->linearVertAdvance =            FIXED_TO_INT( decoder.builder.advance.y );        }        t1glyph->format = FT_GLYPH_FORMAT_OUTLINE;        if ( t1size && t1size->metrics.y_ppem < 24 )          t1glyph->outline.flags |= FT_OUTLINE_HIGH_PRECISION;#if 1        /* apply the font matrix, if any */        if ( font_matrix.xx != 0x10000L || font_matrix.yy != 0x10000L ||             font_matrix.xy != 0        || font_matrix.yx != 0        )        {          FT_Outline_Transform( &t1glyph->outline, &font_matrix );          metrics->horiAdvance = FT_MulFix( metrics->horiAdvance,                                            font_matrix.xx );          metrics->vertAdvance = FT_MulFix( metrics->vertAdvance,                                            font_matrix.yy );        }        if ( font_offset.x || font_offset.y )        {          FT_Outline_Translate( &t1glyph->outline,                                font_offset.x,                                font_offset.y );          metrics->horiAdvance += font_offset.x;          metrics->vertAdvance += font_offset.y;        }#endif        if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 || force_scaling )        {          /* scale the outline and the metrics */          FT_Int       n;          FT_Outline*  cur = decoder.builder.base;          FT_Vector*   vec = cur->points;          FT_Fixed     x_scale = glyph->x_scale;          FT_Fixed     y_scale = glyph->y_scale;          /* First of all, scale the points, if we are not hinting */          if ( !hinting || ! decoder.builder.hints_funcs )            for ( n = cur->n_points; n > 0; n--, vec++ )            {              vec->x = FT_MulFix( vec->x, x_scale );              vec->y = FT_MulFix( vec->y, y_scale );            }          /* Then scale the metrics */          metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );          metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );        }        /* compute the other metrics */        FT_Outline_Get_CBox( &t1glyph->outline, &cbox );        metrics->width  = cbox.xMax - cbox.xMin;        metrics->height = cbox.yMax - cbox.yMin;        metrics->horiBearingX = cbox.xMin;        metrics->horiBearingY = cbox.yMax;        if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )        {          /* make up vertical ones */          ft_synthesize_vertical_metrics( metrics,                                          metrics->vertAdvance );        }      }

/* * Class:     FreetypeFont * Method:    loadGlyph0 * Signature: (JI)V */JNIEXPORT void JNICALL Java_sage_FreetypeFont_loadGlyph0  (JNIEnv *env, jobject jo, jlong fontPtr, jint glyphCode){	//FT_Face face = (FT_Face) facePtr;	FTDataStruct* fontData = (FTDataStruct*)(intptr_t) fontPtr;	FT_Activate_Size(fontData->sizePtr);	int error = FT_Load_Glyph(fontData->facePtr, glyphCode, FT_LOAD_FORCE_AUTOHINT);	if ((fontData->style & FT_STYLE_FLAG_BOLD) != 0)	{		// Apply bold effect		if (fontData->facePtr->glyph->format == FT_GLYPH_FORMAT_OUTLINE)		{			/* some reasonable strength */			FT_Pos strength = FT_MulFix(fontData->facePtr->units_per_EM,				fontData->facePtr->size->metrics.y_scale ) / 42;			FT_BBox bbox_before, bbox_after;			// The bounding box code was what XBMC was using to do this calculation; but the			// examples in the freetype library use the *4 math below which then doesn't clip			// the text when we render it.//			FT_Outline_Get_CBox(&fontData->facePtr->glyph->outline, &bbox_before);			FT_Outline_Embolden(&fontData->facePtr->glyph->outline, strength);  // ignore error//			FT_Outline_Get_CBox(&fontData->facePtr->glyph->outline, &bbox_after);//			FT_Pos dx = bbox_after.xMax - bbox_before.xMax;//			FT_Pos dy = bbox_after.yMax - bbox_before.yMax;FT_Pos dx = strength * 4;FT_Pos dy = dx;			if (fontData->facePtr->glyph->advance.x)				fontData->facePtr->glyph->advance.x += dx;			if (fontData->facePtr->glyph->advance.y)				fontData->facePtr->glyph->advance.y += dy;			fontData->facePtr->glyph->metrics.width        += dx;			fontData->facePtr->glyph->metrics.height       += dy;			fontData->facePtr->glyph->metrics.horiBearingY += dy;			fontData->facePtr->glyph->metrics.horiAdvance  += dx;			fontData->facePtr->glyph->metrics.vertBearingX -= dx / 2;			fontData->facePtr->glyph->metrics.vertBearingY += dy;			fontData->facePtr->glyph->metrics.vertAdvance  += dy;		}	}	if ((fontData->style & FT_STYLE_FLAG_ITALIC) != 0)	{		// Apply italics effect		if (fontData->facePtr->glyph->format == FT_GLYPH_FORMAT_OUTLINE)		{			/* For italic, simply apply a shear transform, with an angle */			/* of about 12 degrees.                                      */			FT_Matrix    transform;			transform.xx = 0x10000L;			transform.yx = 0x00000L;			transform.xy = 0x06000L;			transform.yy = 0x10000L;			FT_BBox bbox_before, bbox_after;			FT_Outline_Get_CBox(&fontData->facePtr->glyph->outline, &bbox_before);			FT_Outline_Transform(&fontData->facePtr->glyph->outline, &transform);			FT_Outline_Get_CBox(&fontData->facePtr->glyph->outline, &bbox_after);			FT_Pos dx = bbox_after.xMax - bbox_before.xMax;			FT_Pos dy = bbox_after.yMax - bbox_before.yMax;			fontData->facePtr->glyph->metrics.width        += dx;			fontData->facePtr->glyph->metrics.height       += dy;		}	}}