freetype-commit
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Git][freetype/freetype][clean-gxvar] 2 commits: [truetype/GX] Fix an ol


From: Alexei Podtelezhnikov (@apodtele)
Subject: [Git][freetype/freetype][clean-gxvar] 2 commits: [truetype/GX] Fix an old typo.
Date: Fri, 17 Jun 2022 02:55:28 +0000

Alexei Podtelezhnikov pushed to branch clean-gxvar at FreeType / FreeType

Commits:

  • d9b8a69e
    by Alexei Podtelezhnikov at 2022-06-16T22:13:25-04:00
    [truetype/GX] Fix an old typo.
    
    * src/truetype/ttgxvar.c (TT_Vary_Apply_Glyph_Deltas): Vertical
    advance is measured along y-coordinate.
    
  • a94b275c
    by Alexei Podtelezhnikov at 2022-06-16T22:48:25-04:00
    [truetype/GX] Clean up phantom point adjustment.
    
    * src/truetype/ttgload.c (load_truetype_glyph): Move it from here...
    * src/truetype/ttgxvar.c (TT_Vary_Apply_Glyph_Deltas): ... to here
    and check for HVAR and VVAR outside the loop.
    

2 changed files:

Changes:

  • src/truetype/ttgload.c
    ... ... @@ -1778,16 +1778,6 @@
    1778 1778
                                                 (FT_UInt)outline.n_points );
    
    1779 1779
             if ( error )
    
    1780 1780
               goto Exit;
    
    1781
    -
    
    1782
    -        loader->pp1.x = points[0].x;
    
    1783
    -        loader->pp1.y = points[0].y;
    
    1784
    -        loader->pp2.x = points[1].x;
    
    1785
    -        loader->pp2.y = points[1].y;
    
    1786
    -
    
    1787
    -        loader->pp3.x = points[2].x;
    
    1788
    -        loader->pp3.y = points[2].y;
    
    1789
    -        loader->pp4.x = points[3].x;
    
    1790
    -        loader->pp4.y = points[3].y;
    
    1791 1781
           }
    
    1792 1782
     
    
    1793 1783
     #endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
    
    ... ... @@ -2008,16 +1998,6 @@
    2008 1998
               }
    
    2009 1999
             }
    
    2010 2000
     
    
    2011
    -        loader->pp1.x = points[i + 0].x;
    
    2012
    -        loader->pp1.y = points[i + 0].y;
    
    2013
    -        loader->pp2.x = points[i + 1].x;
    
    2014
    -        loader->pp2.y = points[i + 1].y;
    
    2015
    -
    
    2016
    -        loader->pp3.x = points[i + 2].x;
    
    2017
    -        loader->pp3.y = points[i + 2].y;
    
    2018
    -        loader->pp4.x = points[i + 3].x;
    
    2019
    -        loader->pp4.y = points[i + 3].y;
    
    2020
    -
    
    2021 2001
           Exit1:
    
    2022 2002
             FT_FREE( outline.points );
    
    2023 2003
             FT_FREE( outline.tags );
    

  • src/truetype/ttgxvar.c
    ... ... @@ -4177,36 +4177,8 @@
    4177 4177
               FT_Pos  point_delta_y = points_out[j].y - points_org[j].y;
    
    4178 4178
     
    
    4179 4179
     
    
    4180
    -          if ( j < n_points - 4 )
    
    4181
    -          {
    
    4182
    -            point_deltas_x[j] = old_point_delta_x + point_delta_x;
    
    4183
    -            point_deltas_y[j] = old_point_delta_y + point_delta_y;
    
    4184
    -          }
    
    4185
    -          else
    
    4186
    -          {
    
    4187
    -            /* To avoid double adjustment of advance width or height, */
    
    4188
    -            /* adjust phantom points only if there is no HVAR or VVAR */
    
    4189
    -            /* support, respectively.                                 */
    
    4190
    -            if ( j == ( n_points - 4 )        &&
    
    4191
    -                 !( face->variation_support &
    
    4192
    -                    TT_FACE_FLAG_VAR_LSB    ) )
    
    4193
    -              point_deltas_x[j] = old_point_delta_x + point_delta_x;
    
    4194
    -
    
    4195
    -            else if ( j == ( n_points - 3 )          &&
    
    4196
    -                      !( face->variation_support   &
    
    4197
    -                         TT_FACE_FLAG_VAR_HADVANCE ) )
    
    4198
    -              point_deltas_x[j] = old_point_delta_x + point_delta_x;
    
    4199
    -
    
    4200
    -            else if ( j == ( n_points - 2 )        &&
    
    4201
    -                      !( face->variation_support &
    
    4202
    -                         TT_FACE_FLAG_VAR_TSB    ) )
    
    4203
    -              point_deltas_y[j] = old_point_delta_y + point_delta_y;
    
    4204
    -
    
    4205
    -            else if ( j == ( n_points - 1 )          &&
    
    4206
    -                      !( face->variation_support   &
    
    4207
    -                         TT_FACE_FLAG_VAR_VADVANCE ) )
    
    4208
    -              point_deltas_y[j] = old_point_delta_y + point_delta_y;
    
    4209
    -          }
    
    4180
    +          point_deltas_x[j] = old_point_delta_x + point_delta_x;
    
    4181
    +          point_deltas_y[j] = old_point_delta_y + point_delta_y;
    
    4210 4182
     
    
    4211 4183
     #ifdef FT_DEBUG_LEVEL_TRACE
    
    4212 4184
               if ( point_delta_x || point_delta_y )
    
    ... ... @@ -4253,14 +4225,25 @@
    4253 4225
           outline->points[i].y += FT_fixedToInt( point_deltas_y[i] );
    
    4254 4226
         }
    
    4255 4227
     
    
    4256
    -    /* recalculate linear horizontal and vertical advances */
    
    4257
    -    /* if we don't have HVAR and VVAR, respectively        */
    
    4228
    +    /* To avoid double adjustment of advance width or height, */
    
    4229
    +    /* adjust phantom points only if there is no HVAR or VVAR */
    
    4230
    +    /* support, respectively.                                 */
    
    4231
    +    if ( !( face->variation_support & TT_FACE_FLAG_VAR_LSB ) )
    
    4232
    +      loader->pp1      = outline->points[n_points - 4];
    
    4258 4233
         if ( !( face->variation_support & TT_FACE_FLAG_VAR_HADVANCE ) )
    
    4234
    +    {
    
    4235
    +      loader->pp2      = outline->points[n_points - 3];
    
    4259 4236
           loader->linear   = FT_PIX_ROUND( unrounded[n_points - 3].x -
    
    4260 4237
                                            unrounded[n_points - 4].x ) / 64;
    
    4238
    +    }
    
    4239
    +    if ( !( face->variation_support & TT_FACE_FLAG_VAR_TSB ) )
    
    4240
    +      loader->pp3      = outline->points[n_points - 2];
    
    4261 4241
         if ( !( face->variation_support & TT_FACE_FLAG_VAR_VADVANCE ) )
    
    4262
    -      loader->vadvance = FT_PIX_ROUND( unrounded[n_points - 1].x -
    
    4263
    -                                       unrounded[n_points - 2].x ) / 64;
    
    4242
    +    {
    
    4243
    +      loader->pp4      = outline->points[n_points - 1];
    
    4244
    +      loader->vadvance = FT_PIX_ROUND( unrounded[n_points - 1].y -
    
    4245
    +                                       unrounded[n_points - 2].y ) / 64;
    
    4246
    +    }
    
    4264 4247
     
    
    4265 4248
       Fail3:
    
    4266 4249
         FT_FREE( point_deltas_x );
    


  • reply via email to

    [Prev in Thread] Current Thread [Next in Thread]