← Back to branch summary

~ubuntu-branches/ubuntu/wily/hedgewars/wily

« back to all changes in this revision

Viewing changes to misc/libfreetype/include/freetype/internal/ftcalc.h

  • Committer: Package Import Robot
  • Author(s): Dmitry E. Oboukhov
  • Date: 2011-09-23 10:16:55 UTC
  • mfrom: (1.2.11 upstream)
  • Revision ID: package-import@ubuntu.com-20110923101655-3977th2gc5n0a3pv
Tags: 0.9.16-1
* New upstream version.
 + Downloadable content! Simply click to install any content.
   New voices, hats, maps, themes, translations, music, scripts...
   Hedgewars is now more customisable than ever before! As time goes
   by we will be soliciting community content to feature on this page,
   so remember to check it from time to time. If you decide you want
   to go back to standard Hedgewars, just remove the Data directory
   from your Hedgewars config directory.
 + 3-D rendering! Diorama-like rendering of the game in a variety
   of 3D modes. Let us know which ones work best for you, we didn't
   really have the equipment to test them all.
 + Resizable game window.
 + New utilities! The Time Box will remove one of your hedgehogs
   from the game for a while, protecting from attack until it returns,
   somewhere else on the map. Land spray will allow you to build bridges,
   seal up holes, or just make life unpleasant for your enemies.
 + New single player: Bamboo Thicket, That Sinking Feeling, Newton and
   the Tree and multi-player: The Specialists, Space Invaders,
   Racer - scripts! And a ton more script hooks for scripters
 + New twists on old weapons. Drill strike, seduction and fire have
   been adjusted. Defective mines have been added, rope can attach to
   hogs/crates/barrels again, grenades now have variable bounce (use
   precise key + 1-5). Portal gun is now more usable in flight and
   all game actions are a lot faster.
 + New theme - Golf, dozens of new community hats and a new
   localised Default voice, Ukranian.

Show diffs side-by-side

added added

removed removed

Lines of Context:
misc/libfreetype/include/freetype/internal/ftcalc.h
 
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 <ft2build.h>
 
24
#include FT_FREETYPE_H
 
25
 
 
26
 
 
27
FT_BEGIN_HEADER
 
28
 
 
29
 
 
30
  /*************************************************************************/
 
31
  /*                                                                       */
 
32
  /* <Function>                                                            */
 
33
  /*    FT_FixedSqrt                                                       */
 
34
  /*                                                                       */
 
35
  /* <Description>                                                         */
 
36
  /*    Computes the square root of a 16.16 fixed point value.             */
 
37
  /*                                                                       */
 
38
  /* <Input>                                                               */
 
39
  /*    x :: The value to compute the root for.                            */
 
40
  /*                                                                       */
 
41
  /* <Return>                                                              */
 
42
  /*    The result of `sqrt(x)'.                                           */
 
43
  /*                                                                       */
 
44
  /* <Note>                                                                */
 
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
  /* <Function>                                                            */
 
56
  /*    FT_Sqrt32                                                          */
 
57
  /*                                                                       */
 
58
  /* <Description>                                                         */
 
59
  /*    Computes the square root of an Int32 integer (which will be        */
 
60
  /*    handled as an unsigned long value).                                */
 
61
  /*                                                                       */
 
62
  /* <Input>                                                               */
 
63
  /*    x :: The value to compute the root for.                            */
 
64
  /*                                                                       */
 
65
  /* <Return>                                                              */
 
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
  /* <Function>                                                            */
 
86
  /*    FT_MulDiv_No_Round                                                 */
 
87
  /*                                                                       */
 
88
  /* <Description>                                                         */
 
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
  /* <Input>                                                               */
 
97
  /*    a :: The first multiplier.                                         */
 
98
  /*    b :: The second multiplier.                                        */
 
99
  /*    c :: The divisor.                                                  */
 
100
  /*                                                                       */
 
101
  /* <Return>                                                              */
 
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 */