Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
4680 | right-hear | 1 | /***************************************************************************/ |
2 | /* */ |
||
3 | /* ftcalc.h */ |
||
4 | /* */ |
||
5 | /* Arithmetic computations (specification). */ |
||
6 | /* */ |
||
7 | /* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2008, 2009 by */ |
||
8 | /* David Turner, Robert Wilhelm, and Werner Lemberg. */ |
||
9 | /* */ |
||
10 | /* This file is part of the FreeType project, and may only be used, */ |
||
11 | /* modified, and distributed under the terms of the FreeType project */ |
||
12 | /* license, LICENSE.TXT. By continuing to use, modify, or distribute */ |
||
13 | /* this file you indicate that you have read the license and */ |
||
14 | /* understand and accept it fully. */ |
||
15 | /* */ |
||
16 | /***************************************************************************/ |
||
17 | |||
18 | |||
19 | #ifndef __FTCALC_H__ |
||
20 | #define __FTCALC_H__ |
||
21 | |||
22 | |||
23 | #include |
||
24 | #include FT_FREETYPE_H |
||
25 | |||
26 | |||
27 | FT_BEGIN_HEADER |
||
28 | |||
29 | |||
30 | /*************************************************************************/ |
||
31 | /* */ |
||
32 | /* |
||
33 | /* FT_FixedSqrt */ |
||
34 | /* */ |
||
35 | /* |
||
36 | /* Computes the square root of a 16.16 fixed point value. */ |
||
37 | /* */ |
||
38 | /* */ |
||
39 | /* x :: The value to compute the root for. */ |
||
40 | /* */ |
||
41 | /* |
||
42 | /* The result of `sqrt(x)'. */ |
||
43 | /* */ |
||
44 | /* |
||
45 | /* This function is not very fast. */ |
||
46 | /* */ |
||
47 | FT_BASE( FT_Int32 ) |
||
48 | FT_SqrtFixed( FT_Int32 x ); |
||
49 | |||
50 | |||
51 | #ifdef FT_CONFIG_OPTION_OLD_INTERNALS |
||
52 | |||
53 | /*************************************************************************/ |
||
54 | /* */ |
||
55 | /* |
||
56 | /* FT_Sqrt32 */ |
||
57 | /* */ |
||
58 | /* |
||
59 | /* Computes the square root of an Int32 integer (which will be */ |
||
60 | /* handled as an unsigned long value). */ |
||
61 | /* */ |
||
62 | /* */ |
||
63 | /* x :: The value to compute the root for. */ |
||
64 | /* */ |
||
65 | /* |
||
66 | /* The result of `sqrt(x)'. */ |
||
67 | /* */ |
||
68 | FT_EXPORT( FT_Int32 ) |
||
69 | FT_Sqrt32( FT_Int32 x ); |
||
70 | |||
71 | #endif /* FT_CONFIG_OPTION_OLD_INTERNALS */ |
||
72 | |||
73 | |||
74 | /*************************************************************************/ |
||
75 | /* */ |
||
76 | /* FT_MulDiv() and FT_MulFix() are declared in freetype.h. */ |
||
77 | /* */ |
||
78 | /*************************************************************************/ |
||
79 | |||
80 | |||
81 | #ifdef TT_USE_BYTECODE_INTERPRETER |
||
82 | |||
83 | /*************************************************************************/ |
||
84 | /* */ |
||
85 | /* |
||
86 | /* FT_MulDiv_No_Round */ |
||
87 | /* */ |
||
88 | /* |
||
89 | /* A very simple function used to perform the computation `(a*b)/c' */ |
||
90 | /* (without rounding) with maximal accuracy (it uses a 64-bit */ |
||
91 | /* intermediate integer whenever necessary). */ |
||
92 | /* */ |
||
93 | /* This function isn't necessarily as fast as some processor specific */ |
||
94 | /* operations, but is at least completely portable. */ |
||
95 | /* */ |
||
96 | /* */ |
||
97 | /* a :: The first multiplier. */ |
||
98 | /* b :: The second multiplier. */ |
||
99 | /* c :: The divisor. */ |
||
100 | /* */ |
||
101 | /* |
||
102 | /* The result of `(a*b)/c'. This function never traps when trying to */ |
||
103 | /* divide by zero; it simply returns `MaxInt' or `MinInt' depending */ |
||
104 | /* on the signs of `a' and `b'. */ |
||
105 | /* */ |
||
106 | FT_BASE( FT_Long ) |
||
107 | FT_MulDiv_No_Round( FT_Long a, |
||
108 | FT_Long b, |
||
109 | FT_Long c ); |
||
110 | |||
111 | #endif /* TT_USE_BYTECODE_INTERPRETER */ |
||
112 | |||
113 | |||
114 | /* |
||
115 | * A variant of FT_Matrix_Multiply which scales its result afterwards. |
||
116 | * The idea is that both `a' and `b' are scaled by factors of 10 so that |
||
117 | * the values are as precise as possible to get a correct result during |
||
118 | * the 64bit multiplication. Let `sa' and `sb' be the scaling factors of |
||
119 | * `a' and `b', respectively, then the scaling factor of the result is |
||
120 | * `sa*sb'. |
||
121 | */ |
||
122 | FT_BASE( void ) |
||
123 | FT_Matrix_Multiply_Scaled( const FT_Matrix* a, |
||
124 | FT_Matrix *b, |
||
125 | FT_Long scaling ); |
||
126 | |||
127 | |||
128 | /* |
||
129 | * A variant of FT_Vector_Transform. See comments for |
||
130 | * FT_Matrix_Multiply_Scaled. |
||
131 | */ |
||
132 | |||
133 | FT_BASE( void ) |
||
134 | FT_Vector_Transform_Scaled( FT_Vector* vector, |
||
135 | const FT_Matrix* matrix, |
||
136 | FT_Long scaling ); |
||
137 | |||
138 | |||
139 | /* |
||
140 | * Return -1, 0, or +1, depending on the orientation of a given corner. |
||
141 | * We use the Cartesian coordinate system, with positive vertical values |
||
142 | * going upwards. The function returns +1 if the corner turns to the |
||
143 | * left, -1 to the right, and 0 for undecidable cases. |
||
144 | */ |
||
145 | FT_BASE( FT_Int ) |
||
146 | ft_corner_orientation( FT_Pos in_x, |
||
147 | FT_Pos in_y, |
||
148 | FT_Pos out_x, |
||
149 | FT_Pos out_y ); |
||
150 | |||
151 | /* |
||
152 | * Return TRUE if a corner is flat or nearly flat. This is equivalent to |
||
153 | * saying that the angle difference between the `in' and `out' vectors is |
||
154 | * very small. |
||
155 | */ |
||
156 | FT_BASE( FT_Int ) |
||
157 | ft_corner_is_flat( FT_Pos in_x, |
||
158 | FT_Pos in_y, |
||
159 | FT_Pos out_x, |
||
160 | FT_Pos out_y ); |
||
161 | |||
162 | |||
163 | #define INT_TO_F26DOT6( x ) ( (FT_Long)(x) << 6 ) |
||
164 | #define INT_TO_F2DOT14( x ) ( (FT_Long)(x) << 14 ) |
||
165 | #define INT_TO_FIXED( x ) ( (FT_Long)(x) << 16 ) |
||
166 | #define F2DOT14_TO_FIXED( x ) ( (FT_Long)(x) << 2 ) |
||
167 | #define FLOAT_TO_FIXED( x ) ( (FT_Long)( x * 65536.0 ) ) |
||
168 | #define FIXED_TO_INT( x ) ( FT_RoundFix( x ) >> 16 ) |
||
169 | |||
170 | #define ROUND_F26DOT6( x ) ( x >= 0 ? ( ( (x) + 32 ) & -64 ) \ |
||
171 | : ( -( ( 32 - (x) ) & -64 ) ) ) |
||
172 | |||
173 | |||
174 | FT_END_HEADER |
||
175 | |||
176 | #endif /* __FTCALC_H__ */ |
||
177 | |||
178 | |||
179 | /* END */><>><>><>><> |