-/***************************************************************************/\r
-/* */\r
-/* afangles.c */\r
-/* */\r
-/* Routines used to compute vector angles with limited accuracy */\r
-/* and very high speed. It also contains sorting routines (body). */\r
-/* */\r
-/* Copyright 2003, 2004, 2005, 2006 by */\r
-/* David Turner, Robert Wilhelm, and Werner Lemberg. */\r
-/* */\r
-/* This file is part of the FreeType project, and may only be used, */\r
-/* modified, and distributed under the terms of the FreeType project */\r
-/* license, LICENSE.TXT. By continuing to use, modify, or distribute */\r
-/* this file you indicate that you have read the license and */\r
-/* understand and accept it fully. */\r
-/* */\r
-/***************************************************************************/\r
-\r
-\r
-#include "aftypes.h"\r
-\r
-\r
-#if 0\r
-\r
- FT_LOCAL_DEF( FT_Int )\r
- af_corner_is_flat( FT_Pos x_in,\r
- FT_Pos y_in,\r
- FT_Pos x_out,\r
- FT_Pos y_out )\r
- {\r
- FT_Pos ax = x_in;\r
- FT_Pos ay = y_in;\r
-\r
- FT_Pos d_in, d_out, d_corner;\r
-\r
-\r
- if ( ax < 0 )\r
- ax = -ax;\r
- if ( ay < 0 )\r
- ay = -ay;\r
- d_in = ax + ay;\r
-\r
- ax = x_out;\r
- if ( ax < 0 )\r
- ax = -ax;\r
- ay = y_out;\r
- if ( ay < 0 )\r
- ay = -ay;\r
- d_out = ax + ay;\r
-\r
- ax = x_out + x_in;\r
- if ( ax < 0 )\r
- ax = -ax;\r
- ay = y_out + y_in;\r
- if ( ay < 0 )\r
- ay = -ay;\r
- d_corner = ax + ay;\r
-\r
- return ( d_in + d_out - d_corner ) < ( d_corner >> 4 );\r
- }\r
-\r
-\r
- FT_LOCAL_DEF( FT_Int )\r
- af_corner_orientation( FT_Pos x_in,\r
- FT_Pos y_in,\r
- FT_Pos x_out,\r
- FT_Pos y_out )\r
- {\r
- FT_Pos delta;\r
-\r
-\r
- delta = x_in * y_out - y_in * x_out;\r
-\r
- if ( delta == 0 )\r
- return 0;\r
- else\r
- return 1 - 2 * ( delta < 0 );\r
- }\r
-\r
-#endif\r
-\r
-\r
- /*\r
- * We are not using `af_angle_atan' anymore, but we keep the source\r
- * code below just in case...\r
- */\r
-\r
-\r
-#if 0\r
-\r
-\r
- /*\r
- * The trick here is to realize that we don't need a very accurate angle\r
- * approximation. We are going to use the result of `af_angle_atan' to\r
- * only compare the sign of angle differences, or check whether its\r
- * magnitude is very small.\r
- *\r
- * The approximation\r
- *\r
- * dy * PI / (|dx|+|dy|)\r
- *\r
- * should be enough, and much faster to compute.\r
- */\r
- FT_LOCAL_DEF( AF_Angle )\r
- af_angle_atan( FT_Fixed dx,\r
- FT_Fixed dy )\r
- {\r
- AF_Angle angle;\r
- FT_Fixed ax = dx;\r
- FT_Fixed ay = dy;\r
-\r
-\r
- if ( ax < 0 )\r
- ax = -ax;\r
- if ( ay < 0 )\r
- ay = -ay;\r
-\r
- ax += ay;\r
-\r
- if ( ax == 0 )\r
- angle = 0;\r
- else\r
- {\r
- angle = ( AF_ANGLE_PI2 * dy ) / ( ax + ay );\r
- if ( dx < 0 )\r
- {\r
- if ( angle >= 0 )\r
- angle = AF_ANGLE_PI - angle;\r
- else\r
- angle = -AF_ANGLE_PI - angle;\r
- }\r
- }\r
-\r
- return angle;\r
- }\r
-\r
-\r
-#elif 0\r
-\r
-\r
- /* the following table has been automatically generated with */\r
- /* the `mather.py' Python script */\r
-\r
-#define AF_ATAN_BITS 8\r
-\r
- static const FT_Byte af_arctan[1L << AF_ATAN_BITS] =\r
- {\r
- 0, 0, 1, 1, 1, 2, 2, 2,\r
- 3, 3, 3, 3, 4, 4, 4, 5,\r
- 5, 5, 6, 6, 6, 7, 7, 7,\r
- 8, 8, 8, 9, 9, 9, 10, 10,\r
- 10, 10, 11, 11, 11, 12, 12, 12,\r
- 13, 13, 13, 14, 14, 14, 14, 15,\r
- 15, 15, 16, 16, 16, 17, 17, 17,\r
- 18, 18, 18, 18, 19, 19, 19, 20,\r
- 20, 20, 21, 21, 21, 21, 22, 22,\r
- 22, 23, 23, 23, 24, 24, 24, 24,\r
- 25, 25, 25, 26, 26, 26, 26, 27,\r
- 27, 27, 28, 28, 28, 28, 29, 29,\r
- 29, 30, 30, 30, 30, 31, 31, 31,\r
- 31, 32, 32, 32, 33, 33, 33, 33,\r
- 34, 34, 34, 34, 35, 35, 35, 35,\r
- 36, 36, 36, 36, 37, 37, 37, 38,\r
- 38, 38, 38, 39, 39, 39, 39, 40,\r
- 40, 40, 40, 41, 41, 41, 41, 42,\r
- 42, 42, 42, 42, 43, 43, 43, 43,\r
- 44, 44, 44, 44, 45, 45, 45, 45,\r
- 46, 46, 46, 46, 46, 47, 47, 47,\r
- 47, 48, 48, 48, 48, 48, 49, 49,\r
- 49, 49, 50, 50, 50, 50, 50, 51,\r
- 51, 51, 51, 51, 52, 52, 52, 52,\r
- 52, 53, 53, 53, 53, 53, 54, 54,\r
- 54, 54, 54, 55, 55, 55, 55, 55,\r
- 56, 56, 56, 56, 56, 57, 57, 57,\r
- 57, 57, 57, 58, 58, 58, 58, 58,\r
- 59, 59, 59, 59, 59, 59, 60, 60,\r
- 60, 60, 60, 61, 61, 61, 61, 61,\r
- 61, 62, 62, 62, 62, 62, 62, 63,\r
- 63, 63, 63, 63, 63, 64, 64, 64\r
- };\r
-\r
-\r
- FT_LOCAL_DEF( AF_Angle )\r
- af_angle_atan( FT_Fixed dx,\r
- FT_Fixed dy )\r
- {\r
- AF_Angle angle;\r
-\r
-\r
- /* check trivial cases */\r
- if ( dy == 0 )\r
- {\r
- angle = 0;\r
- if ( dx < 0 )\r
- angle = AF_ANGLE_PI;\r
- return angle;\r
- }\r
- else if ( dx == 0 )\r
- {\r
- angle = AF_ANGLE_PI2;\r
- if ( dy < 0 )\r
- angle = -AF_ANGLE_PI2;\r
- return angle;\r
- }\r
-\r
- angle = 0;\r
- if ( dx < 0 )\r
- {\r
- dx = -dx;\r
- dy = -dy;\r
- angle = AF_ANGLE_PI;\r
- }\r
-\r
- if ( dy < 0 )\r
- {\r
- FT_Pos tmp;\r
-\r
-\r
- tmp = dx;\r
- dx = -dy;\r
- dy = tmp;\r
- angle -= AF_ANGLE_PI2;\r
- }\r
-\r
- if ( dx == 0 && dy == 0 )\r
- return 0;\r
-\r
- if ( dx == dy )\r
- angle += AF_ANGLE_PI4;\r
- else if ( dx > dy )\r
- angle += af_arctan[FT_DivFix( dy, dx ) >> ( 16 - AF_ATAN_BITS )];\r
- else\r
- angle += AF_ANGLE_PI2 -\r
- af_arctan[FT_DivFix( dx, dy ) >> ( 16 - AF_ATAN_BITS )];\r
-\r
- if ( angle > AF_ANGLE_PI )\r
- angle -= AF_ANGLE_2PI;\r
-\r
- return angle;\r
- }\r
-\r
-\r
-#endif /* 0 */\r
-\r
-\r
- FT_LOCAL_DEF( void )\r
- af_sort_pos( FT_UInt count,\r
- FT_Pos* table )\r
- {\r
- FT_UInt i, j;\r
- FT_Pos swap;\r
-\r
-\r
- for ( i = 1; i < count; i++ )\r
- {\r
- for ( j = i; j > 0; j-- )\r
- {\r
- if ( table[j] > table[j - 1] )\r
- break;\r
-\r
- swap = table[j];\r
- table[j] = table[j - 1];\r
- table[j - 1] = swap;\r
- }\r
- }\r
- }\r
-\r
-\r
- FT_LOCAL_DEF( void )\r
- af_sort_widths( FT_UInt count,\r
- AF_Width table )\r
- {\r
- FT_UInt i, j;\r
- AF_WidthRec swap;\r
-\r
-\r
- for ( i = 1; i < count; i++ )\r
- {\r
- for ( j = i; j > 0; j-- )\r
- {\r
- if ( table[j].org > table[j - 1].org )\r
- break;\r
-\r
- swap = table[j];\r
- table[j] = table[j - 1];\r
- table[j - 1] = swap;\r
- }\r
- }\r
- }\r
-\r
-\r
-/* END */\r
+/***************************************************************************/
+/* */
+/* afangles.c */
+/* */
+/* Routines used to compute vector angles with limited accuracy */
+/* and very high speed. It also contains sorting routines (body). */
+/* */
+/* Copyright 2003, 2004, 2005, 2006 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. */
+/* */
+/***************************************************************************/
+
+
+#include "aftypes.h"
+
+
+#if 0
+
+ FT_LOCAL_DEF( FT_Int )
+ af_corner_is_flat( FT_Pos x_in,
+ FT_Pos y_in,
+ FT_Pos x_out,
+ FT_Pos y_out )
+ {
+ FT_Pos ax = x_in;
+ FT_Pos ay = y_in;
+
+ FT_Pos d_in, d_out, d_corner;
+
+
+ if ( ax < 0 )
+ ax = -ax;
+ if ( ay < 0 )
+ ay = -ay;
+ d_in = ax + ay;
+
+ ax = x_out;
+ if ( ax < 0 )
+ ax = -ax;
+ ay = y_out;
+ if ( ay < 0 )
+ ay = -ay;
+ d_out = ax + ay;
+
+ ax = x_out + x_in;
+ if ( ax < 0 )
+ ax = -ax;
+ ay = y_out + y_in;
+ if ( ay < 0 )
+ ay = -ay;
+ d_corner = ax + ay;
+
+ return ( d_in + d_out - d_corner ) < ( d_corner >> 4 );
+ }
+
+
+ FT_LOCAL_DEF( FT_Int )
+ af_corner_orientation( FT_Pos x_in,
+ FT_Pos y_in,
+ FT_Pos x_out,
+ FT_Pos y_out )
+ {
+ FT_Pos delta;
+
+
+ delta = x_in * y_out - y_in * x_out;
+
+ if ( delta == 0 )
+ return 0;
+ else
+ return 1 - 2 * ( delta < 0 );
+ }
+
+#endif
+
+
+ /*
+ * We are not using `af_angle_atan' anymore, but we keep the source
+ * code below just in case...
+ */
+
+
+#if 0
+
+
+ /*
+ * The trick here is to realize that we don't need a very accurate angle
+ * approximation. We are going to use the result of `af_angle_atan' to
+ * only compare the sign of angle differences, or check whether its
+ * magnitude is very small.
+ *
+ * The approximation
+ *
+ * dy * PI / (|dx|+|dy|)
+ *
+ * should be enough, and much faster to compute.
+ */
+ FT_LOCAL_DEF( AF_Angle )
+ af_angle_atan( FT_Fixed dx,
+ FT_Fixed dy )
+ {
+ AF_Angle angle;
+ FT_Fixed ax = dx;
+ FT_Fixed ay = dy;
+
+
+ if ( ax < 0 )
+ ax = -ax;
+ if ( ay < 0 )
+ ay = -ay;
+
+ ax += ay;
+
+ if ( ax == 0 )
+ angle = 0;
+ else
+ {
+ angle = ( AF_ANGLE_PI2 * dy ) / ( ax + ay );
+ if ( dx < 0 )
+ {
+ if ( angle >= 0 )
+ angle = AF_ANGLE_PI - angle;
+ else
+ angle = -AF_ANGLE_PI - angle;
+ }
+ }
+
+ return angle;
+ }
+
+
+#elif 0
+
+
+ /* the following table has been automatically generated with */
+ /* the `mather.py' Python script */
+
+#define AF_ATAN_BITS 8
+
+ static const FT_Byte af_arctan[1L << AF_ATAN_BITS] =
+ {
+ 0, 0, 1, 1, 1, 2, 2, 2,
+ 3, 3, 3, 3, 4, 4, 4, 5,
+ 5, 5, 6, 6, 6, 7, 7, 7,
+ 8, 8, 8, 9, 9, 9, 10, 10,
+ 10, 10, 11, 11, 11, 12, 12, 12,
+ 13, 13, 13, 14, 14, 14, 14, 15,
+ 15, 15, 16, 16, 16, 17, 17, 17,
+ 18, 18, 18, 18, 19, 19, 19, 20,
+ 20, 20, 21, 21, 21, 21, 22, 22,
+ 22, 23, 23, 23, 24, 24, 24, 24,
+ 25, 25, 25, 26, 26, 26, 26, 27,
+ 27, 27, 28, 28, 28, 28, 29, 29,
+ 29, 30, 30, 30, 30, 31, 31, 31,
+ 31, 32, 32, 32, 33, 33, 33, 33,
+ 34, 34, 34, 34, 35, 35, 35, 35,
+ 36, 36, 36, 36, 37, 37, 37, 38,
+ 38, 38, 38, 39, 39, 39, 39, 40,
+ 40, 40, 40, 41, 41, 41, 41, 42,
+ 42, 42, 42, 42, 43, 43, 43, 43,
+ 44, 44, 44, 44, 45, 45, 45, 45,
+ 46, 46, 46, 46, 46, 47, 47, 47,
+ 47, 48, 48, 48, 48, 48, 49, 49,
+ 49, 49, 50, 50, 50, 50, 50, 51,
+ 51, 51, 51, 51, 52, 52, 52, 52,
+ 52, 53, 53, 53, 53, 53, 54, 54,
+ 54, 54, 54, 55, 55, 55, 55, 55,
+ 56, 56, 56, 56, 56, 57, 57, 57,
+ 57, 57, 57, 58, 58, 58, 58, 58,
+ 59, 59, 59, 59, 59, 59, 60, 60,
+ 60, 60, 60, 61, 61, 61, 61, 61,
+ 61, 62, 62, 62, 62, 62, 62, 63,
+ 63, 63, 63, 63, 63, 64, 64, 64
+ };
+
+
+ FT_LOCAL_DEF( AF_Angle )
+ af_angle_atan( FT_Fixed dx,
+ FT_Fixed dy )
+ {
+ AF_Angle angle;
+
+
+ /* check trivial cases */
+ if ( dy == 0 )
+ {
+ angle = 0;
+ if ( dx < 0 )
+ angle = AF_ANGLE_PI;
+ return angle;
+ }
+ else if ( dx == 0 )
+ {
+ angle = AF_ANGLE_PI2;
+ if ( dy < 0 )
+ angle = -AF_ANGLE_PI2;
+ return angle;
+ }
+
+ angle = 0;
+ if ( dx < 0 )
+ {
+ dx = -dx;
+ dy = -dy;
+ angle = AF_ANGLE_PI;
+ }
+
+ if ( dy < 0 )
+ {
+ FT_Pos tmp;
+
+
+ tmp = dx;
+ dx = -dy;
+ dy = tmp;
+ angle -= AF_ANGLE_PI2;
+ }
+
+ if ( dx == 0 && dy == 0 )
+ return 0;
+
+ if ( dx == dy )
+ angle += AF_ANGLE_PI4;
+ else if ( dx > dy )
+ angle += af_arctan[FT_DivFix( dy, dx ) >> ( 16 - AF_ATAN_BITS )];
+ else
+ angle += AF_ANGLE_PI2 -
+ af_arctan[FT_DivFix( dx, dy ) >> ( 16 - AF_ATAN_BITS )];
+
+ if ( angle > AF_ANGLE_PI )
+ angle -= AF_ANGLE_2PI;
+
+ return angle;
+ }
+
+
+#endif /* 0 */
+
+
+ FT_LOCAL_DEF( void )
+ af_sort_pos( FT_UInt count,
+ FT_Pos* table )
+ {
+ FT_UInt i, j;
+ FT_Pos swap;
+
+
+ for ( i = 1; i < count; i++ )
+ {
+ for ( j = i; j > 0; j-- )
+ {
+ if ( table[j] > table[j - 1] )
+ break;
+
+ swap = table[j];
+ table[j] = table[j - 1];
+ table[j - 1] = swap;
+ }
+ }
+ }
+
+
+ FT_LOCAL_DEF( void )
+ af_sort_widths( FT_UInt count,
+ AF_Width table )
+ {
+ FT_UInt i, j;
+ AF_WidthRec swap;
+
+
+ for ( i = 1; i < count; i++ )
+ {
+ for ( j = i; j > 0; j-- )
+ {
+ if ( table[j].org > table[j - 1].org )
+ break;
+
+ swap = table[j];
+ table[j] = table[j - 1];
+ table[j - 1] = swap;
+ }
+ }
+ }
+
+
+/* END */
projects / reactos.git / blobdiff