clutter 2.0.0-x86-mingw32

data/vendor/local/include/cogl/cogl/cogl-euler.h

@@ -0,0 +1,251 @@
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2010 Intel Corporation.
+ *
+ * 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.
+ *
+ * Authors:
+ *   Robert Bragg <robert@linux.intel.com>
+ */
+
+#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
+#error "Only <cogl/cogl.h> can be included directly."
+#endif
+
+#ifndef __COGL_EULER_H
+#define __COGL_EULER_H
+
+#include <cogl/cogl-types.h>
+
+COGL_BEGIN_DECLS
+
+/**
+ * SECTION:cogl-euler
+ * @short_description: Functions for initializing and manipulating
+ * euler angles.
+ *
+ * Euler angles are a simple representation of a 3 dimensional
+ * rotation; comprised of 3 ordered heading, pitch and roll rotations.
+ * An important thing to understand is that the axis of rotation
+ * belong to the object being rotated and so they also rotate as each
+ * of the heading, pitch and roll rotations are applied.
+ *
+ * One way to consider euler angles is to imagine controlling an
+ * aeroplane, where you first choose a heading (Such as flying south
+ * east), then you set the pitch (such as 30 degrees to take off) and
+ * then you might set a roll, by dipping the left, wing as you prepare
+ * to turn.
+ *
+ * They have some advantages and limitations that it helps to be
+ * aware of:
+ *
+ * Advantages:
+ * <itemizedlist>
+ * <listitem>
+ * Easy to understand and use, compared to quaternions and matrices,
+ * so may be a good choice for a user interface.
+ * </listitem>
+ * <listitem>
+ * Efficient storage, needing only 3 components any rotation can be
+ * represented.
+ * <note>Actually the #CoglEuler type isn't optimized for size because
+ * we may cache the equivalent #CoglQuaternion along with a euler
+ * rotation, but it would be trivial for an application to track the
+ * components of euler rotations in a packed float array if optimizing
+ * for size was important. The values could be passed to Cogl only when
+ * manipulation is necessary.</note>
+ * </listitem>
+ * </itemizedlist>
+ *
+ * Disadvantages:
+ * <itemizedlist>
+ * <listitem>
+ * Aliasing: it's possible to represent some rotations with multiple
+ * different heading, pitch and roll rotations.
+ * </listitem>
+ * <listitem>
+ * They can suffer from a problem called Gimbal Lock. A good
+ * explanation of this can be seen on wikipedia here:
+ * http://en.wikipedia.org/wiki/Gimbal_lock but basically two
+ * of the axis of rotation may become aligned and so you loose a
+ * degree of freedom. For example a pitch of +-90° would mean that
+ * heading and bank rotate around the same axis.
+ * </listitem>
+ * <listitem>
+ * If you use euler angles to orient something in 3D space and try to
+ * transition between orientations by interpolating the component
+ * angles you probably wont get the transitions you expect as they may
+ * not follow the shortest path between the two orientations.
+ * </listitem>
+ * <listitem>
+ * There's no standard to what order the component axis rotations are
+ * applied. The most common convention seems to be what we do in Cogl
+ * with heading (y-axis), pitch (x-axis) and then roll (z-axis), but
+ * other software might apply x-axis, y-axis then z-axis or any other
+ * order so you need to consider this if you are accepting euler
+ * rotations from some other software. Other software may also use
+ * slightly different aeronautical terms, such as "yaw" instead of
+ * "heading" or "bank" instead of "roll".
+ * </listitem>
+ * </itemizedlist>
+ *
+ * To minimize the aliasing issue we may refer to "Canonical Euler"
+ * angles where heading and roll are restricted to +- 180° and pitch is
+ * restricted to +- 90°. If pitch is +- 90° bank is set to 0°.
+ *
+ * Quaternions don't suffer from Gimbal Lock and they can be nicely
+ * interpolated between, their disadvantage is that they don't have an
+ * intuitive representation.
+ *
+ * A common practice is to accept angles in the intuitive Euler form
+ * and convert them to quaternions internally to avoid Gimbal Lock and
+ * handle interpolations. See cogl_quaternion_init_from_euler().
+ */
+
+/**
+ * CoglEuler:
+ * @heading: Angle to rotate around an object's y axis
+ * @pitch: Angle to rotate around an object's x axis
+ * @roll: Angle to rotate around an object's z axis
+ *
+ * Represents an ordered rotation first of @heading degrees around an
+ * object's y axis, then @pitch degrees around an object's x axis and
+ * finally @roll degrees around an object's z axis.
+ *
+ * <note>It's important to understand the that axis are associated
+ * with the object being rotated, so the axis also rotate in sequence
+ * with the rotations being applied.</note>
+ *
+ * The members of a #CoglEuler can be initialized, for example, with
+ * cogl_euler_init() and cogl_euler_init_from_quaternion ().
+ *
+ * You may also want to look at cogl_quaternion_init_from_euler() if
+ * you want to do interpolation between 3d rotations.
+ *
+ * Since: 2.0
+ */
+struct _CoglEuler
+{
+  /*< public > */
+  float heading;
+  float pitch;
+  float roll;
+
+  /*< private > */
+  /* May cached a quaternion here in the future */
+  float padding0;
+  float padding1;
+  float padding2;
+  float padding3;
+  float padding4;
+};
+COGL_STRUCT_SIZE_ASSERT (CoglEuler, 32);
+
+/**
+ * cogl_euler_init:
+ * @euler: The #CoglEuler angle to initialize
+ * @heading: Angle to rotate around an object's y axis
+ * @pitch: Angle to rotate around an object's x axis
+ * @roll: Angle to rotate around an object's z axis
+ *
+ * Initializes @euler to represent a rotation of @x_angle degrees
+ * around the x axis, then @y_angle degrees around the y_axis and
+ * @z_angle degrees around the z axis.
+ *
+ * Since: 2.0
+ */
+void
+cogl_euler_init (CoglEuler *euler,
+                 float heading,
+                 float pitch,
+                 float roll);
+
+/**
+ * cogl_euler_init_from_matrix:
+ * @euler: The #CoglEuler angle to initialize
+ * @matrix: A #CoglMatrix containing a rotation, but no scaling,
+ *          mirroring or skewing.
+ *
+ * Extracts a euler rotation from the given @matrix and
+ * initializses @euler with the component x, y and z rotation angles.
+ */
+void
+cogl_euler_init_from_matrix (CoglEuler *euler,
+                             const CoglMatrix *matrix);
+
+/**
+ * cogl_euler_init_from_quaternion:
+ * @euler: The #CoglEuler angle to initialize
+ * @quaternion: A #CoglEuler with the rotation to initialize with
+ *
+ * Initializes a @euler rotation with the equivalent rotation
+ * represented by the given @quaternion.
+ */
+void
+cogl_euler_init_from_quaternion (CoglEuler *euler,
+                                 const CoglQuaternion *quaternion);
+
+/**
+ * cogl_euler_equal:
+ * @v1: The first euler angle to compare
+ * @v2: The second euler angle to compare
+ *
+ * Compares the two given euler angles @v1 and @v1 and it they are
+ * equal returns %TRUE else %FALSE.
+ *
+ * <note>This function only checks that all three components rotations
+ * are numerically equal, it does not consider that some rotations
+ * can be represented with different component rotations</note>
+ *
+ * Returns: %TRUE if @v1 and @v2 are equal else %FALSE.
+ * Since: 2.0
+ */
+CoglBool
+cogl_euler_equal (const void *v1, const void *v2);
+
+/**
+ * cogl_euler_copy:
+ * @src: A #CoglEuler to copy
+ *
+ * Allocates a new #CoglEuler and initilizes it with the component
+ * angles of @src. The newly allocated euler should be freed using
+ * cogl_euler_free().
+ *
+ * Returns: A newly allocated #CoglEuler
+ * Since: 2.0
+ */
+CoglEuler *
+cogl_euler_copy (const CoglEuler *src);
+
+/**
+ * cogl_euler_free:
+ * @euler: A #CoglEuler allocated via cogl_euler_copy()
+ *
+ * Frees a #CoglEuler that was previously allocated using
+ * cogl_euler_copy().
+ *
+ * Since: 2.0
+ */
+void
+cogl_euler_free (CoglEuler *euler);
+
+COGL_END_DECLS
+
+#endif /* __COGL_EULER_H */
+

