| /***************************************************************************/ |
| /* */ |
| /* ftglyph.c */ |
| /* */ |
| /* FreeType convenience functions to handle glyphs.. */ |
| /* */ |
| /* Copyright 1996-1999 by */ |
| /* David Turner, Robert Wilhelm, and Werner Lemberg. */ |
| /* */ |
| /* This file is part of the FreeType project, and may only be used */ |
| /* modified and distributed under the terms of the FreeType project */ |
| /* license, LICENSE.TXT. By continuing to use, modify, or distribute */ |
| /* this file you indicate that you have read the license and */ |
| /* understand and accept it fully. */ |
| /* */ |
| /* This file contains the definition of several convenience functions */ |
| /* that can be used by client applications to easily retrieve glyph */ |
| /* bitmaps and outlines from a given face. */ |
| /* */ |
| /* These functions should be optional if you're writing a font server */ |
| /* or text layout engine on top of FreeType. However, they are pretty */ |
| /* handy for many other simple uses of the library.. */ |
| /* */ |
| /***************************************************************************/ |
| |
| #include <freetype/ftglyph.h> |
| #include <freetype/internal/ftobjs.h> |
| |
| static |
| void ft_prepare_glyph( FT_Glyph glyph, |
| FT_Face face, |
| FT_Bool vertical ) |
| { |
| FT_Glyph_Metrics* metrics = &face->glyph->metrics; |
| |
| glyph->memory = face->memory; |
| glyph->width = metrics->width; |
| glyph->height = metrics->height; |
| |
| if (vertical) |
| { |
| glyph->bearingX = metrics->vertBearingX; |
| glyph->bearingY = metrics->vertBearingY; |
| glyph->advance = metrics->vertAdvance; |
| } |
| else |
| { |
| glyph->bearingX = metrics->horiBearingX; |
| glyph->bearingY = metrics->horiBearingY; |
| glyph->advance = metrics->horiAdvance; |
| } |
| } |
| |
| /*********************************************************************** |
| * |
| * <Function> |
| * FT_Get_Glyph_Bitmap |
| * |
| * <Description> |
| * A function used to directly return a monochrome bitmap glyph image |
| * from a face. |
| * |
| * <Input> |
| * face :: handle to source face object |
| * glyph_index :: glyph index in face |
| * load_flags :: load flags, see FT_LOAD_FLAG_XXXX constants.. |
| * grays :: number of gray levels for anti-aliased bitmaps, |
| * set to 0 if you want to render a monochrome bitmap |
| * origin :: a pointer to the origin's position. Set to 0 |
| * if the current transform is the identity.. |
| * |
| * <Output> |
| * bitglyph :: pointer to the new bitmap glyph |
| * |
| * <Return> |
| * Error code. 0 means success. |
| * |
| * <Note> |
| * If the font contains glyph outlines, these will be automatically |
| * converted to a bitmap according to the value of "grays" |
| * |
| * If "grays" is set to 0, the result is a 1-bit monochrome bitmap |
| * otherwise, it is an 8-bit gray-level bitmap |
| * |
| * The number of gray levels in the result anti-aliased bitmap might |
| * not be "grays", depending on the current scan-converter implementation |
| * |
| * Note that it is not possible to generate 8-bit monochrome bitmaps |
| * with this function. Rather, use FT_Get_Glyph_Outline, then |
| * FT_Glyph_Render_Outline and provide your own span callbacks.. |
| * |
| * When the face doesn't contain scalable outlines, this function will |
| * fail if the current transform is not the identity, or if the glyph |
| * origin's phase to the pixel grid is not 0 in both directions !! |
| * |
| ***********************************************************************/ |
| |
| EXPORT_FUNC(FT_Error) FT_Get_Glyph_Bitmap( FT_Face face, |
| FT_UInt glyph_index, |
| FT_UInt load_flags, |
| FT_Int grays, |
| FT_Vector* origin, |
| FT_BitmapGlyph *abitglyph ) |
| { |
| FT_Error error; |
| FT_Memory memory; |
| FT_BitmapGlyph bitglyph; |
| FT_Glyph glyph; |
| FT_Pos origin_x = 0; |
| FT_Pos origin_y = 0; |
| |
| *abitglyph = 0; |
| |
| if (origin) |
| { |
| origin_x = origin->x & 63; |
| origin_y = origin->y & 63; |
| } |
| |
| /* check arguments if the face's format is not scalable */ |
| if ( !(face->face_flags & FT_FACE_FLAG_SCALABLE) && face->transform_flags ) |
| { |
| /* we can't transform bitmaps, so return an error */ |
| error = FT_Err_Unimplemented_Feature; |
| goto Exit; |
| } |
| |
| /* check that NO_SCALE and NO_RECURSE are not set */ |
| if (load_flags & (FT_LOAD_NO_SCALE|FT_LOAD_NO_RECURSE)) |
| { |
| error = FT_Err_Invalid_Argument; |
| goto Exit; |
| } |
| |
| /* disable embedded bitmaps for transformed images */ |
| if ( face->face_flags & FT_FACE_FLAG_SCALABLE && face->transform_flags ) |
| load_flags |= FT_LOAD_NO_BITMAP; |
| |
| error = FT_Load_Glyph( face, glyph_index, load_flags ); |
| if (error) goto Exit; |
| |
| /* now, handle bitmap and outline glyph images */ |
| memory = face->memory; |
| switch ( face->glyph->format ) |
| { |
| case ft_glyph_format_bitmap: |
| { |
| FT_Long size; |
| FT_Bitmap* source; |
| |
| if ( ALLOC( bitglyph, sizeof(*bitglyph) ) ) |
| goto Exit; |
| |
| glyph = (FT_Glyph)bitglyph; |
| glyph->glyph_type = ft_glyph_type_bitmap; |
| ft_prepare_glyph( glyph, face, 0 ); |
| |
| source = &face->glyph->bitmap; |
| size = source->rows * source->pitch; |
| if (size < 0) size = -size; |
| |
| bitglyph->bitmap = *source; |
| if ( ALLOC( bitglyph->bitmap.buffer, size ) ) |
| goto Fail; |
| |
| /* copy the content of the source glyph */ |
| MEM_Copy( bitglyph->bitmap.buffer, source->buffer, size ); |
| } |
| break; |
| |
| case ft_glyph_format_outline: |
| { |
| FT_BBox cbox; |
| FT_Int width, height, pitch; |
| FT_Long size; |
| |
| /* transform the outline - note that the original metrics are NOT */ |
| /* transformed by this.. only the outline points themselves.. */ |
| FT_Outline_Transform( &face->glyph->outline, &face->transform_matrix ); |
| FT_Outline_Translate( &face->glyph->outline, |
| face->transform_delta.x + origin_x, |
| face->transform_delta.y + origin_y ); |
| |
| /* compute the size in pixels of the outline */ |
| FT_Outline_Get_CBox( &face->glyph->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; |
| |
| /* allocate the pixel buffer for the glyph bitmap */ |
| if (grays) pitch = (width+3) & -4; /* some raster implementation need this */ |
| else pitch = (width+7) >> 3; |
| |
| size = pitch * height; |
| if ( ALLOC( bitglyph, sizeof(*bitglyph) ) ) |
| goto Exit; |
| |
| glyph = (FT_Glyph)bitglyph; |
| glyph->glyph_type = ft_glyph_type_bitmap; |
| ft_prepare_glyph( glyph, face, 0 ); |
| |
| if ( ALLOC( bitglyph->bitmap.buffer, size ) ) |
| goto Fail; |
| |
| bitglyph->bitmap.width = width; |
| bitglyph->bitmap.rows = height; |
| bitglyph->bitmap.pitch = pitch; |
| bitglyph->bitmap.pixel_mode = grays ? ft_pixel_mode_grays |
| : ft_pixel_mode_mono; |
| bitglyph->bitmap.num_grays = (short)grays; |
| |
| bitglyph->left = (cbox.xMin >> 6); |
| bitglyph->top = (cbox.yMax >> 6); |
| |
| /* render the monochrome outline into the target buffer */ |
| FT_Outline_Translate( &face->glyph->outline, -cbox.xMin, -cbox.yMin ); |
| error = FT_Outline_Get_Bitmap( face->driver->library, |
| &face->glyph->outline, |
| &bitglyph->bitmap ); |
| if (error) |
| { |
| FREE( bitglyph->bitmap.buffer ); |
| goto Fail; |
| } |
| } |
| break; |
| |
| default: |
| error = FT_Err_Invalid_Glyph_Index; |
| goto Exit; |
| } |
| |
| *abitglyph = bitglyph; |
| Exit: |
| return error; |
| |
| Fail: |
| FREE( glyph ); |
| goto Exit; |
| } |
| |
| |
| /*********************************************************************** |
| * |
| * <Function> |
| * FT_Get_Glyph_Outline |
| * |
| * <Description> |
| * A function used to directly return a bitmap glyph image from a |
| * face. This is faster than calling FT_Load_Glyph+FT_Get_Outline_Bitmap.. |
| * |
| * <Input> |
| * face :: handle to source face object |
| * glyph_index :: glyph index in face |
| * load_flags :: load flags, see FT_LOAD_FLAG_XXXX constants.. |
| * |
| * <Output> |
| * vecglyph :: pointer to the new outline glyph |
| * |
| * <Return> |
| * Error code. 0 means success. |
| * |
| * <Note> |
| * This function will fail if the load flags FT_LOAD_NO_OUTLINE and |
| * FT_LOAD_NO_RECURSE are set.. |
| * |
| ***********************************************************************/ |
| |
| EXPORT_FUNC(FT_Error) FT_Get_Glyph_Outline( FT_Face face, |
| FT_UInt glyph_index, |
| FT_UInt load_flags, |
| FT_OutlineGlyph *vecglyph ) |
| { |
| FT_Error error; |
| FT_Memory memory; |
| FT_OutlineGlyph glyph; |
| |
| *vecglyph = 0; |
| |
| /* check that NO_OUTLINE and NO_RECURSE are not set */ |
| if (load_flags & (FT_LOAD_NO_OUTLINE|FT_LOAD_NO_RECURSE)) |
| { |
| error = FT_Err_Invalid_Argument; |
| goto Exit; |
| } |
| |
| /* disable the loading of embedded bitmaps */ |
| load_flags |= FT_LOAD_NO_BITMAP; |
| |
| error = FT_Load_Glyph( face, glyph_index, load_flags ); |
| if (error) goto Exit; |
| |
| /* check that we really loaded an outline */ |
| if ( face->glyph->format != ft_glyph_format_outline ) |
| { |
| error = FT_Err_Invalid_Glyph_Index; |
| goto Exit; |
| } |
| |
| /* transform the outline - note that the original metrics are NOT */ |
| /* transformed by this.. only the outline points themselves.. */ |
| if ( face->transform_flags ) |
| { |
| FT_Outline_Transform( &face->glyph->outline, &face->transform_matrix ); |
| FT_Outline_Translate( &face->glyph->outline, |
| face->transform_delta.x, |
| face->transform_delta.y ); |
| } |
| |
| /* now, create a new outline glyph and copy everything there */ |
| memory = face->memory; |
| if ( ALLOC( glyph, sizeof(*glyph) ) ) |
| goto Exit; |
| |
| ft_prepare_glyph( (FT_Glyph)glyph, face, 0 ); |
| glyph->metrics.glyph_type = ft_glyph_type_outline; |
| |
| error = FT_Outline_New( face->driver->library, |
| face->glyph->outline.n_points, |
| face->glyph->outline.n_contours, |
| &glyph->outline ); |
| if (!error) |
| error = FT_Outline_Copy( &face->glyph->outline, &glyph->outline ); |
| |
| if (error) goto Fail; |
| |
| *vecglyph = glyph; |
| Exit: |
| return error; |
| |
| Fail: |
| FREE( glyph ); |
| goto Exit; |
| } |
| |
| /*********************************************************************** |
| * |
| * <Function> |
| * FT_Set_Transform |
| * |
| * <Description> |
| * A function used to set the transform that is applied to glyph images |
| * just after they're loaded in the face's glyph slot, and before they're |
| * returned by either FT_Get_Glyph_Bitmap or FT_Get_Glyph_Outline |
| * |
| * <Input> |
| * face :: handle to source face object |
| * matrix :: pointer to the transform's 2x2 matrix. 0 for identity |
| * delta :: pointer to the transform's translation. 0 for null vector |
| * |
| * <Note> |
| * The transform is only applied to glyph outlines when they are found |
| * in a font face. It is unable to transform embedded glyph bitmaps |
| * |
| ***********************************************************************/ |
| |
| EXPORT_FUNC(void) FT_Set_Transform( FT_Face face, |
| FT_Matrix* matrix, |
| FT_Vector* delta ) |
| { |
| face->transform_flags = 0; |
| |
| if (!matrix) |
| { |
| face->transform_matrix.xx = 0x10000L; |
| face->transform_matrix.xy = 0; |
| face->transform_matrix.yx = 0L; |
| face->transform_matrix.yy = 0x10000L; |
| matrix = &face->transform_matrix; |
| } |
| else |
| face->transform_matrix = *matrix; |
| |
| /* set transform_flags bit flag 0 if delta isn't the null vector */ |
| if ( (matrix->xy | matrix->yx) || |
| matrix->xx != 0x10000L || |
| matrix->yy != 0x10000L ) |
| face->transform_flags |= 1; |
| |
| if (!delta) |
| { |
| face->transform_delta.x = 0; |
| face->transform_delta.y = 0; |
| delta = &face->transform_delta; |
| } |
| else |
| face->transform_delta = *delta; |
| |
| /* set transform_flags bit flag 1 if delta isn't the null vector */ |
| if ( delta->x | delta->y ) |
| face->transform_flags |= 2; |
| } |
| |
| /*********************************************************************** |
| * |
| * <Function> |
| * FT_Done_Glyph |
| * |
| * <Description> |
| * Destroys a given glyph.. |
| * |
| * <Input> |
| * glyph :: handle to target glyph object |
| * |
| ***********************************************************************/ |
| |
| EXPORT_FUNC(void) FT_Done_Glyph( FT_Glyph glyph ) |
| { |
| if (glyph) |
| { |
| FT_Memory memory = glyph->memory; |
| |
| if ( glyph->glyph_type == ft_glyph_type_bitmap ) |
| { |
| FT_BitmapGlyph bit = (FT_BitmapGlyph)glyph; |
| FREE( bit->bitmap.buffer ); |
| } |
| else if ( glyph->glyph_type == ft_glyph_type_outline ) |
| { |
| FT_OutlineGlyph out = (FT_OutlineGlyph)glyph; |
| if (out->outline.flags & ft_outline_owner) |
| { |
| FREE( out->outline.points ); |
| FREE( out->outline.contours ); |
| FREE( out->outline.tags ); |
| } |
| } |
| |
| FREE( glyph ); |
| } |
| } |
| |
| |
| /*********************************************************************** |
| * |
| * <Function> |
| * FT_Glyph_Get_Box |
| * |
| * <Description> |
| * Returns the glyph image's bounding box in pixels. |
| * |
| * <Input> |
| * glyph :: handle to target glyph object |
| * |
| * <Output> |
| * box :: the glyph bounding box. Coordinates are expressed in |
| * _integer_ pixels, with exclusive max bounds |
| * |
| * <Note> |
| * Coordinates are relative to the glyph origin, using the Y-upwards |
| * convention.. |
| * |
| * The width of the box in pixels is box.xMax-box.xMin |
| * The height is box.yMax - box.yMin |
| * |
| ***********************************************************************/ |
| |
| EXPORT_FUNC(void) FT_Glyph_Get_Box( FT_Glyph glyph, |
| FT_BBox *box ) |
| { |
| box->xMin = box->xMax = 0; |
| box->yMin = box->yMax = 0; |
| |
| if (glyph) switch (glyph->glyph_type) |
| { |
| case ft_glyph_type_bitmap: |
| { |
| FT_BitmapGlyph bit = (FT_BitmapGlyph)glyph; |
| box->xMin = bit->left; |
| box->xMax = box->xMin + bit->bitmap.width; |
| box->yMax = bit->top; |
| box->yMin = box->yMax - bit->bitmap.rows; |
| } |
| break; |
| |
| case ft_glyph_type_outline: |
| { |
| FT_OutlineGlyph out = (FT_OutlineGlyph)glyph; |
| |
| FT_Outline_Get_CBox( &out->outline, box ); |
| box->xMin >>= 6; |
| box->yMin >>= 6; |
| box->xMax = (box->xMax+63) >> 6; |
| box->yMax = (box->yMax+63) >> 6; |
| } |
| break; |
| |
| default: |
| ; |
| } |
| } |
| |
| |
| /***************************************************************************/ |
| /***************************************************************************/ |
| /**** ****/ |
| /**** EXPERIMENTAL EMBOLDENING/OUTLINING SUPPORT ****/ |
| /**** ****/ |
| /***************************************************************************/ |
| /***************************************************************************/ |
| |
| #if 0 |
| |
| /* Compute the norm of a vector */ |
| #ifdef FT_CONFIG_OPTION_OLD_CALCS |
| static |
| FT_Pos ft_norm( FT_Vector* vec ) |
| { |
| FT_Int64 t1, t2; |
| |
| MUL_64( vec->x, vec->x, t1 ); |
| MUL_64( vec->y, vec->y, t2 ); |
| ADD_64( t1, t2, t1 ); |
| return (FT_Pos)SQRT_64(t1); |
| } |
| #else |
| static |
| FT_Pos ft_norm( FT_Vector* vec ) |
| { |
| FT_F26Dot6 u, v, d; |
| FT_Int shift; |
| FT_ULong H, L, L2, hi, lo, med; |
| |
| u = vec->x; if (u < 0) u = -u; |
| v = vec->y; if (v < 0) v = -v; |
| |
| if (u < v) |
| { |
| d = u; |
| u = v; |
| v = d; |
| } |
| |
| /* check that we're not trying to normalise zero !! */ |
| if (u==0) return 0; |
| |
| /* compute (u*u+v*v) on 64 bits with two 32-bit registers [H:L] */ |
| hi = (FT_ULong)u >> 16; |
| lo = (FT_ULong)u & 0xFFFF; |
| med = hi*lo; |
| |
| H = hi*hi + (med >> 15); |
| med <<= 17; |
| L = lo*lo + med; |
| if (L < med) H++; |
| |
| hi = (FT_ULong)v >> 16; |
| lo = (FT_ULong)v & 0xFFFF; |
| med = hi*lo; |
| |
| H += hi*hi + (med >> 15); |
| med <<= 17; |
| L2 = lo*lo + med; |
| if (L2 < med) H++; |
| |
| L += L2; |
| if (L < L2) H++; |
| |
| /* if the value is smaller than 32-bits */ |
| shift = 0; |
| if (H == 0) |
| { |
| while ((L & 0xC0000000) == 0) |
| { |
| L <<= 2; |
| shift++; |
| } |
| return (FT_Sqrt32(L) >> shift); |
| } |
| else |
| { |
| while (H) |
| { |
| L = (L >> 2) | (H << 30); |
| H >>= 2; |
| shift++; |
| } |
| return (FT_Sqrt32(L) << shift); |
| } |
| } |
| #endif |
| |
| static |
| int ft_test_extrema( FT_Outline* outline, |
| int n ) |
| { |
| FT_Vector *prev, *cur, *next; |
| FT_Pos product; |
| FT_Int first, last; |
| |
| /* we need to compute the "previous" and "next" point */ |
| /* for this extrema.. */ |
| cur = outline->points + n; |
| prev = cur - 1; |
| next = cur + 1; |
| |
| first = 0; |
| for ( c = 0; c < outline->n_contours; c++ ) |
| { |
| last = outline->contours[c]; |
| |
| if ( n == first ) |
| prev = outline->points + last; |
| |
| if ( n == last ) |
| next = outline->points + first; |
| |
| first = last + 1; |
| } |
| |
| product = FT_MulDiv( cur->x - prev->x, /* in.x */ |
| next->y - cur->y, /* out.y */ |
| 0x40 ) - |
| |
| FT_MulDiv( cur->y - prev->y, /* in.y */ |
| next->x - cur->x, /* out.x */ |
| 0x40 ); |
| |
| if (product) |
| product = ( product > 0 ? 1 : -1 ); |
| |
| return product; |
| } |
| |
| |
| /* Compute the orientation of path filling. It differs between TrueType */ |
| /* and Type1 formats. We could use the 'ft_outline_reverse_fill' flag, */ |
| /* but it's better to re-compute it directly (it seems that this flag */ |
| /* isn't correctly set for some weird composite glyphs for now).. */ |
| /* */ |
| /* We do this by computing bounding box points, and computing their */ |
| /* curvature.. the function returns either 1 or -1 */ |
| /* */ |
| static |
| int ft_get_orientation( FT_Outline* outline ) |
| { |
| FT_BBox box; |
| FT_BBox indexes; |
| int n, last; |
| |
| indexes.xMin = -1; |
| indexes.yMin = -1; |
| indexes.xMax = -1; |
| indexes.yMax = -1; |
| |
| box.xMin = box.yMin = 32767; |
| box.xMax = box.yMax = -32768; |
| |
| /* is it empty ? */ |
| if ( outline->n_contours < 1 ) |
| return 1; |
| |
| last = outline->contours[outline->n_contours-1]; |
| |
| for ( n = 0; n <= last; n++ ) |
| { |
| FT_Pos x, y; |
| |
| x = outline->points[n].x; |
| if ( x < box.xMin ) |
| { |
| box.xMin = x; |
| indexes.xMin = n; |
| } |
| |
| if ( x > box.xMax ) |
| { |
| box.xMax = x; |
| indexes.xMax = n; |
| } |
| |
| y = outline->points[n].y; |
| if ( y < box.yMin ) |
| { |
| box.yMin = y; |
| indexes.yMin = n; |
| } |
| |
| if ( y > box.yMax ) |
| { |
| box.yMax = y; |
| indexes.yMax = n; |
| } |
| } |
| |
| /* test orientation of the xmin */ |
| return ft_test_extrema( outline, indexes.xMin ) || |
| ft_test_extrema( outline, indexes.yMin ) || |
| ft_test_extrema( outline, indexes.xMax ) || |
| ft_test_extrema( outline, indexes.yMax ) || |
| 1; /* this is an empty glyph ?? */ |
| } |
| |
| |
| static |
| FT_Error ft_embolden( FT_Face original, |
| FT_Outline* outline, |
| FT_Pos* advance ) |
| { |
| FT_Vector u, v; |
| FT_Vector* points; |
| FT_Vector cur, prev, next; |
| FT_Pos distance; |
| int c, n, first, orientation; |
| |
| (void)advance; |
| |
| /* compute control distance */ |
| distance = FT_MulFix( original->em_size/60, |
| original->size->metrics.y_scale ); |
| |
| orientation = ft_get_orientation( &original->glyph->outline ); |
| |
| points = original->glyph->outline.points; |
| |
| first = 0; |
| for ( c = 0; c < outline->n_contours; c++ ) |
| { |
| int last = outline->contours[c]; |
| |
| prev = points[last]; |
| |
| for ( n = first; n <= last; n++ ) |
| { |
| FT_Pos norme, delta, d; |
| FT_Vector in, out; |
| |
| cur = points[n]; |
| if ( n < last ) next = points[n+1]; |
| else next = points[first]; |
| |
| /* compute the in and out vectors */ |
| in.x = cur.x - prev.x; |
| in.y = cur.y - prev.y; |
| |
| out.x = next.x - cur.x; |
| out.y = next.y - cur.y; |
| |
| /* compute U and V */ |
| norme = ft_norm( &in ); |
| u.x = orientation * FT_DivFix( in.y, norme ); |
| u.y = orientation * - FT_DivFix( in.x, norme ); |
| |
| norme = ft_norm( &out ); |
| v.x = orientation * FT_DivFix( out.y, norme ); |
| v.y = orientation * - FT_DivFix( out.x, norme ); |
| |
| d = distance; |
| |
| if ( (outline->flags[n] & FT_Curve_Tag_On) == 0 ) |
| d *= 2; |
| |
| /* Check discriminant for parallel vectors */ |
| delta = FT_MulFix( u.x, v.y ) - FT_MulFix( u.y, v.x ); |
| if ( delta > FT_BOLD_THRESHOLD || delta < - FT_BOLD_THRESHOLD ) |
| { |
| /* Move point - compute A and B */ |
| FT_Pos x, y, A, B; |
| |
| A = d + FT_MulFix( cur.x, u.x ) + FT_MulFix( cur.y, u.y ); |
| B = d + FT_MulFix( cur.x, v.x ) + FT_MulFix( cur.y, v.y ); |
| |
| x = FT_MulFix( A, v.y ) - FT_MulFix( B, u.y ); |
| y = FT_MulFix( B, u.x ) - FT_MulFix( A, v.x ); |
| |
| outline->points[n].x = distance + FT_DivFix( x, delta ); |
| outline->points[n].y = distance + FT_DivFix( y, delta ); |
| } |
| else |
| { |
| /* Vectors are nearly parallel */ |
| FT_Pos x, y; |
| |
| x = distance + cur.x + FT_MulFix( d, u.x + v.x )/2; |
| y = distance + cur.y + FT_MulFix( d, u.y + v.y )/2; |
| |
| outline->points[n].x = x; |
| outline->points[n].y = y; |
| } |
| |
| prev = cur; |
| } |
| |
| first = last+1; |
| } |
| |
| if (advance) |
| *advance = (*advance + distance*4) & -64; |
| |
| return 0; |
| } |
| |
| #endif /* 0 - EXPERIMENTAL STUFF !! */ |