开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
ftoutln.c
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：27k
源码类别：

其他游戏

开发平台：

Visual C++

ftoutln.c：源码内容
  2. /***************************************************************************/
  3. /*                                                                         */
  4. /*  ftoutln.c                                                              */
  5. /*                                                                         */
  6. /*    FreeType outline management (body).                                  */
  7. /*                                                                         */
  8. /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
  9. /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
  10. /*                                                                         */
  11. /*  This file is part of the FreeType project, and may only be used,       */
  12. /*  modified, and distributed under the terms of the FreeType project      */
  13. /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  14. /*  this file you indicate that you have read the license and              */
  15. /*  understand and accept it fully.                                        */
  16. /*                                                                         */
  17. /***************************************************************************/
  20.   /*************************************************************************/
  21.   /*                                                                       */
  22.   /* All functions are declared in freetype.h.                             */
  23.   /*                                                                       */
  24.   /*************************************************************************/
  27. #include <ft2build.h>
  28. #include FT_OUTLINE_H
  29. #include FT_INTERNAL_OBJECTS_H
  30. #include FT_TRIGONOMETRY_H
  33.   /*************************************************************************/
  34.   /*                                                                       */
  35.   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  36.   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  37.   /* messages during execution.                                            */
  38.   /*                                                                       */
  39. #undef  FT_COMPONENT
  40. #define FT_COMPONENT  trace_outline
  43.   static
  44.   const FT_Outline  null_outline = { 0, 0, 0, 0, 0, 0 };
  47.   /* documentation is in ftoutln.h */
  49.   FT_EXPORT_DEF( FT_Error )
  50.   FT_Outline_Decompose( FT_Outline*              outline,
  51.                         const FT_Outline_Funcs*  func_interface,
  52.                         void*                    user )
  53.   {
  54. #undef SCALED
  55. #define SCALED( x )  ( ( (x) << shift ) - delta )
  57.     FT_Vector   v_last;
  58.     FT_Vector   v_control;
  59.     FT_Vector   v_start;
  61.     FT_Vector*  point;
  62.     FT_Vector*  limit;
  63.     char*       tags;
  65.     FT_Error    error;
  67.     FT_Int   n;         /* index of contour in outline     */
  68.     FT_UInt  first;     /* index of first point in contour */
  69.     FT_Int   tag;       /* current point's state           */
  71.     FT_Int   shift;
  72.     FT_Pos   delta;
  75.     if ( !outline || !func_interface )
  76.       return FT_Err_Invalid_Argument;
  78.     shift = func_interface->shift;
  79.     delta = func_interface->delta;
  80.     first = 0;
  82.     for ( n = 0; n < outline->n_contours; n++ )
  83.     {
  84.       FT_Int  last;  /* index of last point in contour */
  87.       last = outline->contours[n];
  88.       if ( last < 0 )
  89.         goto Invalid_Outline;
  90.       limit = outline->points + last;
  92.       v_start = outline->points[first];
  93.       v_last  = outline->points[last];
  95.       v_start.x = SCALED( v_start.x ); v_start.y = SCALED( v_start.y );
  96.       v_last.x  = SCALED( v_last.x );  v_last.y  = SCALED( v_last.y );
  98.       v_control = v_start;
  100.       point = outline->points + first;
  101.       tags  = outline->tags  + first;
  102.       tag   = FT_CURVE_TAG( tags[0] );
  104.       /* A contour cannot start with a cubic control point! */
  105.       if ( tag == FT_CURVE_TAG_CUBIC )
  106.         goto Invalid_Outline;
  108.       /* check first point to determine origin */
  109.       if ( tag == FT_CURVE_TAG_CONIC )
  110.       {
  111.         /* first point is conic control.  Yes, this happens. */
  112.         if ( FT_CURVE_TAG( outline->tags[last] ) == FT_CURVE_TAG_ON )
  113.         {
  114.           /* start at last point if it is on the curve */
  115.           v_start = v_last;
  116.           limit--;
  117.         }
  118.         else
  119.         {
  120.           /* if both first and last points are conic,         */
  121.           /* start at their middle and record its position    */
  122.           /* for closure                                      */
  123.           v_start.x = ( v_start.x + v_last.x ) / 2;
  124.           v_start.y = ( v_start.y + v_last.y ) / 2;
  126.           v_last = v_start;
  127.         }
  128.         point--;
  129.         tags--;
  130.       }
  132.       error = func_interface->move_to( &v_start, user );
  133.       if ( error )
  134.         goto Exit;
  136.       while ( point < limit )
  137.       {
  138.         point++;
  139.         tags++;
  141.         tag = FT_CURVE_TAG( tags[0] );
  142.         switch ( tag )
  143.         {
  144.         case FT_CURVE_TAG_ON:  /* emit a single line_to */
  145.           {
  146.             FT_Vector  vec;
  149.             vec.x = SCALED( point->x );
  150.             vec.y = SCALED( point->y );
  152.             error = func_interface->line_to( &vec, user );
  153.             if ( error )
  154.               goto Exit;
  155.             continue;
  156.           }
  158.         case FT_CURVE_TAG_CONIC:  /* consume conic arcs */
  159.           v_control.x = SCALED( point->x );
  160.           v_control.y = SCALED( point->y );
  162.         Do_Conic:
  163.           if ( point < limit )
  164.           {
  165.             FT_Vector  vec;
  166.             FT_Vector  v_middle;
  169.             point++;
  170.             tags++;
  171.             tag = FT_CURVE_TAG( tags[0] );
  173.             vec.x = SCALED( point->x );
  174.             vec.y = SCALED( point->y );
  176.             if ( tag == FT_CURVE_TAG_ON )
  177.             {
  178.               error = func_interface->conic_to( &v_control, &vec, user );
  179.               if ( error )
  180.                 goto Exit;
  181.               continue;
  182.             }
  184.             if ( tag != FT_CURVE_TAG_CONIC )
  185.               goto Invalid_Outline;
  187.             v_middle.x = ( v_control.x + vec.x ) / 2;
  188.             v_middle.y = ( v_control.y + vec.y ) / 2;
  190.             error = func_interface->conic_to( &v_control, &v_middle, user );
  191.             if ( error )
  192.               goto Exit;
  194.             v_control = vec;
  195.             goto Do_Conic;
  196.           }
  198.           error = func_interface->conic_to( &v_control, &v_start, user );
  199.           goto Close;
  201.         default:  /* FT_CURVE_TAG_CUBIC */
  202.           {
  203.             FT_Vector  vec1, vec2;
  206.             if ( point + 1 > limit                             ||
  207.                  FT_CURVE_TAG( tags[1] ) != FT_CURVE_TAG_CUBIC )
  208.               goto Invalid_Outline;
  210.             point += 2;
  211.             tags  += 2;
  213.             vec1.x = SCALED( point[-2].x ); vec1.y = SCALED( point[-2].y );
  214.             vec2.x = SCALED( point[-1].x ); vec2.y = SCALED( point[-1].y );
  216.             if ( point <= limit )
  217.             {
  218.               FT_Vector  vec;
  221.               vec.x = SCALED( point->x );
  222.               vec.y = SCALED( point->y );
  224.               error = func_interface->cubic_to( &vec1, &vec2, &vec, user );
  225.               if ( error )
  226.                 goto Exit;
  227.               continue;
  228.             }
  230.             error = func_interface->cubic_to( &vec1, &vec2, &v_start, user );
  231.             goto Close;
  232.           }
  233.         }
  234.       }
  236.       /* close the contour with a line segment */
  237.       error = func_interface->line_to( &v_start, user );
  239.     Close:
  240.       if ( error )
  241.         goto Exit;
  243.       first = last + 1;
  244.     }
  246.     return 0;
  248.   Exit:
  249.     return error;
  251.   Invalid_Outline:
  252.     return FT_Err_Invalid_Outline;
  253.   }
  256.   FT_EXPORT_DEF( FT_Error )
  257.   FT_Outline_New_Internal( FT_Memory    memory,
  258.                            FT_UInt      numPoints,
  259.                            FT_Int       numContours,
  260.                            FT_Outline  *anoutline )
  261.   {
  262.     FT_Error  error;
  265.     if ( !anoutline || !memory )
  266.       return FT_Err_Invalid_Argument;
  268.     *anoutline = null_outline;
  270.     if ( FT_NEW_ARRAY( anoutline->points,   numPoints * 2L ) ||
  271.          FT_NEW_ARRAY( anoutline->tags,     numPoints      ) ||
  272.          FT_NEW_ARRAY( anoutline->contours, numContours    ) )
  273.       goto Fail;
  275.     anoutline->n_points    = (FT_UShort)numPoints;
  276.     anoutline->n_contours  = (FT_Short)numContours;
  277.     anoutline->flags      |= FT_OUTLINE_OWNER;
  279.     return FT_Err_Ok;
  281.   Fail:
  282.     anoutline->flags |= FT_OUTLINE_OWNER;
  283.     FT_Outline_Done_Internal( memory, anoutline );
  285.     return error;
  286.   }
  289.   /* documentation is in ftoutln.h */
  291.   FT_EXPORT_DEF( FT_Error )
  292.   FT_Outline_New( FT_Library   library,
  293.                   FT_UInt      numPoints,
  294.                   FT_Int       numContours,
  295.                   FT_Outline  *anoutline )
  296.   {
  297.     if ( !library )
  298.       return FT_Err_Invalid_Library_Handle;
  300.     return FT_Outline_New_Internal( library->memory, numPoints,
  301.                                     numContours, anoutline );
  302.   }
  305.   /* documentation is in ftoutln.h */
  307.   FT_EXPORT_DEF( FT_Error )
  308.   FT_Outline_Check( FT_Outline*  outline )
  309.   {
  310.     if ( outline )
  311.     {
  312.       FT_Int  n_points   = outline->n_points;
  313.       FT_Int  n_contours = outline->n_contours;
  314.       FT_Int  end0, end;
  315.       FT_Int  n;
  318.       /* empty glyph? */
  319.       if ( n_points == 0 && n_contours == 0 )
  320.         return 0;
  322.       /* check point and contour counts */
  323.       if ( n_points <= 0 || n_contours <= 0 )
  324.         goto Bad;
  326.       end0 = end = -1;
  327.       for ( n = 0; n < n_contours; n++ )
  328.       {
  329.         end = outline->contours[n];
  331.         /* note that we don't accept empty contours */
  332.         if ( end <= end0 || end >= n_points )
  333.           goto Bad;
  335.         end0 = end;
  336.       }
  338.       if ( end != n_points - 1 )
  339.         goto Bad;
  341.       /* XXX: check the tags array */
  342.       return 0;
  343.     }
  345.   Bad:
  346.     return FT_Err_Invalid_Argument;
  347.   }
  350.   /* documentation is in ftoutln.h */
  352.   FT_EXPORT_DEF( FT_Error )
  353.   FT_Outline_Copy( const FT_Outline*  source,
  354.                    FT_Outline        *target )
  355.   {
  356.     FT_Int  is_owner;
  359.     if ( !source            || !target            ||
  360.          source->n_points   != target->n_points   ||
  361.          source->n_contours != target->n_contours )
  362.       return FT_Err_Invalid_Argument;
  364.     if ( source == target )
  365.       return FT_Err_Ok;
  367.     FT_ARRAY_COPY( target->points, source->points, source->n_points );
  369.     FT_ARRAY_COPY( target->tags, source->tags, source->n_points );
  371.     FT_ARRAY_COPY( target->contours, source->contours, source->n_contours );
  373.     /* copy all flags, except the `FT_OUTLINE_OWNER' one */
  374.     is_owner      = target->flags & FT_OUTLINE_OWNER;
  375.     target->flags = source->flags;
  377.     target->flags &= ~FT_OUTLINE_OWNER;
  378.     target->flags |= is_owner;
  380.     return FT_Err_Ok;
  381.   }
  384.   FT_EXPORT_DEF( FT_Error )
  385.   FT_Outline_Done_Internal( FT_Memory    memory,
  386.                             FT_Outline*  outline )
  387.   {
  388.     if ( memory && outline )
  389.     {
  390.       if ( outline->flags & FT_OUTLINE_OWNER )
  391.       {
  392.         FT_FREE( outline->points   );
  393.         FT_FREE( outline->tags     );
  394.         FT_FREE( outline->contours );
  395.       }
  396.       *outline = null_outline;
  398.       return FT_Err_Ok;
  399.     }
  400.     else
  401.       return FT_Err_Invalid_Argument;
  402.   }
  405.   /* documentation is in ftoutln.h */
  407.   FT_EXPORT_DEF( FT_Error )
  408.   FT_Outline_Done( FT_Library   library,
  409.                    FT_Outline*  outline )
  410.   {
  411.     /* check for valid `outline' in FT_Outline_Done_Internal() */
  413.     if ( !library )
  414.       return FT_Err_Invalid_Library_Handle;
  416.     return FT_Outline_Done_Internal( library->memory, outline );
  417.   }
  420.   /* documentation is in ftoutln.h */
  422.   FT_EXPORT_DEF( void )
  423.   FT_Outline_Get_CBox( const FT_Outline*  outline,
  424.                        FT_BBox           *acbox )
  425.   {
  426.     FT_Pos  xMin, yMin, xMax, yMax;
  429.     if ( outline && acbox )
  430.     {
  431.       if ( outline->n_points == 0 )
  432.       {
  433.         xMin = 0;
  434.         yMin = 0;
  435.         xMax = 0;
  436.         yMax = 0;
  437.       }
  438.       else
  439.       {
  440.         FT_Vector*  vec   = outline->points;
  441.         FT_Vector*  limit = vec + outline->n_points;
  444.         xMin = xMax = vec->x;
  445.         yMin = yMax = vec->y;
  446.         vec++;
  448.         for ( ; vec < limit; vec++ )
  449.         {
  450.           FT_Pos  x, y;
  453.           x = vec->x;
  454.           if ( x < xMin ) xMin = x;
  455.           if ( x > xMax ) xMax = x;
  457.           y = vec->y;
  458.           if ( y < yMin ) yMin = y;
  459.           if ( y > yMax ) yMax = y;
  460.         }
  461.       }
  462.       acbox->xMin = xMin;
  463.       acbox->xMax = xMax;
  464.       acbox->yMin = yMin;
  465.       acbox->yMax = yMax;
  466.     }
  467.   }
  470.   /* documentation is in ftoutln.h */
  472.   FT_EXPORT_DEF( void )
  473.   FT_Outline_Translate( const FT_Outline*  outline,
  474.                         FT_Pos             xOffset,
  475.                         FT_Pos             yOffset )
  476.   {
  477.     FT_UShort   n;
  478.     FT_Vector*  vec = outline->points;
  481.     if ( !outline )
  482.       return;
  484.     for ( n = 0; n < outline->n_points; n++ )
  485.     {
  486.       vec->x += xOffset;
  487.       vec->y += yOffset;
  488.       vec++;
  489.     }
  490.   }
  493.   /* documentation is in ftoutln.h */
  495.   FT_EXPORT_DEF( void )
  496.   FT_Outline_Reverse( FT_Outline*  outline )
  497.   {
  498.     FT_UShort  n;
  499.     FT_Int     first, last;
  502.     if ( !outline )
  503.       return;
  505.     first = 0;
  507.     for ( n = 0; n < outline->n_contours; n++ )
  508.     {
  509.       last  = outline->contours[n];
  511.       /* reverse point table */
  512.       {
  513.         FT_Vector*  p = outline->points + first;
  514.         FT_Vector*  q = outline->points + last;
  515.         FT_Vector   swap;
  518.         while ( p < q )
  519.         {
  520.           swap = *p;
  521.           *p   = *q;
  522.           *q   = swap;
  523.           p++;
  524.           q--;
  525.         }
  526.       }
  528.       /* reverse tags table */
  529.       {
  530.         char*  p = outline->tags + first;
  531.         char*  q = outline->tags + last;
  532.         char   swap;
  535.         while ( p < q )
  536.         {
  537.           swap = *p;
  538.           *p   = *q;
  539.           *q   = swap;
  540.           p++;
  541.           q--;
  542.         }
  543.       }
  545.       first = last + 1;
  546.     }
  548.     outline->flags ^= FT_OUTLINE_REVERSE_FILL;
  549.   }
  552.   /* documentation is in ftoutln.h */
  554.   FT_EXPORT_DEF( FT_Error )
  555.   FT_Outline_Render( FT_Library         library,
  556.                      FT_Outline*        outline,
  557.                      FT_Raster_Params*  params )
  558.   {
  559.     FT_Error     error;
  560.     FT_Bool      update = 0;
  561.     FT_Renderer  renderer;
  562.     FT_ListNode  node;
  565.     if ( !library )
  566.       return FT_Err_Invalid_Library_Handle;
  568.     if ( !outline || !params )
  569.       return FT_Err_Invalid_Argument;
  571.     renderer = library->cur_renderer;
  572.     node     = library->renderers.head;
  574.     params->source = (void*)outline;
  576.     error = FT_Err_Cannot_Render_Glyph;
  577.     while ( renderer )
  578.     {
  579.       error = renderer->raster_render( renderer->raster, params );
  580.       if ( !error || FT_ERROR_BASE( error ) != FT_Err_Cannot_Render_Glyph )
  581.         break;
  583.       /* FT_Err_Cannot_Render_Glyph is returned if the render mode   */
  584.       /* is unsupported by the current renderer for this glyph image */
  585.       /* format                                                      */
  587.       /* now, look for another renderer that supports the same */
  588.       /* format                                                */
  589.       renderer = FT_Lookup_Renderer( library, FT_GLYPH_FORMAT_OUTLINE,
  590.                                      &node );
  591.       update   = 1;
  592.     }
  594.     /* if we changed the current renderer for the glyph image format */
  595.     /* we need to select it as the next current one                  */
  596.     if ( !error && update && renderer )
  597.       FT_Set_Renderer( library, renderer, 0, 0 );
  599.     return error;
  600.   }
  603.   /* documentation is in ftoutln.h */
  605.   FT_EXPORT_DEF( FT_Error )
  606.   FT_Outline_Get_Bitmap( FT_Library        library,
  607.                          FT_Outline*       outline,
  608.                          const FT_Bitmap  *abitmap )
  609.   {
  610.     FT_Raster_Params  params;
  613.     if ( !abitmap )
  614.       return FT_Err_Invalid_Argument;
  616.     /* other checks are delayed to FT_Outline_Render() */
  618.     params.target = abitmap;
  619.     params.flags  = 0;
  621.     if ( abitmap->pixel_mode == FT_PIXEL_MODE_GRAY  ||
  622.          abitmap->pixel_mode == FT_PIXEL_MODE_LCD   ||
  623.          abitmap->pixel_mode == FT_PIXEL_MODE_LCD_V )
  624.       params.flags |= FT_RASTER_FLAG_AA;
  626.     return FT_Outline_Render( library, outline, &params );
  627.   }
  630.   /* documentation is in ftoutln.h */
  632.   FT_EXPORT_DEF( void )
  633.   FT_Vector_Transform( FT_Vector*        vector,
  634.                        const FT_Matrix*  matrix )
  635.   {
  636.     FT_Pos xz, yz;
  639.     if ( !vector || !matrix )
  640.       return;
  642.     xz = FT_MulFix( vector->x, matrix->xx ) +
  643.          FT_MulFix( vector->y, matrix->xy );
  645.     yz = FT_MulFix( vector->x, matrix->yx ) +
  646.          FT_MulFix( vector->y, matrix->yy );
  648.     vector->x = xz;
  649.     vector->y = yz;
  650.   }
  653.   /* documentation is in ftoutln.h */
  655.   FT_EXPORT_DEF( void )
  656.   FT_Outline_Transform( const FT_Outline*  outline,
  657.                         const FT_Matrix*   matrix )
  658.   {
  659.     FT_Vector*  vec;
  660.     FT_Vector*  limit;
  663.     if ( !outline || !matrix )
  664.       return;
  666.     vec   = outline->points;
  667.     limit = vec + outline->n_points;
  669.     for ( ; vec < limit; vec++ )
  670.       FT_Vector_Transform( vec, matrix );
  671.   }
  674. #if 0
  676. #define FT_OUTLINE_GET_CONTOUR( outline, c, first, last )  
  677.   do {                                                     
  678.     (first) = ( c > 0 ) ? (outline)->points +              
  679.                             (outline)->contours[c - 1] + 1 
  680.                         : (outline)->points;               
  681.     (last) = (outline)->points + (outline)->contours[c];   
  682.   } while ( 0 )
  685.   /* Is a point in some contour?                     */
  686.   /*                                                 */
  687.   /* We treat every point of the contour as if it    */
  688.   /* it were ON.  That is, we allow false positives, */
  689.   /* but disallow false negatives.  (XXX really?)    */
  690.   static FT_Bool
  691.   ft_contour_has( FT_Outline*  outline,
  692.                   FT_Short     c,
  693.                   FT_Vector*   point )
  694.   {
  695.     FT_Vector*  first;
  696.     FT_Vector*  last;
  697.     FT_Vector*  a;
  698.     FT_Vector*  b;
  699.     FT_UInt     n = 0;
  702.     FT_OUTLINE_GET_CONTOUR( outline, c, first, last );
  704.     for ( a = first; a <= last; a++ )
  705.     {
  706.       FT_Pos  x;
  707.       FT_Int  intersect;
  710.       b = ( a == last ) ? first : a + 1;
  712.       intersect = ( a->y - point->y ) ^ ( b->y - point->y );
  714.       /* a and b are on the same side */
  715.       if ( intersect >= 0 )
  716.       {
  717.         if ( intersect == 0 && a->y == point->y )
  718.         {
  719.           if ( ( a->x <= point->x && b->x >= point->x ) ||
  720.                ( a->x >= point->x && b->x <= point->x ) )
  721.             return 1;
  722.         }
  724.         continue;
  725.       }
  727.       x = a->x + ( b->x - a->x ) * (point->y - a->y ) / ( b->y - a->y );
  729.       if ( x < point->x )
  730.         n++;
  731.       else if ( x == point->x )
  732.         return 1;
  733.     }
  735.     return ( n % 2 );
  736.   }
  739.   static FT_Bool
  740.   ft_contour_enclosed( FT_Outline*  outline,
  741.                        FT_UShort    c )
  742.   {
  743.     FT_Vector*  first;
  744.     FT_Vector*  last;
  745.     FT_Short    i;
  748.     FT_OUTLINE_GET_CONTOUR( outline, c, first, last );
  750.     for ( i = 0; i < outline->n_contours; i++ )
  751.     {
  752.       if ( i != c && ft_contour_has( outline, i, first ) )
  753.       {
  754.         FT_Vector*  pt;
  757.         for ( pt = first + 1; pt <= last; pt++ )
  758.           if ( !ft_contour_has( outline, i, pt ) )
  759.             return 0;
  761.         return 1;
  762.       }
  763.     }
  765.     return 0;
  766.   }
  769.   /* This version differs from the public one in that each */
  770.   /* part (contour not enclosed in another contour) of the */
  771.   /* outline is checked for orientation.  This is          */
  772.   /* necessary for some buggy CJK fonts.                   */
  773.   static FT_Orientation
  774.   ft_outline_get_orientation( FT_Outline*  outline )
  775.   {
  776.     FT_Short        i;
  777.     FT_Vector*      first;
  778.     FT_Vector*      last;
  779.     FT_Orientation  orient = FT_ORIENTATION_NONE;
  782.     first = outline->points;
  783.     for ( i = 0; i < outline->n_contours; i++, first = last + 1 )
  784.     {
  785.       FT_Vector*  point;
  786.       FT_Vector*  xmin_point;
  787.       FT_Pos      xmin;
  790.       last = outline->points + outline->contours[i];
  792.       /* skip degenerate contours */
  793.       if ( last < first + 2 )
  794.         continue;
  796.       if ( ft_contour_enclosed( outline, i ) )
  797.         continue;
  799.       xmin       = first->x;
  800.       xmin_point = first;
  802.       for ( point = first + 1; point <= last; point++ )
  803.       {
  804.         if ( point->x < xmin )
  805.         {
  806.           xmin       = point->x;
  807.           xmin_point = point;
  808.         }
  809.       }
  811.       /* check the orientation of the contour */
  812.       {
  813.         FT_Vector*      prev;
  814.         FT_Vector*      next;
  815.         FT_Orientation  o;
  818.         prev = ( xmin_point == first ) ? last : xmin_point - 1;
  819.         next = ( xmin_point == last ) ? first : xmin_point + 1;
  821.         if ( FT_Atan2( prev->x - xmin_point->x, prev->y - xmin_point->y ) >
  822.              FT_Atan2( next->x - xmin_point->x, next->y - xmin_point->y ) )
  823.           o = FT_ORIENTATION_POSTSCRIPT;
  824.         else
  825.           o = FT_ORIENTATION_TRUETYPE;
  827.         if ( orient == FT_ORIENTATION_NONE )
  828.           orient = o;
  829.         else if ( orient != o )
  830.           return FT_ORIENTATION_NONE;
  831.       }
  832.     }
  834.     return orient;
  835.   }
  837. #endif /* 0 */
  840.   /* documentation is in ftoutln.h */
  842.   FT_EXPORT_DEF( FT_Error )
  843.   FT_Outline_Embolden( FT_Outline*  outline,
  844.                        FT_Pos       strength )
  845.   {
  846.     FT_Vector*  points;
  847.     FT_Vector   v_prev, v_first, v_next, v_cur;
  848.     FT_Angle    rotate, angle_in, angle_out;
  849.     FT_Int      c, n, first;
  850.     FT_Int      orientation;
  853.     if ( !outline )
  854.       return FT_Err_Invalid_Argument;
  856.     strength /= 2;
  857.     if ( strength == 0 )
  858.       return FT_Err_Ok;
  860.     orientation = FT_Outline_Get_Orientation( outline );
  861.     if ( orientation == FT_ORIENTATION_NONE )
  862.     {
  863.       if ( outline->n_contours )
  864.         return FT_Err_Invalid_Argument;
  865.       else
  866.         return FT_Err_Ok;
  867.     }
  869.     if ( orientation == FT_ORIENTATION_TRUETYPE )
  870.       rotate = -FT_ANGLE_PI2;
  871.     else
  872.       rotate = FT_ANGLE_PI2;
  874.     points = outline->points;
  876.     first = 0;
  877.     for ( c = 0; c < outline->n_contours; c++ )
  878.     {
  879.       int  last = outline->contours[c];
  882.       v_first = points[first];
  883.       v_prev  = points[last];
  884.       v_cur   = v_first;
  886.       for ( n = first; n <= last; n++ )
  887.       {
  888.         FT_Vector  in, out;
  889.         FT_Angle   angle_diff;
  890.         FT_Pos     d;
  891.         FT_Fixed   scale;
  894.         if ( n < last )
  895.           v_next = points[n + 1];
  896.         else
  897.           v_next = v_first;
  899.         /* compute the in and out vectors */
  900.         in.x = v_cur.x - v_prev.x;
  901.         in.y = v_cur.y - v_prev.y;
  903.         out.x = v_next.x - v_cur.x;
  904.         out.y = v_next.y - v_cur.y;
  906.         angle_in   = FT_Atan2( in.x, in.y );
  907.         angle_out  = FT_Atan2( out.x, out.y );
  908.         angle_diff = FT_Angle_Diff( angle_in, angle_out );
  909.         scale      = FT_Cos( angle_diff / 2 );
  911.         if ( scale < 0x4000L && scale > -0x4000L )
  912.           in.x = in.y = 0;
  913.         else
  914.         {
  915.           d = FT_DivFix( strength, scale );
  917.           FT_Vector_From_Polar( &in, d, angle_in + angle_diff / 2 - rotate );
  918.         }
  920.         outline->points[n].x = v_cur.x + strength + in.x;
  921.         outline->points[n].y = v_cur.y + strength + in.y;
  923.         v_prev = v_cur;
  924.         v_cur  = v_next;
  925.       }
  927.       first = last + 1;
  928.     }
  930.     return FT_Err_Ok;
  931.   }
  934.   /* documentation is in ftoutln.h */
  936.   FT_EXPORT_DEF( FT_Orientation )
  937.   FT_Outline_Get_Orientation( FT_Outline*  outline )
  938.   {
  939.     FT_Pos      xmin       = 32768L;
  940.     FT_Pos      xmin_ymin  = 32768L;
  941.     FT_Pos      xmin_ymax  = -32768L;
  942.     FT_Vector*  xmin_first = NULL;
  943.     FT_Vector*  xmin_last  = NULL;
  945.     short*      contour;
  947.     FT_Vector*  first;
  948.     FT_Vector*  last;
  949.     FT_Vector*  prev;
  950.     FT_Vector*  point;
  952.     int             i;
  953.     FT_Pos          ray_y[3];
  954.     FT_Orientation  result[3];
  957.     if ( !outline || outline->n_points <= 0 )
  958.       return FT_ORIENTATION_TRUETYPE;
  960.     /* We use the nonzero winding rule to find the orientation.       */
  961.     /* Since glyph outlines behave much more `regular' than arbitrary */
  962.     /* cubic or quadratic curves, this test deals with the polygon    */
  963.     /* only which is spanned up by the control points.                */
  965.     first = outline->points;
  966.     for ( contour = outline->contours;
  967.           contour < outline->contours + outline->n_contours;
  968.           contour++, first = last + 1 )
  969.     {
  970.       FT_Pos  contour_xmin = 32768L;
  971.       FT_Pos  contour_xmax = -32768L;
  972.       FT_Pos  contour_ymin = 32768L;
  973.       FT_Pos  contour_ymax = -32768L;
  976.       last = outline->points + *contour;
  978.       /* skip degenerate contours */
  979.       if ( last < first + 2 )
  980.         continue;
  982.       for ( point = first; point <= last; ++point )
  983.       {
  984.         if ( point->x < contour_xmin )
  985.           contour_xmin = point->x;
  987.         if ( point->x > contour_xmax )
  988.           contour_xmax = point->x;
  990.         if ( point->y < contour_ymin )
  991.           contour_ymin = point->y;
  993.         if ( point->y > contour_ymax )
  994.           contour_ymax = point->y;
  995.       }
  997.       if ( contour_xmin < xmin          &&
  998.            contour_xmin != contour_xmax &&
  999.            contour_ymin != contour_ymax )
  1000.       {
  1001.         xmin       = contour_xmin;
  1002.         xmin_ymin  = contour_ymin;
  1003.         xmin_ymax  = contour_ymax;
  1004.         xmin_first = first;
  1005.         xmin_last  = last;
  1006.       }
  1007.     }
  1009.     if ( xmin == 32768 )
  1010.       return FT_ORIENTATION_TRUETYPE;
  1012.     ray_y[0] = ( xmin_ymin * 3 + xmin_ymax     ) >> 2;
  1013.     ray_y[1] = ( xmin_ymin     + xmin_ymax     ) >> 1;
  1014.     ray_y[2] = ( xmin_ymin     + xmin_ymax * 3 ) >> 2;
  1016.     for ( i = 0; i < 3; i++ )
  1017.     {
  1018.       FT_Pos      left_x;
  1019.       FT_Pos      right_x;
  1020.       FT_Vector*  left1;
  1021.       FT_Vector*  left2;
  1022.       FT_Vector*  right1;
  1023.       FT_Vector*  right2;
  1026.     RedoRay:
  1027.       left_x  = 32768L;
  1028.       right_x = -32768L;
  1030.       left1 = left2 = right1 = right2 = NULL;
  1032.       prev = xmin_last;
  1033.       for ( point = xmin_first; point <= xmin_last; prev = point, ++point )
  1034.       {
  1035.         FT_Pos  tmp_x;
  1038.         if ( point->y == ray_y[i] || prev->y == ray_y[i] )
  1039.         {
  1040.           ray_y[i]++;
  1041.           goto RedoRay;
  1042.         }
  1044.         if ( ( point->y < ray_y[i] && prev->y < ray_y[i] ) ||
  1045.              ( point->y > ray_y[i] && prev->y > ray_y[i] ) )
  1046.           continue;
  1048.         tmp_x = FT_MulDiv( point->x - prev->x,
  1049.                            ray_y[i] - prev->y,
  1050.                            point->y - prev->y ) + prev->x;
  1052.         if ( tmp_x < left_x )
  1053.         {
  1054.           left_x = tmp_x;
  1055.           left1  = prev;
  1056.           left2  = point;
  1057.         }
  1059.         if ( tmp_x > right_x )
  1060.         {
  1061.           right_x = tmp_x;
  1062.           right1  = prev;
  1063.           right2  = point;
  1064.         }
  1065.       }
  1067.       if ( left1 && right1 )
  1068.       {
  1069.         if ( left1->y < left2->y && right1->y > right2->y )
  1070.           result[i] = FT_ORIENTATION_TRUETYPE;
  1071.         else if ( left1->y > left2->y && right1->y < right2->y )
  1072.           result[i] = FT_ORIENTATION_POSTSCRIPT;
  1073.         else
  1074.           result[i] = FT_ORIENTATION_NONE;
  1075.       }
  1076.     }
  1078.     if ( result[0] != FT_ORIENTATION_NONE                     &&
  1079.          ( result[0] == result[1] || result[0] == result[2] ) )
  1080.       return result[0];
  1082.     if ( result[1] != FT_ORIENTATION_NONE && result[1] == result[2] )
  1083.       return result[1];
  1085.     return FT_ORIENTATION_TRUETYPE;
  1086.   }
  1089. /* END */