data/vendor/local/include/cogl/cogl/cogl-fixed.h

@@ -0,0 +1,804 @@
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2007,2008,2009 Intel Corporation.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ */
+
+#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
+#error "Only <cogl/cogl.h> can be included directly."
+#endif
+
+#ifndef __COGL_FIXED_H__
+#define __COGL_FIXED_H__
+
+#include <cogl/cogl-types.h>
+
+/**
+ * SECTION:cogl-fixed
+ * @short_description: Fixed Point API
+ *
+ * COGL has a fixed point API targeted at platforms without a floating
+ * point unit, such as embedded devices. On such platforms this API should
+ * be preferred to the floating point one as it does not trigger the slow
+ * path of software emulation, relying on integer math for fixed-to-floating
+ * and floating-to-fixed notations conversion.
+ *
+ * It is not recommened for use on platforms with a floating point unit
+ * (e.g. desktop systems), nor for use in language bindings.
+ *
+ * Basic rules of Fixed Point arithmethic:
+ * <itemizedlist>
+ *   <listitem>
+ *     <para>Two fixed point numbers can be directly added, subtracted and
+ *     have their modulus taken.</para>
+ *   </listitem>
+ *   <listitem>
+ *     <para>To add other numerical type to a fixed point number it has to
+ *     be first converted to fixed point.</para>
+ *   </listitem>
+ *   <listitem>
+ *     <para>A fixed point number can be directly multiplied or divided by
+ *     an integer.</para>
+ *   </listitem>
+ *   <listitem>
+ *     <para>Two fixed point numbers can only be multiplied and divided by
+ *     the provided %COGL_FIXED_MUL and %COGL_FIXED_DIV macros.</para>
+ *   </listitem>
+ * </itemizedlist>
+ *
+ * The fixed point API is available since COGL 1.0.
+ */
+
+COGL_BEGIN_DECLS
+
+/**
+ * COGL_FIXED_BITS:
+ *
+ * Evaluates to the number of bits used by the #CoglFixed type.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_BITS         (32)
+
+/**
+ * COGL_FIXED_Q:
+ *
+ * Evaluates to the number of bits used for the non-integer part
+ * of the #CoglFixed type.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_Q            (COGL_FIXED_BITS - 16)
+
+/**
+ * COGL_FIXED_1:
+ *
+ * The number 1 expressed as a #CoglFixed number.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_1            (1 << COGL_FIXED_Q)
+
+/**
+ * COGL_FIXED_0_5:
+ *
+ * The number 0.5 expressed as a #CoglFixed number.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_0_5          (32768)
+
+/**
+ * COGL_FIXED_EPSILON:
+ *
+ * A very small number expressed as a #CoglFixed number.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_EPSILON      (1)
+
+/**
+ * COGL_FIXED_MAX:
+ *
+ * The biggest number representable using #CoglFixed
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_MAX          (0x7fffffff)
+
+/**
+ * COGL_FIXED_MIN:
+ *
+ * The smallest number representable using #CoglFixed
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_MIN          (0x80000000)
+
+/**
+ * COGL_FIXED_PI:
+ *
+ * The number pi, expressed as a #CoglFixed number.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_PI           (0x0003243f)
+
+/**
+ * COGL_FIXED_2_PI:
+ *
+ * Two times pi, expressed as a #CoglFixed number.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_2_PI         (0x0006487f)
+
+/**
+ * COGL_FIXED_PI_2:
+ *
+ * Half pi, expressed as a #CoglFixed number.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_PI_2         (0x00019220)
+
+/**
+ * COGL_FIXED_PI_4:
+ *
+ * pi / 4, expressed as #CoglFixed number.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_PI_4         (0x0000c910)
+
+/**
+ * COGL_FIXED_360:
+ *
+ * Evaluates to the number 360 in fixed point notation.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_360          (COGL_FIXED_FROM_INT (360))
+
+/**
+ * COGL_FIXED_270:
+ *
+ * Evaluates to the number 270 in fixed point notation.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_270          (COGL_FIXED_FROM_INT (270))
+
+/**
+ * COGL_FIXED_255:
+ *
+ * Evaluates to the number 255 in fixed point notation.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_255          (COGL_FIXED_FROM_INT (255))
+
+/**
+ * COGL_FIXED_240:
+ *
+ * Evaluates to the number 240 in fixed point notation.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_240          (COGL_FIXED_FROM_INT (240))
+
+/**
+ * COGL_FIXED_180:
+ *
+ * Evaluates to the number 180 in fixed point notation.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_180          (COGL_FIXED_FROM_INT (180))
+
+/**
+ * COGL_FIXED_120:
+ *
+ * Evaluates to the number 120 in fixed point notation.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_120          (COGL_FIXED_FROM_INT (120))
+
+/**
+ * COGL_FIXED_90:
+ *
+ * Evaluates to the number 90 in fixed point notation.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_90           (COGL_FIXED_FROM_INT (90))
+
+/**
+ * COGL_FIXED_60:
+ *
+ * Evaluates to the number 60 in fixed point notation.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_60           (COGL_FIXED_FROM_INT (60))
+
+/**
+ * COGL_FIXED_45:
+ *
+ * Evaluates to the number 45 in fixed point notation.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_45           (COGL_FIXED_FROM_INT (45))
+
+/**
+ * COGL_FIXED_30:
+ *
+ * Evaluates to the number 30 in fixed point notation.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_30           (COGL_FIXED_FROM_INT (30))
+
+/**
+ * COGL_RADIANS_TO_DEGREES:
+ *
+ * Evaluates to 180 / pi in fixed point notation.
+ *
+ * Since: 1.0
+ */
+#define COGL_RADIANS_TO_DEGREES (0x394bb8)
+
+/*
+ * conversion macros
+ */
+
+/**
+ * COGL_FIXED_FROM_FLOAT:
+ * @x: a floating point number
+ *
+ * Converts @x from a floating point to a fixed point notation.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_FROM_FLOAT(x)        ((float) cogl_double_to_fixed (x))
+
+/**
+ * COGL_FIXED_TO_FLOAT:
+ * @x: a #CoglFixed number
+ *
+ * Converts @x from a fixed point to a floating point notation, in
+ * single precision.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_TO_FLOAT(x)          ((float) ((int)(x) / 65536.0))
+
+/**
+ * COGL_FIXED_FROM_DOUBLE:
+ * @x: a floating point number
+ *
+ * Converts @x from a double precision, floating point to a fixed
+ * point notation.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_FROM_DOUBLE(x)       (cogl_double_to_fixed (x))
+
+/**
+ * COGL_FIXED_TO_DOUBLE:
+ * @x: a #CoglFixed number
+ *
+ * Converts @x from a fixed point to a floating point notation, in
+ * double precision.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_TO_DOUBLE(x)         ((double) ((int)(x) / 65536.0))
+
+/**
+ * COGL_FIXED_FROM_INT:
+ * @x: an integer number
+ *
+ * Converts @x from an integer to a fixed point notation.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_FROM_INT(x)          ((x) << COGL_FIXED_Q)
+
+/**
+ * COGL_FIXED_TO_INT:
+ * @x: a #CoglFixed number
+ *
+ * Converts @x from a fixed point notation to an integer, dropping
+ * the fractional part without rounding.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_TO_INT(x)            ((x) >> COGL_FIXED_Q)
+
+/**
+ * COGL_FLOAT_TO_INT:
+ * @x: a floatint point number
+ *
+ * Converts @x from a floating point notation to a signed integer.
+ *
+ * Since: 1.0
+ */
+#define COGL_FLOAT_TO_INT(x)            (cogl_double_to_int ((x)))
+
+/**
+ * COGL_FLOAT_TO_UINT:
+ * @x: a floatint point number
+ *
+ * Converts @x from a floating point notation to an unsigned integer.
+ *
+ * Since: 1.0
+ */
+#define COGL_FLOAT_TO_UINT(x)           (cogl_double_to_uint ((x)))
+
+/*
+ * fixed point math functions
+ */
+
+/**
+ * COGL_FIXED_FRACTION:
+ * @x: a #CoglFixed number
+ *
+ * Retrieves the fractionary part of @x.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_FRACTION(x)          ((x) & ((1 << COGL_FIXED_Q) - 1))
+
+/**
+ * COGL_FIXED_FLOOR:
+ * @x: a #CoglFixed number
+ *
+ * Rounds down a fixed point number to the previous integer.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_FLOOR(x)             (((x) >= 0) ? ((x) >> COGL_FIXED_Q) \
+                                                    : ~((~(x)) >> COGL_FIXED_Q))
+
+/**
+ * COGL_FIXED_CEIL:
+ * @x: a #CoglFixed number
+ *
+ * Rounds up a fixed point number to the next integer.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_CEIL(x)              (COGL_FIXED_FLOOR ((x) + 0xffff))
+
+/**
+ * COGL_FIXED_MUL:
+ * @a: a #CoglFixed number
+ * @b: a #CoglFixed number
+ *
+ * Computes (a * b).
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_MUL(a,b)             (cogl_fixed_mul ((a), (b)))
+
+/**
+ * COGL_FIXED_DIV:
+ * @a: a #CoglFixed number
+ * @b: a #CoglFixed number
+ *
+ * Computes (a / b).
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_DIV(a,b)             (cogl_fixed_div ((a), (b)))
+
+/**
+ * COGL_FIXED_MUL_DIV:
+ * @a: a #CoglFixed number
+ * @b: a #CoglFixed number
+ * @c: a #CoglFixed number
+ *
+ * Computes ((a * b) / c). It is logically equivalent to:
+ *
+ * |[
+ *   res = COGL_FIXED_DIV (COGL_FIXED_MUL (a, b), c);
+ * ]|
+ *
+ * But it is shorter to type.
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_MUL_DIV(a,b,c)       (cogl_fixed_mul_div ((a), (b), (c)))
+
+/**
+ * COGL_FIXED_FAST_MUL:
+ * @a: a #CoglFixed number
+ * @b: a #CoglFixed number
+ *
+ * Fast version of %COGL_FIXED_MUL, implemented as a macro.
+ *
+ * <note>This macro might lose precision. If the precision of the result
+ * is important use %COGL_FIXED_MUL instead.</note>
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_FAST_MUL(a,b)        ((a) >> 8) * ((b) >> 8)
+
+/**
+ * COGL_FIXED_FAST_DIV:
+ * @a: a #CoglFixed number
+ * @b: a #CoglFixed number
+ *
+ * Fast version of %COGL_FIXED_DIV, implemented as a macro.
+ *
+ * <note>This macro might lose precision. If the precision of the result
+ * is important use %COGL_FIXED_DIV instead.</note>
+ *
+ * Since: 1.0
+ */
+#define COGL_FIXED_FAST_DIV(a,b)        ((((a) << 8) / (b)) << 8)
+
+/**
+ * cogl_fixed_sin:
+ * @angle: a #CoglFixed number
+ *
+ * Computes the sine of @angle.
+ *
+ * Return value: the sine of the passed angle, in fixed point notation
+ *
+ * Since: 1.0
+ */
+CoglFixed
+cogl_fixed_sin (CoglFixed angle);
+
+/**
+ * cogl_fixed_tan:
+ * @angle: a #CoglFixed number
+ *
+ * Computes the tangent of @angle.
+ *
+ * Return value: the tangent of the passed angle, in fixed point notation
+ *
+ * Since: 1.0
+ */
+CoglFixed
+cogl_fixed_tan (CoglFixed angle);
+
+/**
+ * cogl_fixed_cos:
+ * @angle: a #CoglFixed number
+ *
+ * Computes the cosine of @angle.
+ *
+ * Return value: the cosine of the passed angle, in fixed point notation
+ *
+ * Since: 1.0
+ */
+CoglFixed cogl_fixed_cos (CoglFixed angle);
+
+/**
+ * cogl_fixed_atan:
+ * @a: a #CoglFixed number
+ *
+ * Computes the arc tangent of @a.
+ *
+ * Return value: the arc tangent of the passed value, in fixed point notation
+ *
+ * Since: 1.0
+ */
+CoglFixed
+cogl_fixed_atan (CoglFixed a);
+
+/**
+ * cogl_fixed_atan2:
+ * @a: the numerator as a #CoglFixed number
+ * @b: the denominator as a #CoglFixed number
+ *
+ * Computes the arc tangent of @a / @b but uses the sign of both
+ * arguments to return the angle in right quadrant.
+ *
+ * Return value: the arc tangent of the passed fraction, in fixed point
+ *   notation
+ *
+ * Since: 1.0
+ */
+CoglFixed
+cogl_fixed_atan2 (CoglFixed a,
+                  CoglFixed b);
+
+/*< public >*/
+
+/* Fixed point math routines */
+G_INLINE_FUNC CoglFixed
+cogl_fixed_mul (CoglFixed a,
+                CoglFixed b);
+
+G_INLINE_FUNC CoglFixed
+cogl_fixed_div (CoglFixed a,
+                CoglFixed b);
+
+G_INLINE_FUNC CoglFixed
+cogl_fixed_mul_div (CoglFixed a,
+                    CoglFixed b,
+                    CoglFixed c);
+
+/**
+ * COGL_SQRTI_ARG_MAX:
+ *
+ * Maximum argument that can be passed to cogl_sqrti() function.
+ *
+ * Since: 1.0
+ */
+#ifndef __SSE2__
+#define COGL_SQRTI_ARG_MAX 0x3fffff
+#else
+#define COGL_SQRTI_ARG_MAX INT_MAX
+#endif
+
+/**
+ * COGL_SQRTI_ARG_5_PERCENT:
+ *
+ * Maximum argument that can be passed to cogl_sqrti() for which the
+ * resulting error is < 5%
+ *
+ * Since: 1.0
+ */
+#ifndef __SSE2__
+#define COGL_SQRTI_ARG_5_PERCENT 210
+#else
+#define COGL_SQRTI_ARG_5_PERCENT INT_MAX
+#endif
+
+/**
+ * COGL_SQRTI_ARG_10_PERCENT:
+ *
+ * Maximum argument that can be passed to cogl_sqrti() for which the
+ * resulting error is < 10%
+ *
+ * Since: 1.0
+ */
+#ifndef __SSE2__
+#define COGL_SQRTI_ARG_10_PERCENT 5590
+#else
+#define COGL_SQRTI_ARG_10_PERCENT INT_MAX
+#endif
+
+/**
+ * cogl_fixed_sqrt:
+ * @x: a #CoglFixed number
+ *
+ * Computes the square root of @x.
+ *
+ * Return value: the square root of the passed value, in floating point
+ *   notation
+ *
+ * Since: 1.0
+ */
+CoglFixed
+cogl_fixed_sqrt (CoglFixed x);
+
+/**
+ * cogl_fixed_log2:
+ * @x: value to calculate base 2 logarithm from
+ *
+ * Calculates base 2 logarithm.
+ *
+ * This function is some 2.5 times faster on x86, and over 12 times faster on
+ * fpu-less arm, than using libc log().
+ *
+ * Return value: base 2 logarithm.
+ *
+ * Since: 1.0
+ */
+CoglFixed
+cogl_fixed_log2 (unsigned int x);
+
+/**
+ * cogl_fixed_pow2:
+ * @x: a #CoglFixed number
+ *
+ * Calculates 2 to the @x power.
+ *
+ * This function is around 11 times faster on x86, and around 22 times faster
+ * on fpu-less arm than libc pow(2, x).
+ *
+ * Return value: the power of 2 to the passed value
+ *
+ * Since: 1.0
+ */
+unsigned int
+cogl_fixed_pow2 (CoglFixed x);
+
+/**
+ * cogl_fixed_pow:
+ * @x: base
+ * @y: #CoglFixed exponent
+ *
+ * Calculates @x to the @y power.
+ *
+ * Return value: the power of @x to the @y
+ *
+ * Since: 1.0
+ */
+unsigned int
+cogl_fixed_pow  (unsigned int x,
+                 CoglFixed y);
+
+/**
+ * cogl_sqrti:
+ * @x: integer value
+ *
+ * Very fast fixed point implementation of square root for integers.
+ *
+ * This function is at least 6x faster than clib sqrt() on x86, and (this is
+ * not a typo!) about 500x faster on ARM without FPU. It's error is less than
+ * 5% for arguments smaller than %COGL_SQRTI_ARG_5_PERCENT and less than 10%
+ * for narguments smaller than %COGL_SQRTI_ARG_10_PERCENT. The maximum
+ * argument that can be passed to this function is %COGL_SQRTI_ARG_MAX.
+ *
+ * Return value: integer square root.
+ *
+ * Since: 1.0
+ */
+int
+cogl_sqrti (int x);
+
+/**
+ * COGL_ANGLE_FROM_DEG:
+ * @x: an angle in degrees in floating point notation
+ *
+ * Converts an angle in degrees into a #CoglAngle.
+ *
+ * Since: 1.0
+ */
+#define COGL_ANGLE_FROM_DEG(x)  (COGL_FLOAT_TO_INT (((float)(x) * 1024.0f) / 360.0f))
+
+/**
+ * COGL_ANGLE_TO_DEG:
+ * @x: a #CoglAngle
+ *
+ * Converts a #CoglAngle into an angle in degrees, using floatint point
+ * notation.
+ *
+ * Since: 1.0
+ */
+#define COGL_ANGLE_TO_DEG(x)    (((float)(x) * 360.0) / 1024.0)
+
+/**
+ * COGL_ANGLE_FROM_DEGX:
+ * @x: an angle in degrees in fixed point notation
+ *
+ * Converts an angle in degrees into a #CoglAngle.
+ *
+ * Since: 1.0
+ */
+#define COGL_ANGLE_FROM_DEGX(x) (COGL_FIXED_TO_INT ((((x) / 360) * 1024) + COGL_FIXED_0_5))
+
+/**
+ * COGL_ANGLE_TO_DEGX:
+ * @x: a #CoglAngle
+ *
+ * Converts a #CoglAngle into an angle in degrees, using fixed point notation
+ *
+ * Since: 1.0
+ */
+#define COGL_ANGLE_TO_DEGX(x)   (COGL_FIXED_FROM_INT ((x) * 45) / 128)
+
+/**
+ * cogl_angle_sin:
+ * @angle: an angle expressed using #CoglAngle
+ *
+ * Computes the sine of @angle
+ *
+ * Return value: the sine of the passed angle
+ *
+ * Since: 1.0
+ */
+CoglFixed
+cogl_angle_sin (CoglAngle angle);
+
+/**
+ * cogl_angle_tan:
+ * @angle: an angle expressed using #CoglAngle
+ *
+ * Computes the tangent of @angle
+ *
+ * Return value: the tangent of the passed angle
+ *
+ * Since: 1.0
+ */
+CoglFixed
+cogl_angle_tan (CoglAngle angle);
+
+/**
+ * cogl_angle_cos:
+ * @angle: an angle expressed using #CoglAngle
+ *
+ * Computes the cosine of @angle
+ *
+ * Return value: the cosine of the passed angle
+ *
+ * Since: 1.0
+ */
+CoglFixed
+cogl_angle_cos (CoglAngle angle);
+
+/*< private >*/
+
+#if defined (G_CAN_INLINE)
+G_INLINE_FUNC CoglFixed
+cogl_fixed_mul (CoglFixed a,
+                CoglFixed b)
+{
+# ifdef __arm__
+    int res_low, res_hi;
+
+    __asm__ ("smull %0, %1, %2, %3     \n"
+	     "mov   %0, %0,     lsr %4 \n"
+	     "add   %1, %0, %1, lsl %5 \n"
+	     : "=r"(res_hi), "=r"(res_low)\
+	     : "r"(a), "r"(b), "i"(COGL_FIXED_Q), "i"(32 - COGL_FIXED_Q));
+
+    return (CoglFixed) res_low;
+# else
+    long long r = (long long) a * (long long) b;
+
+    return (unsigned int)(r >> COGL_FIXED_Q);
+# endif
+}
+#endif
+
+#if defined (G_CAN_INLINE)
+G_INLINE_FUNC CoglFixed
+cogl_fixed_div (CoglFixed a,
+                CoglFixed b)
+{
+  return (CoglFixed) ((((int64_t) a) << COGL_FIXED_Q) / b);
+}
+#endif
+
+#if defined(G_CAN_INLINE)
+G_INLINE_FUNC CoglFixed
+cogl_fixed_mul_div (CoglFixed a,
+                    CoglFixed b,
+                    CoglFixed c)
+{
+  CoglFixed ab = cogl_fixed_mul (a, b);
+  CoglFixed quo = cogl_fixed_div (ab, c);
+
+  return quo;
+}
+#endif
+
+CoglFixed
+cogl_double_to_fixed (double value);
+
+int
+cogl_double_to_int   (double value);
+
+unsigned int
+cogl_double_to_uint (double value);
+
+COGL_END_DECLS
+
+#endif /* __COGL_FIXED_H__ */