diff --git a/ChangeLog b/ChangeLog index b6ebed5d3..5ac536ce4 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,15 @@ +2007-01-17 Tomas Frydrych + + * clutter/clutter-fixed.h: + * clutter/clutter-fixed.c: + * clutter/clutter-alpha.c: + Renamed clutter_fixed_sin() to clutter_sinx() and + clutter_angle_sin() to clutter_sini(); added clutter_sqrtx() + and clutter_sqrti(); added missing copyright. + + * clutter/clutter-behavior.c: + replaced call to sqrt() with clutter_sqrti() + 2007-01-16 Emmanuele Bassi * clutter/clutter-feature.c: Use clutter_vblank_method() to diff --git a/clutter/clutter-alpha.c b/clutter/clutter-alpha.c index c5f715f96..70978309d 100644 --- a/clutter/clutter-alpha.c +++ b/clutter/clutter-alpha.c @@ -513,7 +513,7 @@ sincx1024_func (ClutterAlpha *alpha, */ x = (x << 9) - (512 / angle); - sine = (clutter_angle_sin (x) + offset)/2; + sine = (clutter_sini (x) + offset)/2; CLUTTER_NOTE (ALPHA, "sine: %2f\n", CLUTTER_FIXED_TO_DOUBLE (sine)); diff --git a/clutter/clutter-behaviour-path.c b/clutter/clutter-behaviour-path.c index a7c1b11bd..4a2acdd0f 100644 --- a/clutter/clutter-behaviour-path.c +++ b/clutter/clutter-behaviour-path.c @@ -196,9 +196,8 @@ node_distance (const ClutterKnot *begin, if (clutter_knot_equal (begin, end)) return 0; - /* FIXME: need fixed point here */ - return sqrt ((end->x - begin->x) * (end->x - begin->x) + - (end->y - begin->y) * (end->y - begin->y)); + return clutter_sqrti ((end->x - begin->x) * (end->x - begin->x) + + (end->y - begin->y) * (end->y - begin->y)); } static gint diff --git a/clutter/clutter-fixed.c b/clutter/clutter-fixed.c index 253a17308..af2aa480c 100644 --- a/clutter/clutter-fixed.c +++ b/clutter/clutter-fixed.c @@ -1,3 +1,28 @@ +/* + * Clutter. + * + * An OpenGL based 'interactive canvas' library. + * + * Authored By Matthew Allum + * + * Copyright (C) 2006 OpenedHand + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + #include /* pre-computed sin table for 1st quadrant @@ -85,7 +110,7 @@ static ClutterFixed sin_tbl [] = /** - * clutter_fixed_sin: + * clutter_sinx: * @angle: a #ClutterFixed angle in radians * * Fixed point implementation of sine function @@ -95,7 +120,7 @@ static ClutterFixed sin_tbl [] = * Since: 0.2 */ ClutterFixed -clutter_fixed_sin (ClutterFixed angle) +clutter_sinx (ClutterFixed angle) { int sign = 1, indx1, indx2; ClutterFixed low, high, d1, d2; @@ -144,8 +169,6 @@ clutter_fixed_sin (ClutterFixed angle) * Handle the end of the table gracefully */ indx1 = CLUTTER_FIXED_DIV (angle, CFX_SIN_STEP); - indx2; - indx1 = CLUTTER_FIXED_INT (indx1); if (indx1 == sizeof (sin_tbl)/sizeof (ClutterFixed) - 1) @@ -173,10 +196,10 @@ clutter_fixed_sin (ClutterFixed angle) } /** - * clutter_angle_sin: + * clutter_sini: * @angle: a #ClutterAngle * - * Fast fixed point implementation of sine function. + * Very fast fixed point implementation of sine function. * * ClutterAngle is an integer such that 1024 represents * full circle. @@ -186,7 +209,7 @@ clutter_fixed_sin (ClutterFixed angle) * Since: 0.2 */ ClutterFixed -clutter_angle_sin (ClutterAngle angle) +clutter_sini (ClutterAngle angle) { int sign = 1; ClutterFixed result; @@ -232,3 +255,261 @@ clutter_angle_sin (ClutterAngle angle) return result; } + +ClutterFixed sqrt_tbl [] = +{ + 0x00000000L, 0x00010000L, 0x00016A0AL, 0x0001BB68L, + 0x00020000L, 0x00023C6FL, 0x00027312L, 0x0002A550L, + 0x0002D414L, 0x00030000L, 0x0003298BL, 0x0003510EL, + 0x000376CFL, 0x00039B05L, 0x0003BDDDL, 0x0003DF7CL, + 0x00040000L, 0x00041F84L, 0x00043E1EL, 0x00045BE1L, + 0x000478DEL, 0x00049524L, 0x0004B0BFL, 0x0004CBBCL, + 0x0004E624L, 0x00050000L, 0x00051959L, 0x00053237L, + 0x00054AA0L, 0x0005629AL, 0x00057A2BL, 0x00059159L, + 0x0005A828L, 0x0005BE9CL, 0x0005D4B9L, 0x0005EA84L, + 0x00060000L, 0x00061530L, 0x00062A17L, 0x00063EB8L, + 0x00065316L, 0x00066733L, 0x00067B12L, 0x00068EB4L, + 0x0006A21DL, 0x0006B54DL, 0x0006C847L, 0x0006DB0CL, + 0x0006ED9FL, 0x00070000L, 0x00071232L, 0x00072435L, + 0x0007360BL, 0x000747B5L, 0x00075935L, 0x00076A8CL, + 0x00077BBBL, 0x00078CC2L, 0x00079DA3L, 0x0007AE60L, + 0x0007BEF8L, 0x0007CF6DL, 0x0007DFBFL, 0x0007EFF0L, + 0x00080000L, 0x00080FF0L, 0x00081FC1L, 0x00082F73L, + 0x00083F08L, 0x00084E7FL, 0x00085DDAL, 0x00086D18L, + 0x00087C3BL, 0x00088B44L, 0x00089A32L, 0x0008A906L, + 0x0008B7C2L, 0x0008C664L, 0x0008D4EEL, 0x0008E361L, + 0x0008F1BCL, 0x00090000L, 0x00090E2EL, 0x00091C45L, + 0x00092A47L, 0x00093834L, 0x0009460CL, 0x000953CFL, + 0x0009617EL, 0x00096F19L, 0x00097CA1L, 0x00098A16L, + 0x00099777L, 0x0009A4C6L, 0x0009B203L, 0x0009BF2EL, + 0x0009CC47L, 0x0009D94FL, 0x0009E645L, 0x0009F32BL, + 0x000A0000L, 0x000A0CC5L, 0x000A1979L, 0x000A261EL, + 0x000A32B3L, 0x000A3F38L, 0x000A4BAEL, 0x000A5816L, + 0x000A646EL, 0x000A70B8L, 0x000A7CF3L, 0x000A8921L, + 0x000A9540L, 0x000AA151L, 0x000AAD55L, 0x000AB94BL, + 0x000AC534L, 0x000AD110L, 0x000ADCDFL, 0x000AE8A1L, + 0x000AF457L, 0x000B0000L, 0x000B0B9DL, 0x000B172DL, + 0x000B22B2L, 0x000B2E2BL, 0x000B3998L, 0x000B44F9L, + 0x000B504FL, 0x000B5B9AL, 0x000B66D9L, 0x000B720EL, + 0x000B7D37L, 0x000B8856L, 0x000B936AL, 0x000B9E74L, + 0x000BA973L, 0x000BB467L, 0x000BBF52L, 0x000BCA32L, + 0x000BD508L, 0x000BDFD5L, 0x000BEA98L, 0x000BF551L, + 0x000C0000L, 0x000C0AA6L, 0x000C1543L, 0x000C1FD6L, + 0x000C2A60L, 0x000C34E1L, 0x000C3F59L, 0x000C49C8L, + 0x000C542EL, 0x000C5E8CL, 0x000C68E0L, 0x000C732DL, + 0x000C7D70L, 0x000C87ACL, 0x000C91DFL, 0x000C9C0AL, + 0x000CA62CL, 0x000CB047L, 0x000CBA59L, 0x000CC464L, + 0x000CCE66L, 0x000CD861L, 0x000CE254L, 0x000CEC40L, + 0x000CF624L, 0x000D0000L, 0x000D09D5L, 0x000D13A2L, + 0x000D1D69L, 0x000D2727L, 0x000D30DFL, 0x000D3A90L, + 0x000D4439L, 0x000D4DDCL, 0x000D5777L, 0x000D610CL, + 0x000D6A9AL, 0x000D7421L, 0x000D7DA1L, 0x000D871BL, + 0x000D908EL, 0x000D99FAL, 0x000DA360L, 0x000DACBFL, + 0x000DB618L, 0x000DBF6BL, 0x000DC8B7L, 0x000DD1FEL, + 0x000DDB3DL, 0x000DE477L, 0x000DEDABL, 0x000DF6D8L, + 0x000E0000L, 0x000E0922L, 0x000E123DL, 0x000E1B53L, + 0x000E2463L, 0x000E2D6DL, 0x000E3672L, 0x000E3F70L, + 0x000E4869L, 0x000E515DL, 0x000E5A4BL, 0x000E6333L, + 0x000E6C16L, 0x000E74F3L, 0x000E7DCBL, 0x000E869DL, + 0x000E8F6BL, 0x000E9832L, 0x000EA0F5L, 0x000EA9B2L, + 0x000EB26BL, 0x000EBB1EL, 0x000EC3CBL, 0x000ECC74L, + 0x000ED518L, 0x000EDDB7L, 0x000EE650L, 0x000EEEE5L, + 0x000EF775L, 0x000F0000L, 0x000F0886L, 0x000F1107L, + 0x000F1984L, 0x000F21FCL, 0x000F2A6FL, 0x000F32DDL, + 0x000F3B47L, 0x000F43ACL, 0x000F4C0CL, 0x000F5468L, + 0x000F5CBFL, 0x000F6512L, 0x000F6D60L, 0x000F75AAL, + 0x000F7DEFL, 0x000F8630L, 0x000F8E6DL, 0x000F96A5L, + 0x000F9ED9L, 0x000FA709L, 0x000FAF34L, 0x000FB75BL, + 0x000FBF7EL, 0x000FC79DL, 0x000FCFB7L, 0x000FD7CEL, + 0x000FDFE0L, 0x000FE7EEL, 0x000FEFF8L, 0x000FF7FEL, + 0x00100000L, +}; + +/** + * clutter_sqrtx: + * @x: a #ClutterFixed + * + * A fixed point implementation of squre root + * + * Return value: square root (as fixed point). + * + * Since: 0.2 + */ +ClutterFixed +clutter_sqrtx (ClutterFixed x) +{ + /* The idea for this comes from the Alegro library, exploiting the + * fact that, + * sqrt (x) = sqrt (x/d) * sqrt (d); + * + * For d == 2^(n): + * + * sqrt (x) = sqrt (x/2^(2n)) * 2^n + * + * By locating suitable n for given x such that x >> 2n is in <0,255> + * we can use a LUT of precomputed values. + * + * This algorithm provides both good performance and precission; + * on ARM this function is about 5 times faster than c-lib sqrt, whilst + * producing errors < 1%. + * + * (There are faster algorithm's available; the Carmack 'magic' + * algorithm, http://www.codemaestro.com/reviews/review00000105.html, + * is about five times faster than this one when implemented + * as fixed point, but it's error is much greater and grows with the + * size of the argument (reaches about 10% around x == 800). + * + * Note: on systems with FPU, the clib sqrt can be noticeably faster + * than this function. + */ + int t = 0; + int sh = 0; + unsigned int mask = 0x40000000; + unsigned fract = x & 0x0000ffff; + unsigned int d1, d2; + + if (x <= 0) + return 0; + + if (x > CFX_255 || x < CFX_ONE) + { + /* + * Find the highest bit set + */ +#if __arm__ + /* This actually requires at least arm v5, but gcc does not seem + * to set the architecture defines correctly, and it is I think + * very unlikely that anyone will want to use clutter on anything + * less than v5. + */ + int bit; + __asm__ ("clz %0, %1\n" + "rsb %0, %0, #31\n" + :"=r"(bit) + :"r" (x)); + + /* make even (2n) */ + bit &= 0xfffffffe; +#else + /* TODO -- add i386 branch using bshr */ + int bit = 30; + while (bit >= 0) + { + if (x & mask) + break; + + mask = (mask >> 1 | mask >> 2); + bit -= 2; + } +#endif + + /* now bit indicates the highest bit set; there are two scenarios + * + * 1) bit < 23: Our number is smaller so we shift it left to maximase + * precision (< 16 really, since <16,23> never goes + * through here. + * + * 2) bit > 23: our number is above the table, so we shift right + */ + + sh = ((bit - 22) >> 1); + if (bit >= 8) + t = (x >> (16 - 22 + bit)); + else + t = (x << (22 - 16 - bit)); + } + else + { + t = CLUTTER_FIXED_INT (x); + } + + /* Do a weighted average of the two nearest values */ + ClutterFixed v1 = sqrt_tbl[t]; + ClutterFixed v2 = sqrt_tbl[t+1]; + + /* + * 12 is fairly arbitrary -- we want integer that is not too big to cost + * us precission + */ + d1 = (unsigned)(fract) >> 12; + d2 = ((unsigned)CFX_ONE >> 12) - d1; + + x = ((v1*d2) + (v2*d1))/(CFX_ONE >> 12); + + if (sh > 0) + x = x << sh; + else if (sh < 0) + x = (x >> (1 + ~sh)); + + return x; +} + +/** + * clutter_sqrti: + * @x: integer value + * + * A fixed point implementation of square root for integers + * + * Return value: square root (as truncated integer). + * + * + * Since: 0.2 + */ +int +clutter_sqrti (int x) +{ + int t = 0; + int sh = 0; + unsigned int mask = 0x40000000; + + if (x <= 0) + return 0; + + if (x > (sizeof (sqrt_tbl)/sizeof(ClutterFixed) - 1)) + { + /* + * Find the highest bit set + */ +#if __arm__ + /* This actually requires at least arm v5, but gcc does not seem + * to set the architecture defines correctly, and it is probably + * very unlikely that anyone will want to use clutter on anything + * less than v5. + */ + int bit; + __asm__ ("clz %0, %1\n" + "rsb %0, %0, #31\n" + :"=r"(bit) + :"r" (x)); + + /* make even (2n) */ + bit &= 0xfffffffe; +#else + /* TODO -- add i386 branch using bshr */ + int bit = 30; + while (bit >= 0) + { + if (x & mask) + break; + + mask = (mask >> 1 | mask >> 2); + bit -= 2; + } +#endif + sh = ((bit - 6) >> 1); + t = (x >> (bit - 6)); + } + else + { + return (sqrt_tbl[x] >> CFX_Q); + } + + x = sqrt_tbl[t]; + + if (sh > 0) + x = x << sh; + else if (sh < 0) + x = (x >> (1 + ~sh)); + + return (x >> CFX_Q); +} diff --git a/clutter/clutter-fixed.h b/clutter/clutter-fixed.h index a982ddfbe..9539f0e7b 100644 --- a/clutter/clutter-fixed.h +++ b/clutter/clutter-fixed.h @@ -52,6 +52,7 @@ typedef gint32 ClutterAngle; /* angle such that 1024 == 2*PI */ #define CFX_180 CLUTTER_INT_TO_FIXED (180) #define CFX_120 CLUTTER_INT_TO_FIXED (120) #define CFX_60 CLUTTER_INT_TO_FIXED (60) +#define CFX_255 CLUTTER_INT_TO_FIXED (255) #define CLUTTER_FIXED_TO_FLOAT(x) ((float)((int)(x)/65536.0)) @@ -84,12 +85,15 @@ typedef gint32 ClutterAngle; /* angle such that 1024 == 2*PI */ #define CFX_DIV CLUTTER_FIXED_DIV /* Fixed point math routines */ -ClutterFixed clutter_fixed_sin (ClutterFixed angle); -ClutterFixed clutter_angle_sin (ClutterAngle angle); +ClutterFixed clutter_sinx (ClutterFixed anx); +ClutterFixed clutter_sini (ClutterAngle angle); /* convenience macros for the cos functions */ -#define clutter_fixed_cos(x) clutter_fixed_sin((x) - CFX_PI_2) -#define clutter_angle_cos(x) clutter_fixed_sin((x) - 256) +#define clutter_cosx(x) clutter_fixed_sin((x) - CFX_PI_2) +#define clutter_cosi(x) clutter_sini((x) - 256) + +ClutterFixed clutter_sqrtx (ClutterFixed x); +int clutter_sqrti (int x); G_END_DECLS