isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-29 19:40:43 -05:00
Code Issues Packages Projects Releases Wiki Activity

2008-10-30 Emmanuele Bassi <ebassi@linux.intel.com>

Browse Source 
Bug 1209 - Move fixed point API in COGL

	* clutter/cogl/cogl-fixed.h:
	* clutter/cogl/cogl.h.in:
	* clutter/cogl/common/Makefile.am:
	* clutter/cogl/common/cogl-fixed.c: Add fixed point API, modelled
	after the ClutterFixed. The CoglFixed API supercedes the ClutterFixed
	one and avoids the dependency of COGL on Clutter's own API.

	* clutter/cogl/common/cogl-clip-stack.c:
	* clutter/cogl/common/cogl-primitives.c:
	* clutter/cogl/common/cogl-primitives.h: Update internal usage of
	ClutterFixed to CoglFixed.

	* clutter/cogl/gl/Makefile.am:
	* clutter/cogl/gl/cogl-primitives.c:
	* clutter/cogl/gl/cogl-texture.c:
	* clutter/cogl/gl/cogl.c: Ditto, in the GL implementation of the
	COGL API.

	* clutter/cogl/gles/Makefile.am:
	* clutter/cogl/gles/cogl-fbo.c:
	* clutter/cogl/gles/cogl-gles2-wrapper.c:
	* clutter/cogl/gles/cogl-primitives.c:
	* clutter/cogl/gles/cogl-texture.c:
	* clutter/cogl/gles/cogl.c: Ditto, in the GLES implementation of
	the COGL API.

	* clutter/pango/pangoclutter-glyph-cache.c:
	* clutter/pango/pangoclutter-glyph-cache.h: Ditto, in the Pango
	renderer glyphs cache.

	* clutter/clutter-fixed.c:
	* clutter/clutter-fixed.h: ClutterFixed and related API becomes
	a simple transition API for bindings and public Clutter API.

	* clutter/clutter-actor.c:
	* clutter/clutter-alpha.c:
	* clutter/clutter-backend.c:
	* clutter/clutter-behaviour-depth.c:
	* clutter/clutter-behaviour-ellipse.c:
	* clutter/clutter-behaviour-path.c:
	* clutter/clutter-behaviour-rotate.c:
	* clutter/clutter-behaviour-scale.c:
	* clutter/clutter-clone-texture.c:
	* clutter/clutter-color.c:
	* clutter/clutter-entry.c:
	* clutter/clutter-stage.c:
	* clutter/clutter-texture.c:
	* clutter/clutter-timeline.c:
	* clutter/clutter-units.h: Move from the internal usage of
	ClutterFixed to CoglFixed.

	* doc/reference/clutter/clutter-sections.txt:
	* doc/reference/cogl/cogl-docs.sgml:
	* doc/reference/cogl/cogl-sections.txt: Update the documentation.

	* tests/test-cogl-tex-tile.c:
	* tests/test-project.c: Fix tests after the API change

	* README: Add release notes.
This commit is contained in:
Emmanuele Bassi 2008-10-30 16:37:55 +00:00
parent 1b619c3843
commit 71a0be6fff
19 changed files with 2586 additions and 799 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

753
cogl-fixed.h Normal file
View File

@ -0,0 +1,753 @@
#ifndef __COGL_FIXED_H__
#define __COGL_FIXED_H__
#include <glib.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.
*/
G_BEGIN_DECLS
/**
* CoglFixed:
*
* Fixed point number using a (16.16) notation.
*/
typedef gint32 CoglFixed;
/*
* some commonly used constants
*/
/**
* 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) (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_TO_FLOAT:
* @x: a #CoglFixed number
*
* Converts @x from a fixed point to a floatint 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_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_atani:
* @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_atani (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 (guint 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
*/
guint 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
*/
guint cogl_fixed_pow (guint 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
*/
gint cogl_sqrti (gint x);
/**
* CoglAngle:
*
* Integer representation of an angle such that 1024 corresponds to
* full circle (i.e., 2 * pi).
*
* Since: 1.0
*/
typedef gint32 CoglAngle;
/**
* 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) ((((gint64) 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
extern CoglFixed cogl_double_to_fixed (double value);
extern gint cogl_double_to_int (double value);
extern guint cogl_double_to_unit (double value);
G_END_DECLS
#endif /* __COGL_FIXED_H__ */

190
cogl.h.in
View File

@ -45,10 +45,10 @@
#include <glib.h>
#include <clutter/clutter-color.h>
#include <clutter/clutter-feature.h>
#include <clutter/clutter-fixed.h>
#include <clutter/clutter-types.h>
#include <cogl/cogl-defines-@CLUTTER_COGL@.h>
#include <cogl/cogl-fixed.h>
G_BEGIN_DECLS
@ -210,8 +210,8 @@ typedef enum
*/
struct _CoglTextureVertex
{
ClutterFixed x, y, z;
ClutterFixed tx, ty;
CoglFixed x, y, z;
CoglFixed tx, ty;
ClutterColor color;
};
@ -341,10 +341,10 @@ void cogl_get_bitmasks (gint *red,
* Replaces the current projection matrix with a perspective matrix
* based on the provided values.
*/
void cogl_perspective (ClutterFixed fovy,
ClutterFixed aspect,
ClutterFixed z_near,
ClutterFixed z_far);
void cogl_perspective (CoglFixed fovy,
CoglFixed aspect,
CoglFixed z_near,
CoglFixed z_far);
/**
* cogl_frustum:
@ -360,12 +360,12 @@ void cogl_perspective (ClutterFixed fovy,
*
* Since: 0.8.2
*/
void cogl_frustum (ClutterFixed left,
ClutterFixed right,
ClutterFixed bottom,
ClutterFixed top,
ClutterFixed z_near,
ClutterFixed z_far);
void cogl_frustum (CoglFixed left,
CoglFixed right,
CoglFixed bottom,
CoglFixed top,
CoglFixed z_near,
CoglFixed z_far);
/**
* cogl_setup_viewport:
@ -385,10 +385,10 @@ void cogl_frustum (ClutterFixed left,
*/
void cogl_setup_viewport (guint width,
guint height,
ClutterFixed fovy,
ClutterFixed aspect,
ClutterFixed z_near,
ClutterFixed z_far);
CoglFixed fovy,
CoglFixed aspect,
CoglFixed z_near,
CoglFixed z_far);
/**
* cogl_viewport:
@ -425,8 +425,8 @@ void cogl_pop_matrix (void);
* Multiplies the current model-view matrix by one that scales the x
* and y axes by the given values.
*/
void cogl_scale (ClutterFixed x,
ClutterFixed y);
void cogl_scale (CoglFixed x,
CoglFixed y);
/**
* cogl_translatex:
@ -437,9 +437,9 @@ void cogl_scale (ClutterFixed x,
* Multiplies the current model-view matrix by one that translates the
* model along all three axes according to the given values.
*/
void cogl_translatex (ClutterFixed x,
ClutterFixed y,
ClutterFixed z);
void cogl_translatex (CoglFixed x,
CoglFixed y,
CoglFixed z);
/**
* cogl_translate:
@ -468,7 +468,7 @@ void cogl_translate (gint x,
* degrees about the vertex (0, 0, 1) causes a small counter-clockwise
* rotation.
*/
void cogl_rotatex (ClutterFixed angle,
void cogl_rotatex (CoglFixed angle,
gint x,
gint y,
gint z);
@ -491,32 +491,32 @@ void cogl_rotate (gint angle,
/**
* cogl_get_modelview_matrix:
* @m: pointer to a 4x4 array of #ClutterFixed<!-- -->s to receive the matrix
* @m: pointer to a 4x4 array of #CoglFixed<!-- -->s to receive the matrix
*
* Stores the current model-view matrix in @m. The matrix is in
* column-major order.
*/
void cogl_get_modelview_matrix (ClutterFixed m[16]);
void cogl_get_modelview_matrix (CoglFixed m[16]);
/**
* cogl_get_projection_matrix:
* @m: pointer to a 4x4 array of #ClutterFixed<!-- -->s to receive the matrix
* @m: pointer to a 4x4 array of #CoglFixed<!-- -->s to receive the matrix
*
* Stores the current projection matrix in @m. The matrix is in
* column-major order.
*/
void cogl_get_projection_matrix (ClutterFixed m[16]);
void cogl_get_projection_matrix (CoglFixed m[16]);
/**
* cogl_get_viewport:
* @v: pointer to a 4 element array of #ClutterFixed<!-- -->s to
* @v: pointer to a 4 element array of #CoglFixed<!-- -->s to
* receive the viewport dimensions.
*
* Stores the current viewport in @v. @v[0] and @v[1] get the x and y
* position of the viewport and @v[2] and @v[3] get the width and
* height.
*/
void cogl_get_viewport (ClutterFixed v[4]);
void cogl_get_viewport (CoglFixed v[4]);
/**
* cogl_clip_set:
@ -531,10 +531,10 @@ void cogl_get_viewport (ClutterFixed v[4]);
* be displayed. The rectangle dimensions are transformed by the
* current model-view matrix.
*/
void cogl_clip_set (ClutterFixed x_offset,
ClutterFixed y_offset,
ClutterFixed width,
ClutterFixed height);
void cogl_clip_set (CoglFixed x_offset,
CoglFixed y_offset,
CoglFixed width,
CoglFixed height);
/**
* cogl_clip_unset:
@ -602,7 +602,7 @@ void cogl_enable_backface_culling (gboolean setting);
* initial reference value is 1.0.
*/
void cogl_alpha_func (COGLenum func,
ClutterFixed ref);
CoglFixed ref);
/**
* cogl_fog_set:
@ -619,9 +619,9 @@ void cogl_alpha_func (COGLenum func,
* cogl_paint_init().
*/
void cogl_fog_set (const ClutterColor *fog_color,
ClutterFixed density,
ClutterFixed z_near,
ClutterFixed z_far);
CoglFixed density,
CoglFixed z_near,
CoglFixed z_far);
/**
* cogl_paint_init:
@ -954,14 +954,14 @@ void cogl_texture_unref (CoglHandle handle);
* texture pass in @tx1=0.0 @ty1=0.0 @tx2=1.0 @ty2=1.0.
*/
void cogl_texture_rectangle (CoglHandle handle,
ClutterFixed x1,
ClutterFixed y1,
ClutterFixed x2,
ClutterFixed y2,
ClutterFixed tx1,
ClutterFixed ty1,
ClutterFixed tx2,
ClutterFixed ty2);
CoglFixed x1,
CoglFixed y1,
CoglFixed x2,
CoglFixed y2,
CoglFixed tx1,
CoglFixed ty1,
CoglFixed tx2,
CoglFixed ty2);
/**
* cogl_texture_polygon:
@ -1051,10 +1051,10 @@ void cogl_rectangle (gint x,
*
* A fixed-point version of cogl_fast_fill_rectangle.
**/
void cogl_rectanglex (ClutterFixed x,
ClutterFixed y,
ClutterFixed width,
ClutterFixed height);
void cogl_rectanglex (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height);
/**
* cogl_path_fill:
@ -1081,8 +1081,8 @@ void cogl_path_stroke (void);
* Clears the previously constructed shape and begins a new path
* contour by moving the pen to the given coordinates.
**/
void cogl_path_move_to (ClutterFixed x,
ClutterFixed y);
void cogl_path_move_to (CoglFixed x,
CoglFixed y);
/**
@ -1094,8 +1094,8 @@ void cogl_path_move_to (ClutterFixed x,
* contour by moving the pen to the given coordinates relative
* to the current pen location.
**/
void cogl_path_rel_move_to (ClutterFixed x,
ClutterFixed y);
void cogl_path_rel_move_to (CoglFixed x,
CoglFixed y);
/**
* cogl_path_line_to:
@ -1105,8 +1105,8 @@ void cogl_path_rel_move_to (ClutterFixed x,
* Adds a straight line segment to the current path that ends at the
* given coordinates.
**/
void cogl_path_line_to (ClutterFixed x,
ClutterFixed y);
void cogl_path_line_to (CoglFixed x,
CoglFixed y);
/**
* cogl_path_rel_line_to:
@ -1116,8 +1116,8 @@ void cogl_path_line_to (ClutterFixed x,
* Adds a straight line segment to the current path that ends at the
* given coordinates relative to the current pen location.
**/
void cogl_path_rel_line_to (ClutterFixed x,
ClutterFixed y);
void cogl_path_rel_line_to (CoglFixed x,
CoglFixed y);
/**
@ -1134,12 +1134,12 @@ void cogl_path_rel_line_to (ClutterFixed x,
* of the arc. If you perform a move_to to the arcs start just before
* drawing it you create a free standing arc.
**/
void cogl_path_arc (ClutterFixed center_x,
ClutterFixed center_y,
ClutterFixed radius_x,
ClutterFixed radius_y,
ClutterAngle angle_1,
ClutterAngle angle_2);
void cogl_path_arc (CoglFixed center_x,
CoglFixed center_y,
CoglFixed radius_x,
CoglFixed radius_y,
CoglAngle angle_1,
CoglAngle angle_2);
@ -1156,12 +1156,12 @@ void cogl_path_arc (ClutterFixed center_x,
* second, third and fourth control points and using current pen location
* as the first control point.
**/
void cogl_path_curve_to (ClutterFixed x1,
ClutterFixed y1,
ClutterFixed x2,
ClutterFixed y2,
ClutterFixed x3,
ClutterFixed y3);
void cogl_path_curve_to (CoglFixed x1,
CoglFixed y1,
CoglFixed x2,
CoglFixed y2,
CoglFixed x3,
CoglFixed y3);
/**
* cogl_path_rel_curve_to:
@ -1177,12 +1177,12 @@ void cogl_path_curve_to (ClutterFixed x1,
* as the first control point. The given coordinates are relative to the
* current pen location.
*/
void cogl_path_rel_curve_to (ClutterFixed x1,
ClutterFixed y1,
ClutterFixed x2,
ClutterFixed y2,
ClutterFixed x3,
ClutterFixed y3);
void cogl_path_rel_curve_to (CoglFixed x1,
CoglFixed y1,
CoglFixed x2,
CoglFixed y2,
CoglFixed x3,
CoglFixed y3);
/**
* cogl_path_close:
@ -1202,10 +1202,10 @@ void cogl_path_close (void);
* Clears the previously constructed shape and constructs a straight
* line shape start and ending at the given coordinates.
**/
void cogl_path_line (ClutterFixed x1,
ClutterFixed y1,
ClutterFixed x2,
ClutterFixed y2);
void cogl_path_line (CoglFixed x1,
CoglFixed y1,
CoglFixed x2,
CoglFixed y2);
/**
* cogl_path_polyline:
@ -1224,7 +1224,7 @@ void cogl_path_line (ClutterFixed x1,
* fashion for the rest of the vertices. (num_points - 1) segments will
* be constructed.
**/
void cogl_path_polyline (ClutterFixed *coords,
void cogl_path_polyline (CoglFixed *coords,
gint num_points);
@ -1242,7 +1242,7 @@ void cogl_path_polyline (ClutterFixed *coords,
* represents the Y coordinate of the first vertex, continuing in the same
* fashion for the rest of the vertices.
**/
void cogl_path_polygon (ClutterFixed *coords,
void cogl_path_polygon (CoglFixed *coords,
gint num_points);
@ -1256,10 +1256,10 @@ void cogl_path_polygon (ClutterFixed *coords,
* Clears the previously constructed shape and constructs a rectangular
* shape at the given coordinates.
**/
void cogl_path_rectangle (ClutterFixed x,
ClutterFixed y,
ClutterFixed width,
ClutterFixed height);
void cogl_path_rectangle (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height);
/**
* cogl_path_ellipse:
@ -1271,10 +1271,10 @@ void cogl_path_rectangle (ClutterFixed x,
* Clears the previously constructed shape and constructs an ellipse
* shape.
**/
void cogl_path_ellipse (ClutterFixed center_x,
ClutterFixed center_y,
ClutterFixed radius_x,
ClutterFixed radius_y);
void cogl_path_ellipse (CoglFixed center_x,
CoglFixed center_y,
CoglFixed radius_x,
CoglFixed radius_y);
/**
* cogl_path_round_rectangle:
@ -1289,12 +1289,12 @@ void cogl_path_ellipse (ClutterFixed center_x,
* Clears the previously constructed shape and constructs a rectangular
* shape with rounded corners.
**/
void cogl_path_round_rectangle (ClutterFixed x,
ClutterFixed y,
ClutterFixed width,
ClutterFixed height,
ClutterFixed radius,
ClutterAngle arc_step);
void cogl_path_round_rectangle (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height,
CoglFixed radius,
CoglAngle arc_step);
/**
* SECTION:cogl-shaders

3
common/Makefile.am
View File

@ -25,4 +25,5 @@ libclutter_cogl_common_la_SOURCES = \
cogl-primitives.c \
cogl-bitmap-pixbuf.c \
cogl-clip-stack.h \
cogl-clip-stack.c
cogl-clip-stack.c \
cogl-fixed.c

36
common/cogl-clip-stack.c
View File

@ -32,19 +32,19 @@
/* These are defined in the particular backend (float in GL vs fixed
in GL ES) */
void _cogl_set_clip_planes (ClutterFixed x,
ClutterFixed y,
ClutterFixed width,
ClutterFixed height);
void _cogl_set_clip_planes (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height);
void _cogl_init_stencil_buffer (void);
void _cogl_add_stencil_clip (ClutterFixed x,
ClutterFixed y,
ClutterFixed width,
ClutterFixed height,
void _cogl_add_stencil_clip (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height,
gboolean first);
void _cogl_disable_clip_planes (void);
void _cogl_disable_stencil_buffer (void);
void _cogl_set_matrix (const ClutterFixed *matrix);
void _cogl_set_matrix (const CoglFixed *matrix);
typedef struct _CoglClipStackEntry CoglClipStackEntry;
@ -57,13 +57,13 @@ struct _CoglClipStackEntry
gboolean clear;
/* The rectangle for this clip */
ClutterFixed x_offset;
ClutterFixed y_offset;
ClutterFixed width;
ClutterFixed height;
CoglFixed x_offset;
CoglFixed y_offset;
CoglFixed width;
CoglFixed height;
/* The matrix that was current when the clip was set */
ClutterFixed matrix[16];
CoglFixed matrix[16];
};
static GList *cogl_clip_stack_top = NULL;
@ -90,10 +90,10 @@ _cogl_clip_stack_add (const CoglClipStackEntry *entry, int depth)
}
void
cogl_clip_set (ClutterFixed x_offset,
ClutterFixed y_offset,
ClutterFixed width,
ClutterFixed height)
cogl_clip_set (CoglFixed x_offset,
CoglFixed y_offset,
CoglFixed width,
CoglFixed height)
{
CoglClipStackEntry *entry = g_slice_new (CoglClipStackEntry);

911
common/cogl-fixed.c Normal file
View File

@ -0,0 +1,911 @@
#define G_IMPLEMENT_INLINES
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "cogl-fixed.h"
/* pre-computed sin table for 1st quadrant
*
* Currently contains 257 entries.
*
* The current error (compared to system sin) is about
* 0.5% for values near the start of the table where the
* curve is steep, but improving rapidly. If this precision
* is not enough, we can increase the size of the table
*/
static const CoglFixed sin_tbl[] =
{
0x00000000L, 0x00000192L, 0x00000324L, 0x000004B6L,
0x00000648L, 0x000007DAL, 0x0000096CL, 0x00000AFEL,
0x00000C90L, 0x00000E21L, 0x00000FB3L, 0x00001144L,
0x000012D5L, 0x00001466L, 0x000015F7L, 0x00001787L,
0x00001918L, 0x00001AA8L, 0x00001C38L, 0x00001DC7L,
0x00001F56L, 0x000020E5L, 0x00002274L, 0x00002402L,
0x00002590L, 0x0000271EL, 0x000028ABL, 0x00002A38L,
0x00002BC4L, 0x00002D50L, 0x00002EDCL, 0x00003067L,
0x000031F1L, 0x0000337CL, 0x00003505L, 0x0000368EL,
0x00003817L, 0x0000399FL, 0x00003B27L, 0x00003CAEL,
0x00003E34L, 0x00003FBAL, 0x0000413FL, 0x000042C3L,
0x00004447L, 0x000045CBL, 0x0000474DL, 0x000048CFL,
0x00004A50L, 0x00004BD1L, 0x00004D50L, 0x00004ECFL,
0x0000504DL, 0x000051CBL, 0x00005348L, 0x000054C3L,
0x0000563EL, 0x000057B9L, 0x00005932L, 0x00005AAAL,
0x00005C22L, 0x00005D99L, 0x00005F0FL, 0x00006084L,
0x000061F8L, 0x0000636BL, 0x000064DDL, 0x0000664EL,
0x000067BEL, 0x0000692DL, 0x00006A9BL, 0x00006C08L,
0x00006D74L, 0x00006EDFL, 0x00007049L, 0x000071B2L,
0x0000731AL, 0x00007480L, 0x000075E6L, 0x0000774AL,
0x000078ADL, 0x00007A10L, 0x00007B70L, 0x00007CD0L,
0x00007E2FL, 0x00007F8CL, 0x000080E8L, 0x00008243L,
0x0000839CL, 0x000084F5L, 0x0000864CL, 0x000087A1L,
0x000088F6L, 0x00008A49L, 0x00008B9AL, 0x00008CEBL,
0x00008E3AL, 0x00008F88L, 0x000090D4L, 0x0000921FL,
0x00009368L, 0x000094B0L, 0x000095F7L, 0x0000973CL,
0x00009880L, 0x000099C2L, 0x00009B03L, 0x00009C42L,
0x00009D80L, 0x00009EBCL, 0x00009FF7L, 0x0000A130L,
0x0000A268L, 0x0000A39EL, 0x0000A4D2L, 0x0000A605L,
0x0000A736L, 0x0000A866L, 0x0000A994L, 0x0000AAC1L,
0x0000ABEBL, 0x0000AD14L, 0x0000AE3CL, 0x0000AF62L,
0x0000B086L, 0x0000B1A8L, 0x0000B2C9L, 0x0000B3E8L,
0x0000B505L, 0x0000B620L, 0x0000B73AL, 0x0000B852L,
0x0000B968L, 0x0000BA7DL, 0x0000BB8FL, 0x0000BCA0L,
0x0000BDAFL, 0x0000BEBCL, 0x0000BFC7L, 0x0000C0D1L,
0x0000C1D8L, 0x0000C2DEL, 0x0000C3E2L, 0x0000C4E4L,
0x0000C5E4L, 0x0000C6E2L, 0x0000C7DEL, 0x0000C8D9L,
0x0000C9D1L, 0x0000CAC7L, 0x0000CBBCL, 0x0000CCAEL,
0x0000CD9FL, 0x0000CE8EL, 0x0000CF7AL, 0x0000D065L,
0x0000D14DL, 0x0000D234L, 0x0000D318L, 0x0000D3FBL,
0x0000D4DBL, 0x0000D5BAL, 0x0000D696L, 0x0000D770L,
0x0000D848L, 0x0000D91EL, 0x0000D9F2L, 0x0000DAC4L,
0x0000DB94L, 0x0000DC62L, 0x0000DD2DL, 0x0000DDF7L,
0x0000DEBEL, 0x0000DF83L, 0x0000E046L, 0x0000E107L,
0x0000E1C6L, 0x0000E282L, 0x0000E33CL, 0x0000E3F4L,
0x0000E4AAL, 0x0000E55EL, 0x0000E610L, 0x0000E6BFL,
0x0000E76CL, 0x0000E817L, 0x0000E8BFL, 0x0000E966L,
0x0000EA0AL, 0x0000EAABL, 0x0000EB4BL, 0x0000EBE8L,
0x0000EC83L, 0x0000ED1CL, 0x0000EDB3L, 0x0000EE47L,
0x0000EED9L, 0x0000EF68L, 0x0000EFF5L, 0x0000F080L,
0x0000F109L, 0x0000F18FL, 0x0000F213L, 0x0000F295L,
0x0000F314L, 0x0000F391L, 0x0000F40CL, 0x0000F484L,
0x0000F4FAL, 0x0000F56EL, 0x0000F5DFL, 0x0000F64EL,
0x0000F6BAL, 0x0000F724L, 0x0000F78CL, 0x0000F7F1L,
0x0000F854L, 0x0000F8B4L, 0x0000F913L, 0x0000F96EL,
0x0000F9C8L, 0x0000FA1FL, 0x0000FA73L, 0x0000FAC5L,
0x0000FB15L, 0x0000FB62L, 0x0000FBADL, 0x0000FBF5L,
0x0000FC3BL, 0x0000FC7FL, 0x0000FCC0L, 0x0000FCFEL,
0x0000FD3BL, 0x0000FD74L, 0x0000FDACL, 0x0000FDE1L,
0x0000FE13L, 0x0000FE43L, 0x0000FE71L, 0x0000FE9CL,
0x0000FEC4L, 0x0000FEEBL, 0x0000FF0EL, 0x0000FF30L,
0x0000FF4EL, 0x0000FF6BL, 0x0000FF85L, 0x0000FF9CL,
0x0000FFB1L, 0x0000FFC4L, 0x0000FFD4L, 0x0000FFE1L,
0x0000FFECL, 0x0000FFF5L, 0x0000FFFBL, 0x0000FFFFL,
0x00010000L,
};
/* pre-computed tan table for 1st quadrant */
static const CoglFixed tan_tbl[] =
{
0x00000000L, 0x00000192L, 0x00000324L, 0x000004b7L,
0x00000649L, 0x000007dbL, 0x0000096eL, 0x00000b01L,
0x00000c94L, 0x00000e27L, 0x00000fbaL, 0x0000114eL,
0x000012e2L, 0x00001477L, 0x0000160cL, 0x000017a1L,
0x00001937L, 0x00001acdL, 0x00001c64L, 0x00001dfbL,
0x00001f93L, 0x0000212cL, 0x000022c5L, 0x0000245fL,
0x000025f9L, 0x00002795L, 0x00002931L, 0x00002aceL,
0x00002c6cL, 0x00002e0aL, 0x00002faaL, 0x0000314aL,
0x000032ecL, 0x0000348eL, 0x00003632L, 0x000037d7L,
0x0000397dL, 0x00003b24L, 0x00003cccL, 0x00003e75L,
0x00004020L, 0x000041ccL, 0x00004379L, 0x00004528L,
0x000046d8L, 0x0000488aL, 0x00004a3dL, 0x00004bf2L,
0x00004da8L, 0x00004f60L, 0x0000511aL, 0x000052d5L,
0x00005492L, 0x00005651L, 0x00005812L, 0x000059d5L,
0x00005b99L, 0x00005d60L, 0x00005f28L, 0x000060f3L,
0x000062c0L, 0x0000648fL, 0x00006660L, 0x00006834L,
0x00006a0aL, 0x00006be2L, 0x00006dbdL, 0x00006f9aL,
0x0000717aL, 0x0000735dL, 0x00007542L, 0x0000772aL,
0x00007914L, 0x00007b02L, 0x00007cf2L, 0x00007ee6L,
0x000080dcL, 0x000082d6L, 0x000084d2L, 0x000086d2L,
0x000088d6L, 0x00008adcL, 0x00008ce7L, 0x00008ef4L,
0x00009106L, 0x0000931bL, 0x00009534L, 0x00009750L,
0x00009971L, 0x00009b95L, 0x00009dbeL, 0x00009febL,
0x0000a21cL, 0x0000a452L, 0x0000a68cL, 0x0000a8caL,
0x0000ab0eL, 0x0000ad56L, 0x0000afa3L, 0x0000b1f5L,
0x0000b44cL, 0x0000b6a8L, 0x0000b909L, 0x0000bb70L,
0x0000bdddL, 0x0000c04fL, 0x0000c2c7L, 0x0000c545L,
0x0000c7c9L, 0x0000ca53L, 0x0000cce3L, 0x0000cf7aL,
0x0000d218L, 0x0000d4bcL, 0x0000d768L, 0x0000da1aL,
0x0000dcd4L, 0x0000df95L, 0x0000e25eL, 0x0000e52eL,
0x0000e806L, 0x0000eae7L, 0x0000edd0L, 0x0000f0c1L,
0x0000f3bbL, 0x0000f6bfL, 0x0000f9cbL, 0x0000fce1L,
0x00010000L, 0x00010329L, 0x0001065dL, 0x0001099aL,
0x00010ce3L, 0x00011036L, 0x00011394L, 0x000116feL,
0x00011a74L, 0x00011df6L, 0x00012184L, 0x0001251fL,
0x000128c6L, 0x00012c7cL, 0x0001303fL, 0x00013410L,
0x000137f0L, 0x00013bdfL, 0x00013fddL, 0x000143ebL,
0x00014809L, 0x00014c37L, 0x00015077L, 0x000154c9L,
0x0001592dL, 0x00015da4L, 0x0001622eL, 0x000166ccL,
0x00016b7eL, 0x00017045L, 0x00017523L, 0x00017a17L,
0x00017f22L, 0x00018444L, 0x00018980L, 0x00018ed5L,
0x00019445L, 0x000199cfL, 0x00019f76L, 0x0001a53aL,
0x0001ab1cL, 0x0001b11dL, 0x0001b73fL, 0x0001bd82L,
0x0001c3e7L, 0x0001ca71L, 0x0001d11fL, 0x0001d7f4L,
0x0001def1L, 0x0001e618L, 0x0001ed6aL, 0x0001f4e8L,
0x0001fc96L, 0x00020473L, 0x00020c84L, 0x000214c9L,
0x00021d44L, 0x000225f9L, 0x00022ee9L, 0x00023818L,
0x00024187L, 0x00024b3aL, 0x00025534L, 0x00025f78L,
0x00026a0aL, 0x000274edL, 0x00028026L, 0x00028bb8L,
0x000297a8L, 0x0002a3fbL, 0x0002b0b5L, 0x0002bdddL,
0x0002cb79L, 0x0002d98eL, 0x0002e823L, 0x0002f740L,
0x000306ecL, 0x00031730L, 0x00032816L, 0x000339a6L,
0x00034bebL, 0x00035ef2L, 0x000372c6L, 0x00038776L,
0x00039d11L, 0x0003b3a6L, 0x0003cb48L, 0x0003e40aL,
0x0003fe02L, 0x00041949L, 0x000435f7L, 0x0004542bL,
0x00047405L, 0x000495a9L, 0x0004b940L, 0x0004def6L,
0x00050700L, 0x00053196L, 0x00055ef9L, 0x00058f75L,
0x0005c35dL, 0x0005fb14L, 0x00063709L, 0x000677c0L,
0x0006bdd0L, 0x000709ecL, 0x00075ce6L, 0x0007b7bbL,
0x00081b98L, 0x000889e9L, 0x0009046eL, 0x00098d4dL,
0x000a2736L, 0x000ad593L, 0x000b9cc6L, 0x000c828aL,
0x000d8e82L, 0x000ecb1bL, 0x001046eaL, 0x00121703L,
0x00145b00L, 0x0017448dL, 0x001b2672L, 0x002095afL,
0x0028bc49L, 0x0036519aL, 0x00517bb6L, 0x00a2f8fdL,
0x46d3eab2L,
};
/* 257-value table of atan.
*
* atan_tbl[0] is atan(0.0) and atan_tbl[256] is atan(1).
* The angles are radians in CoglFixed truncated to 16-bit (they're
* all less than one)
*/
static const guint16 atan_tbl[] =
{
0x0000, 0x00FF, 0x01FF, 0x02FF, 0x03FF, 0x04FF, 0x05FF, 0x06FF,
0x07FF, 0x08FF, 0x09FE, 0x0AFE, 0x0BFD, 0x0CFD, 0x0DFC, 0x0EFB,
0x0FFA, 0x10F9, 0x11F8, 0x12F7, 0x13F5, 0x14F3, 0x15F2, 0x16F0,
0x17EE, 0x18EB, 0x19E9, 0x1AE6, 0x1BE3, 0x1CE0, 0x1DDD, 0x1ED9,
0x1FD5, 0x20D1, 0x21CD, 0x22C8, 0x23C3, 0x24BE, 0x25B9, 0x26B3,
0x27AD, 0x28A7, 0x29A1, 0x2A9A, 0x2B93, 0x2C8B, 0x2D83, 0x2E7B,
0x2F72, 0x306A, 0x3160, 0x3257, 0x334D, 0x3442, 0x3538, 0x362D,
0x3721, 0x3815, 0x3909, 0x39FC, 0x3AEF, 0x3BE2, 0x3CD4, 0x3DC5,
0x3EB6, 0x3FA7, 0x4097, 0x4187, 0x4277, 0x4365, 0x4454, 0x4542,
0x462F, 0x471C, 0x4809, 0x48F5, 0x49E0, 0x4ACB, 0x4BB6, 0x4CA0,
0x4D89, 0x4E72, 0x4F5B, 0x5043, 0x512A, 0x5211, 0x52F7, 0x53DD,
0x54C2, 0x55A7, 0x568B, 0x576F, 0x5852, 0x5934, 0x5A16, 0x5AF7,
0x5BD8, 0x5CB8, 0x5D98, 0x5E77, 0x5F55, 0x6033, 0x6110, 0x61ED,
0x62C9, 0x63A4, 0x647F, 0x6559, 0x6633, 0x670C, 0x67E4, 0x68BC,
0x6993, 0x6A6A, 0x6B40, 0x6C15, 0x6CEA, 0x6DBE, 0x6E91, 0x6F64,
0x7036, 0x7108, 0x71D9, 0x72A9, 0x7379, 0x7448, 0x7516, 0x75E4,
0x76B1, 0x777E, 0x7849, 0x7915, 0x79DF, 0x7AA9, 0x7B72, 0x7C3B,
0x7D03, 0x7DCA, 0x7E91, 0x7F57, 0x801C, 0x80E1, 0x81A5, 0x8269,
0x832B, 0x83EE, 0x84AF, 0x8570, 0x8630, 0x86F0, 0x87AF, 0x886D,
0x892A, 0x89E7, 0x8AA4, 0x8B5F, 0x8C1A, 0x8CD5, 0x8D8E, 0x8E47,
0x8F00, 0x8FB8, 0x906F, 0x9125, 0x91DB, 0x9290, 0x9345, 0x93F9,
0x94AC, 0x955F, 0x9611, 0x96C2, 0x9773, 0x9823, 0x98D2, 0x9981,
0x9A2F, 0x9ADD, 0x9B89, 0x9C36, 0x9CE1, 0x9D8C, 0x9E37, 0x9EE0,
0x9F89, 0xA032, 0xA0DA, 0xA181, 0xA228, 0xA2CE, 0xA373, 0xA418,
0xA4BC, 0xA560, 0xA602, 0xA6A5, 0xA746, 0xA7E8, 0xA888, 0xA928,
0xA9C7, 0xAA66, 0xAB04, 0xABA1, 0xAC3E, 0xACDB, 0xAD76, 0xAE11,
0xAEAC, 0xAF46, 0xAFDF, 0xB078, 0xB110, 0xB1A7, 0xB23E, 0xB2D5,
0xB36B, 0xB400, 0xB495, 0xB529, 0xB5BC, 0xB64F, 0xB6E2, 0xB773,
0xB805, 0xB895, 0xB926, 0xB9B5, 0xBA44, 0xBAD3, 0xBB61, 0xBBEE,
0xBC7B, 0xBD07, 0xBD93, 0xBE1E, 0xBEA9, 0xBF33, 0xBFBC, 0xC046,
0xC0CE, 0xC156, 0xC1DD, 0xC264, 0xC2EB, 0xC371, 0xC3F6, 0xC47B,
0xC4FF, 0xC583, 0xC606, 0xC689, 0xC70B, 0xC78D, 0xC80E, 0xC88F,
0xC90F
};
/* look up table for square root */
static const CoglFixed 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,
};
/* the difference of the angle for two adjacent values in the
* sin_tbl table, expressed as CoglFixed number
*/
#define COGL_SIN_STEP 0x00000192
static const double _magic = 68719476736.0 * 1.5;
/* Where in the 64 bits of double is the mantissa.
*
* FIXME - this should go inside the configure.ac
*/
#if (__FLOAT_WORD_ORDER == 1234)
#define _COGL_MAN 0
#elif (__FLOAT_WORD_ORDER == 4321)
#define _COGL_MAN 1
#else
#define COGL_NO_FAST_CONVERSIONS
#endif
/*
* cogl_double_to_fixed :
* @value: value to be converted
*
* A fast conversion from double precision floating to fixed point
*
* Return value: Fixed point representation of the value
*/
CoglFixed
cogl_double_to_fixed (double val)
{
#ifdef COGL_NO_FAST_CONVERSIONS
return (CoglFixed) (val * (double) COGL_FIXED_1);
#else
union {
double d;
unsigned int i[2];
} dbl;
dbl.d = val;
dbl.d = dbl.d + _magic;
return dbl.i[_COGL_MAN];
#endif
}
/*
* cogl_double_to_int :
* @value: value to be converted
*
* A fast conversion from doulbe precision floatint point to int;
* used this instead of casting double/float to int.
*
* Return value: Integer part of the double
*/
gint
cogl_double_to_int (double val)
{
#ifdef COGL_NO_FAST_CONVERSIONS
return (gint) (val);
#else
union {
double d;
unsigned int i[2];
} dbl;
dbl.d = val;
dbl.d = dbl.d + _magic;
return ((int) dbl.i[_COGL_MAN]) >> 16;
#endif
}
guint
cogl_double_to_uint (double val)
{
#ifdef COGL_NO_FAST_CONVERSIONS
return (guint)(val);
#else
union {
double d;
unsigned int i[2];
} dbl;
dbl.d = val;
dbl.d = dbl.d + _magic;
return (dbl.i[_COGL_MAN]) >> 16;
#endif
}
#undef _COGL_MAN
CoglFixed
cogl_fixed_sin (CoglFixed angle)
{
int sign = 1, indx1, indx2;
CoglFixed low, high, d1, d2;
/* convert negative angle to positive + sign */
if ((int) angle < 0)
{
sign = 1 + ~sign;
angle = 1 + ~angle;
}
/* reduce to <0, 2*pi) */
angle = angle % COGL_FIXED_2_PI;
/* reduce to first quadrant and sign */
if (angle > COGL_FIXED_PI)
{
sign = 1 + ~sign;
if (angle > COGL_FIXED_PI + COGL_FIXED_PI_2)
{
/* fourth qudrant */
angle = COGL_FIXED_2_PI - angle;
}
else
{
/* third quadrant */
angle -= COGL_FIXED_PI;
}
}
else
{
if (angle > COGL_FIXED_PI_2)
{
/* second quadrant */
angle = COGL_FIXED_PI - angle;
}
}
/* Calculate indices of the two nearest values in our table
* and return weighted average
*
* Handle the end of the table gracefully
*/
indx1 = COGL_FIXED_DIV (angle, COGL_SIN_STEP);
indx1 = COGL_FIXED_TO_INT (indx1);
if (indx1 == (G_N_ELEMENTS (sin_tbl) - 1))
{
indx2 = indx1;
indx1 = indx2 - 1;
}
else
{
indx2 = indx1 + 1;
}
low = sin_tbl[indx1];
high = sin_tbl[indx2];
d1 = angle - indx1 * COGL_SIN_STEP;
d2 = indx2 * COGL_SIN_STEP - angle;
angle = ((low * d2 + high * d1) / (COGL_SIN_STEP));
if (sign < 0)
angle = (1 + ~angle);
return angle;
}
CoglFixed
cogl_angle_sin (CoglAngle angle)
{
int sign = 1;
CoglFixed result;
/* reduce negative angle to positive + sign */
if (angle < 0)
{
sign = 1 + ~sign;
angle = 1 + ~angle;
}
/* reduce to <0, 2*pi) */
angle &= 0x3ff;
/* reduce to first quadrant and sign */
if (angle > 512)
{
sign = 1 + ~sign;
if (angle > 768)
{
/* fourth qudrant */
angle = 1024 - angle;
}
else
{
/* third quadrant */
angle -= 512;
}
}
else
{
if (angle > 256)
{
/* second quadrant */
angle = 512 - angle;
}
}
result = sin_tbl[angle];
if (sign < 0)
result = (1 + ~result);
return result;
}
CoglFixed
cogl_angle_tan (CoglAngle angle)
{
int sign = 1;
CoglFixed result;
/* reduce negative angle to positive + sign */
if (angle < 0)
{
sign = 1 + ~sign;
angle = 1 + ~angle;
}
/* reduce to <0, pi) */
angle &= 0x1ff;
/* reduce to first quadrant and sign */
if (angle > 256)
{
sign = 1 + ~sign;
angle = 512 - angle;
}
result = tan_tbl[angle];
if (sign < 0)
result = (1 + ~result);
return result;
}
CoglFixed
cogl_fixed_atan (CoglFixed x)
{
gboolean negative = FALSE;
CoglFixed angle;
if (x < 0)
{
negative = TRUE;
x = -x;
}
if (x > COGL_FIXED_1)
{
/* if x > 1 then atan(x) = pi/2 - atan(1/x) */
angle = COGL_FIXED_PI / 2
- atan_tbl[COGL_FIXED_DIV (COGL_FIXED_1, x) >> 8];
}
else
angle = atan_tbl[x >> 8];
return negative ? -angle : angle;
}
CoglFixed
cogl_fixed_atan2 (CoglFixed y, CoglFixed x)
{
CoglFixed angle;
if (x == 0)
angle = y >= 0 ? COGL_FIXED_PI_2 : -COGL_FIXED_PI_2;
else
{
angle = cogl_fixed_atan (COGL_FIXED_DIV (y, x));
if (x < 0)
angle += y >= 0 ? COGL_FIXED_PI : -COGL_FIXED_PI;
}
return angle;
}
CoglFixed
cogl_fixed_sqrt (CoglFixed 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 precision;
* on ARM this function is about 5 times faster than c-lib sqrt,
* whilst producing errors < 1%.
*/
int t = 0;
int sh = 0;
unsigned int mask = 0x40000000;
unsigned fract = x & 0x0000ffff;
unsigned int d1, d2;
CoglFixed v1, v2;
if (x <= 0)
return 0;
if (x > COGL_FIXED_255 || x < COGL_FIXED_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 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
*
* NB: it's been said that the bshr instruction is poorly implemented
* and that it is possible to write a faster code in C using binary
* search -- at some point we should explore this
*/
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 = COGL_FIXED_TO_INT (x);
}
/* Do a weighted average of the two nearest values */
v1 = sqrt_tbl[t];
v2 = sqrt_tbl[t+1];
/*
* 12 is fairly arbitrary -- we want integer that is not too big to cost
* us precision
*/
d1 = (unsigned)(fract) >> 12;
d2 = ((unsigned)COGL_FIXED_1 >> 12) - d1;
x = ((v1*d2) + (v2*d1))/(COGL_FIXED_1 >> 12);
if (sh > 0)
x = x << sh;
else if (sh < 0)
x = (x >> (1 + ~sh));
return x;
}
/**
* 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 < 5%
* for arguments < #COGL_SQRTI_ARG_5_PERCENT and < 10% for arguments <
* #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: 0.2
*/
gint
cogl_sqrti (gint number)
{
#if defined __SSE2__
/* The GCC built-in with SSE2 (sqrtsd) is up to twice as fast as
* the pure integer code below. It is also more accurate.
*/
return __builtin_sqrt (number);
#else
/* This is a fixed point implementation of the Quake III sqrt algorithm,
* described, for example, at
* http://www.codemaestro.com/reviews/review00000105.html
*
* While the original QIII is extremely fast, the use of floating division
* and multiplication makes it perform very on arm processors without FPU.
*
* The key to successfully replacing the floating point operations with
* fixed point is in the choice of the fixed point format. The QIII
* algorithm does not calculate the square root, but its reciprocal ('y'
* below), which is only at the end turned to the inverse value. In order
* for the algorithm to produce satisfactory results, the reciprocal value
* must be represented with sufficient precission; the 16.16 we use
* elsewhere in clutter is not good enough, and 10.22 is used instead.
*/
CoglFixed x;
guint32 y_1; /* 10.22 fixed point */
guint32 f = 0x600000; /* '1.5' as 10.22 fixed */
union
{
float f;
guint32 i;
} flt, flt2;
flt.f = number;
x = COGL_FIXED_FROM_INT (number) / 2;
/* The QIII initial estimate */
flt.i = 0x5f3759df - ( flt.i >> 1 );
/* Now, we convert the float to 10.22 fixed. We exploit the mechanism
* described at http://www.d6.com/users/checker/pdfs/gdmfp.pdf.
*
* We want 22 bit fraction; a single precission float uses 23 bit
* mantisa, so we only need to add 2^(23-22) (no need for the 1.5
* multiplier as we are only dealing with positive numbers).
*
* Note: we have to use two separate variables here -- for some reason,
* if we try to use just the flt variable, gcc on ARM optimises the whole
* addition out, and it all goes pear shape, since without it, the bits
* in the float will not be correctly aligned.
*/
flt2.f = flt.f + 2.0;
flt2.i &= 0x7FFFFF;
/* Now we correct the estimate */
y_1 = (flt2.i >> 11) * (flt2.i >> 11);
y_1 = (y_1 >> 8) * (x >> 8);
y_1 = f - y_1;
flt2.i = (flt2.i >> 11) * (y_1 >> 11);
/* If the original argument is less than 342, we do another
* iteration to improve precission (for arguments >= 342, the single
* iteration produces generally better results).
*/
if (x < 171)
{
y_1 = (flt2.i >> 11) * (flt2.i >> 11);
y_1 = (y_1 >> 8) * (x >> 8);
y_1 = f - y_1;
flt2.i = (flt2.i >> 11) * (y_1 >> 11);
}
/* Invert, round and convert from 10.22 to an integer
* 0x1e3c68 is a magical rounding constant that produces slightly
* better results than 0x200000.
*/
return (number * flt2.i + 0x1e3c68) >> 22;
#endif
}
CoglFixed
cogl_fixed_mul (CoglFixed a,
CoglFixed b)
{
#ifdef __arm__
/* This provides about 12% speedeup on the gcc -O2 optimised
* C version
*
* Based on code found in the following thread:
* http://lists.mplayerhq.hu/pipermail/ffmpeg-devel/2006-August/014405.html
*/
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
gint64 r = (gint64) a * (gint64) b;
return (CoglFixed) (r >> COGL_FIXED_Q);
#endif
}
CoglFixed
cogl_fixed_div (CoglFixed a,
CoglFixed b)
{
return (CoglFixed) ((((gint64) a) << COGL_FIXED_Q) / b);
}
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;
}
/*
* The log2x() and pow2x() functions
*
* The implementation of the log2x() and pow2x() exploits the
* well-documented fact that the exponent part of IEEE floating
* number provides a good estimate of log2 of that number, while
* the mantissa serves as a good error-correction.
*
* The implementation here uses a quadratic error correction as
* described by Ian Stephenson at:
* http://www.dctsystems.co.uk/Software/power.html.
*/
CoglFixed
cogl_fixed_log2 (guint x)
{
/* Note: we could easily have a version for CoglFixed x, but the int
* precision is enough for the current purposes.
*/
union
{
float f;
CoglFixed i;
} flt;
CoglFixed magic = 0x58bb;
CoglFixed y;
/*
* Convert x to float, then extract exponent.
*
* We want the result to be 16.16 fixed, so we shift (23-16) bits only
*/
flt.f = x;
flt.i >>= 7;
flt.i -= COGL_FIXED_FROM_INT (127);
y = COGL_FIXED_FRACTION (flt.i);
y = COGL_FIXED_MUL ((y - COGL_FIXED_MUL (y, y)), magic);
return flt.i + y;
}
guint
cogl_fixed_pow2 (CoglFixed x)
{
/* Note: we could easily have a version that produces CoglFixed result,
* but the the range would be limited to x < 15, and the int precision
* is enough for the current purposes.
*/
union
{
float f;
guint32 i;
} flt;
CoglFixed magic = 0x56f7;
CoglFixed y;
flt.i = x;
/*
* Reverse of the log2x function -- convert the fixed value to a suitable
* floating point exponent, and mantisa adjusted with quadratic error
* correction y.
*/
y = COGL_FIXED_FRACTION (x);
y = COGL_FIXED_MUL ((y - COGL_FIXED_MUL (y, y)), magic);
/* Shift the exponent into it's position in the floating point
* representation; as our number is not int but 16.16 fixed, shift only
* by (23 - 16)
*/
flt.i += (COGL_FIXED_FROM_INT (127) - y);
flt.i <<= 7;
return COGL_FLOAT_TO_UINT (flt.f);
}
guint
cogl_fixed_pow (guint x,
CoglFixed y)
{
return cogl_fixed_pow2 (COGL_FIXED_MUL (y, cogl_fixed_log2 (x)));
}
CoglFixed
cogl_angle_cos (CoglAngle angle)
{
CoglAngle a = angle + 256;
return cogl_angle_sin (a);
}
CoglFixed
cogl_fixed_cos (CoglFixed angle)
{
CoglFixed a = angle + COGL_FIXED_PI_2;
return cogl_fixed_sin (a);
}

240
common/cogl-primitives.c
View File

@ -38,18 +38,18 @@
/* these are defined in the particular backend(float in gl vs fixed in gles)*/
void _cogl_path_clear_nodes ();
void _cogl_path_add_node (ClutterFixed x,
ClutterFixed y);
void _cogl_path_add_node (CoglFixed x,
CoglFixed y);
void _cogl_path_fill_nodes ();
void _cogl_path_stroke_nodes ();
void _cogl_rectangle (gint x,
gint y,
guint width,
guint height);
void _cogl_rectanglex (ClutterFixed x,
ClutterFixed y,
ClutterFixed width,
ClutterFixed height);
void _cogl_rectanglex (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height);
void
cogl_rectangle (gint x,
gint y,
@ -60,10 +60,10 @@ cogl_rectangle (gint x,
}
void
cogl_rectanglex (ClutterFixed x,
ClutterFixed y,
ClutterFixed width,
ClutterFixed height)
cogl_rectanglex (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height)
{
_cogl_rectanglex (x, y, width, height);
}
@ -92,8 +92,8 @@ cogl_path_stroke (void)
}
void
cogl_path_move_to (ClutterFixed x,
ClutterFixed y)
cogl_path_move_to (CoglFixed x,
CoglFixed y)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -112,8 +112,8 @@ cogl_path_move_to (ClutterFixed x,
}
void
cogl_path_rel_move_to (ClutterFixed x,
ClutterFixed y)
cogl_path_rel_move_to (CoglFixed x,
CoglFixed y)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -122,8 +122,8 @@ cogl_path_rel_move_to (ClutterFixed x,
}
void
cogl_path_line_to (ClutterFixed x,
ClutterFixed y)
cogl_path_line_to (CoglFixed x,
CoglFixed y)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -134,8 +134,8 @@ cogl_path_line_to (ClutterFixed x,
}
void
cogl_path_rel_line_to (ClutterFixed x,
ClutterFixed y)
cogl_path_rel_line_to (CoglFixed x,
CoglFixed y)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -154,17 +154,17 @@ cogl_path_close (void)
void
cogl_path_line (ClutterFixed x1,
ClutterFixed y1,
ClutterFixed x2,
ClutterFixed y2)
cogl_path_line (CoglFixed x1,
CoglFixed y1,
CoglFixed x2,
CoglFixed y2)
{
cogl_path_move_to (x1, y1);
cogl_path_line_to (x2, y2);
}
void
cogl_path_polyline (ClutterFixed *coords,
cogl_path_polyline (CoglFixed *coords,
gint num_points)
{
gint c = 0;
@ -176,7 +176,7 @@ cogl_path_polyline (ClutterFixed *coords,
}
void
cogl_path_polygon (ClutterFixed *coords,
cogl_path_polygon (CoglFixed *coords,
gint num_points)
{
cogl_path_polyline (coords, num_points);
@ -184,10 +184,10 @@ cogl_path_polygon (ClutterFixed *coords,
}
void
cogl_path_rectangle (ClutterFixed x,
ClutterFixed y,
ClutterFixed width,
ClutterFixed height)
cogl_path_rectangle (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height)
{
cogl_path_move_to (x, y);
cogl_path_line_to (x + width, y);
@ -197,20 +197,20 @@ cogl_path_rectangle (ClutterFixed x,
}
static void
_cogl_path_arc (ClutterFixed center_x,
ClutterFixed center_y,
ClutterFixed radius_x,
ClutterFixed radius_y,
ClutterAngle angle_1,
ClutterAngle angle_2,
ClutterAngle angle_step,
_cogl_path_arc (CoglFixed center_x,
CoglFixed center_y,
CoglFixed radius_x,
CoglFixed radius_y,
CoglAngle angle_1,
CoglAngle angle_2,
CoglAngle angle_step,
guint move_first)
{
ClutterAngle a = 0x0;
ClutterFixed cosa = 0x0;
ClutterFixed sina = 0x0;
ClutterFixed px = 0x0;
ClutterFixed py = 0x0;
CoglAngle a = 0x0;
CoglFixed cosa = 0x0;
CoglFixed sina = 0x0;
CoglFixed px = 0x0;
CoglFixed py = 0x0;
/* Fix invalid angles */
@ -225,11 +225,11 @@ _cogl_path_arc (ClutterFixed center_x,
a = angle_1;
while (a != angle_2)
{
cosa = clutter_cosi (a);
sina = clutter_sini (a);
cosa = cogl_angle_cos (a);
sina = cogl_angle_sin (a);
px = center_x + CFX_MUL (cosa, radius_x);
py = center_y + CFX_MUL (sina, radius_y);
px = center_x + COGL_FIXED_MUL (cosa, radius_x);
py = center_y + COGL_FIXED_MUL (sina, radius_y);
if (a == angle_1 && move_first)
cogl_path_move_to (px, py);
@ -252,24 +252,24 @@ _cogl_path_arc (ClutterFixed center_x,
/* Make sure the final point is drawn */
cosa = clutter_cosi (angle_2);
sina = clutter_sini (angle_2);
cosa = cogl_angle_cos (angle_2);
sina = cogl_angle_sin (angle_2);
px = center_x + CFX_MUL (cosa, radius_x);
py = center_y + CFX_MUL (sina, radius_y);
px = center_x + COGL_FIXED_MUL (cosa, radius_x);
py = center_y + COGL_FIXED_MUL (sina, radius_y);
cogl_path_line_to (px, py);
}
void
cogl_path_arc (ClutterFixed center_x,
ClutterFixed center_y,
ClutterFixed radius_x,
ClutterFixed radius_y,
ClutterAngle angle_1,
ClutterAngle angle_2)
cogl_path_arc (CoglFixed center_x,
CoglFixed center_y,
CoglFixed radius_x,
CoglFixed radius_y,
CoglAngle angle_1,
CoglAngle angle_2)
{
ClutterAngle angle_step = 10;
CoglAngle angle_step = 10;
/* it is documented that a move to is needed to create a freestanding
* arc
*/
@ -281,13 +281,13 @@ cogl_path_arc (ClutterFixed center_x,
void
cogl_path_arc_rel (ClutterFixed center_x,
ClutterFixed center_y,
ClutterFixed radius_x,
ClutterFixed radius_y,
ClutterAngle angle_1,
ClutterAngle angle_2,
ClutterAngle angle_step)
cogl_path_arc_rel (CoglFixed center_x,
CoglFixed center_y,
CoglFixed radius_x,
CoglFixed radius_y,
CoglAngle angle_1,
CoglAngle angle_2,
CoglAngle angle_step)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -299,50 +299,50 @@ cogl_path_arc_rel (ClutterFixed center_x,
}
void
cogl_path_ellipse (ClutterFixed center_x,
ClutterFixed center_y,
ClutterFixed radius_x,
ClutterFixed radius_y)
cogl_path_ellipse (CoglFixed center_x,
CoglFixed center_y,
CoglFixed radius_x,
CoglFixed radius_y)
{
ClutterAngle angle_step = 10;
CoglAngle angle_step = 10;
/* FIXME: if shows to be slow might be optimized
* by mirroring just a quarter of it */
_cogl_path_arc (center_x, center_y,
radius_x, radius_y,
0, CLUTTER_ANGLE_FROM_DEG(360),
0, COGL_ANGLE_FROM_DEG (360),
angle_step, 1 /* move first */);
cogl_path_close();
}
void
cogl_path_round_rectangle (ClutterFixed x,
ClutterFixed y,
ClutterFixed width,
ClutterFixed height,
ClutterFixed radius,
ClutterAngle arc_step)
cogl_path_round_rectangle (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height,
CoglFixed radius,
CoglAngle arc_step)
{
ClutterFixed inner_width = width - (radius << 1);
ClutterFixed inner_height = height - (radius << 1);
CoglFixed inner_width = width - (radius << 1);
CoglFixed inner_height = height - (radius << 1);
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
cogl_path_move_to (x, y + radius);
cogl_path_arc_rel (radius, 0,
radius, radius,
CLUTTER_ANGLE_FROM_DEG (180),
CLUTTER_ANGLE_FROM_DEG (270),
COGL_ANGLE_FROM_DEG (180),
COGL_ANGLE_FROM_DEG (270),
arc_step);
cogl_path_line_to (ctx->path_pen.x + inner_width,
ctx->path_pen.y);
cogl_path_arc_rel (0, radius,
radius, radius,
CLUTTER_ANGLE_FROM_DEG (-90),
CLUTTER_ANGLE_FROM_DEG (0),
COGL_ANGLE_FROM_DEG (-90),
COGL_ANGLE_FROM_DEG (0),
arc_step);
cogl_path_line_to (ctx->path_pen.x,
@ -350,16 +350,16 @@ cogl_path_round_rectangle (ClutterFixed x,
cogl_path_arc_rel (-radius, 0,
radius, radius,
CLUTTER_ANGLE_FROM_DEG (0),
CLUTTER_ANGLE_FROM_DEG (90),
COGL_ANGLE_FROM_DEG (0),
COGL_ANGLE_FROM_DEG (90),
arc_step);
cogl_path_line_to (ctx->path_pen.x - inner_width,
ctx->path_pen.y);
cogl_path_arc_rel (0, -radius,
radius, radius,
CLUTTER_ANGLE_FROM_DEG (90),
CLUTTER_ANGLE_FROM_DEG (180),
COGL_ANGLE_FROM_DEG (90),
COGL_ANGLE_FROM_DEG (180),
arc_step);
cogl_path_close ();
@ -393,7 +393,7 @@ _cogl_path_bezier3_sub (CoglBezCubic *cubic)
#define CFX_MUL2(x) ((x) << 1)
#define CFX_MUL3(x) (((x) << 1) + (x))
#define CFX_SQ(x) CFX_MUL (x, x)
#define CFX_SQ(x) COGL_FIXED_MUL (x, x)
/* Calculate distance of control points from their
* counterparts on the line between end points */
@ -401,10 +401,15 @@ _cogl_path_bezier3_sub (CoglBezCubic *cubic)
dif1.y = CFX_MUL3 (c->p2.y) - CFX_MUL2 (c->p1.y) - c->p4.y;
dif2.x = CFX_MUL3 (c->p3.x) - CFX_MUL2 (c->p4.x) - c->p1.x;
dif2.y = CFX_MUL3 (c->p3.y) - CFX_MUL2 (c->p4.y) - c->p1.y;
if (dif1.x < 0) dif1.x = -dif1.x;
if (dif1.y < 0) dif1.y = -dif1.y;
if (dif2.x < 0) dif2.x = -dif2.x;
if (dif2.y < 0) dif2.y = -dif2.y;
if (dif1.x < 0)
dif1.x = -dif1.x;
if (dif1.y < 0)
dif1.y = -dif1.y;
if (dif2.x < 0)
dif2.x = -dif2.x;
if (dif2.y < 0)
dif2.y = -dif2.y;
#undef CFX_MUL2
#undef CFX_MUL3
@ -415,13 +420,18 @@ _cogl_path_bezier3_sub (CoglBezCubic *cubic)
if (dif1.y < dif2.y) dif1.y = dif2.y;
/* Cancel if the curve is flat enough */
if (dif1.x + dif1.y <= CFX_ONE
|| cindex == _COGL_MAX_BEZ_RECURSE_DEPTH-1)
if (dif1.x + dif1.y <= COGL_FIXED_1 ||
cindex == _COGL_MAX_BEZ_RECURSE_DEPTH-1)
{
/* Add subdivision point (skip last) */
if (cindex == 0) return;
if (cindex == 0)
return;
_cogl_path_add_node (c->p4.x, c->p4.y);
--cindex; continue;
--cindex;
continue;
}
/* Left recursion goes on top of stack! */
@ -458,12 +468,12 @@ _cogl_path_bezier3_sub (CoglBezCubic *cubic)
}
void
cogl_path_curve_to (ClutterFixed x1,
ClutterFixed y1,
ClutterFixed x2,
ClutterFixed y2,
ClutterFixed x3,
ClutterFixed y3)
cogl_path_curve_to (CoglFixed x1,
CoglFixed y1,
CoglFixed x2,
CoglFixed y2,
CoglFixed x3,
CoglFixed y3)
{
CoglBezCubic cubic;
@ -487,12 +497,12 @@ cogl_path_curve_to (ClutterFixed x1,
}
void
cogl_path_rel_curve_to (ClutterFixed x1,
ClutterFixed y1,
ClutterFixed x2,
ClutterFixed y2,
ClutterFixed x3,
ClutterFixed y3)
cogl_path_rel_curve_to (CoglFixed x1,
CoglFixed y1,
CoglFixed x2,
CoglFixed y2,
CoglFixed x3,
CoglFixed y3)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -544,8 +554,8 @@ _cogl_path_bezier2_sub (CoglBezQuad *quad)
if (dif.y < 0) dif.y = -dif.y;
/* Cancel if the curve is flat enough */
if (dif.x + dif.y <= CFX_ONE
|| qindex == _COGL_MAX_BEZ_RECURSE_DEPTH - 1)
if (dif.x + dif.y <= COGL_FIXED_1 ||
qindex == _COGL_MAX_BEZ_RECURSE_DEPTH - 1)
{
/* Add subdivision point (skip last) */
if (qindex == 0) return;
@ -577,10 +587,10 @@ _cogl_path_bezier2_sub (CoglBezQuad *quad)
}
void
cogl_path_curve2_to (ClutterFixed x1,
ClutterFixed y1,
ClutterFixed x2,
ClutterFixed y2)
cogl_path_curve2_to (CoglFixed x1,
CoglFixed y1,
CoglFixed x2,
CoglFixed y2)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -602,10 +612,10 @@ cogl_path_curve2_to (ClutterFixed x1,
}
void
cogl_rel_curve2_to (ClutterFixed x1,
ClutterFixed y1,
ClutterFixed x2,
ClutterFixed y2)
cogl_rel_curve2_to (CoglFixed x1,
CoglFixed y1,
CoglFixed x2,
CoglFixed y2)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);

4
common/cogl-primitives.h
View File

@ -32,8 +32,8 @@ typedef struct _CoglBezCubic CoglBezCubic;
struct _CoglFixedVec2
{
ClutterFixed x;
ClutterFixed y;
CoglFixed x;
CoglFixed y;
};
#ifdef CLUTTER_COGL_HAS_GL

1
doc/reference/cogl/cogl-docs.sgml
View File

@ -58,6 +58,7 @@
<xi:include href="xml/cogl-texture.xml"/>
<xi:include href="xml/cogl-shaders.xml"/>
<xi:include href="xml/cogl-offscreen.xml"/>
<xi:include href="xml/cogl-fixed.xml"/>
</chapter>

85
doc/reference/cogl/cogl-sections.txt
View File

@ -146,3 +146,88 @@ cogl_offscreen_blit
cogl_offscreen_blit_region
cogl_draw_buffer
</SECTION>
<SECTION>
<FILE>cogl-fixed</FILE>
<TITLE>Fixed Point API</TITLE>
CoglFixed
COGL_FIXED_BITS
COGL_FIXED_Q
COGL_FIXED_MAX
COGL_FIXED_MIN
<SUBSECTION>
COGL_FIXED_FROM_FLOAT
COGL_FIXED_TO_FLOAT
COGL_FIXED_FROM_INT
COGL_FIXED_TO_INT
COGL_FIXED_TO_DOUBLE
COGL_FLOAT_TO_INT
COGL_FLOAT_TO_UINT
<SUBSECTION>
COGL_FIXED_EPSILON
COGL_FIXED_1
COGL_FIXED_0_5
COGL_FIXED_30
COGL_FIXED_45
COGL_FIXED_60
COGL_FIXED_90
COGL_FIXED_120
COGL_FIXED_180
COGL_FIXED_240
COGL_FIXED_255
COGL_FIXED_270
COGL_FIXED_360
<SUBSECTION>
COGL_FIXED_MUL
COGL_FIXED_DIV
COGL_FIXED_MUL_DIV
COGL_FIXED_FAST_DIV
COGL_FIXED_FAST_MUL
COGL_FIXED_FRACTION
COGL_FIXED_FLOOR
COGL_FIXED_CEIL
<SUBSECTION>
COGL_FIXED_2_PI
COGL_FIXED_PI
COGL_FIXED_PI_2
COGL_FIXED_PI_4
COGL_RADIANS_TO_DEGREES
<SUBSECTION>
COGL_SQRTI_ARG_10_PERCENT
COGL_SQRTI_ARG_5_PERCENT
COGL_SQRTI_ARG_MAX
cogl_sqrti
<SUBSECTION>
cogl_fixed_atan2
cogl_fixed_atani
cogl_fixed_cos
cogl_fixed_log2
cogl_fixed_pow
cogl_fixed_pow2
cogl_fixed_sin
cogl_fixed_sqrt
<SUBSECTION>
CoglAngle
COGL_ANGLE_FROM_DEG
COGL_ANGLE_FROM_DEGX
COGL_ANGLE_TO_DEG
COGL_ANGLE_TO_DEGX
cogl_angle_cos
cogl_angle_sin
cogl_angle_tan
<SUBSECTION Private>
cogl_fixed_mul
cogl_fixed_div
cogl_fixed_mul_div
cogl_double_to_fixed
cogl_double_to_int
cogl_double_to_unit
</SECTION>

7
gl/Makefile.am
View File

@ -1,6 +1,8 @@
libclutterincludedir = $(includedir)/clutter-@CLUTTER_API_VERSION@/cogl
libclutterinclude_HEADERS = $(top_builddir)/clutter/cogl/cogl.h \
$(top_builddir)/clutter/cogl/cogl-defines-gl.h
libclutterinclude_HEADERS = \
$(top_builddir)/clutter/cogl/cogl.h \
$(top_builddir)/clutter/cogl/cogl-defines-gl.h \
$(top_builddir)/clutter/cogl/cogl-fixed.h
INCLUDES = \
-I$(top_srcdir) \
@ -21,6 +23,7 @@ noinst_LTLIBRARIES = libclutter-cogl.la
libclutter_cogl_la_SOURCES = \
$(top_builddir)/clutter/cogl/cogl.h \
$(top_builddir)/clutter/cogl/cogl-defines-gl.h \
$(top_builddir)/clutter/cogl/cogl-fixed.h \
cogl-internal.h \
cogl-texture.h \
cogl-fbo.h \

32
gl/cogl-primitives.c
View File

@ -53,20 +53,20 @@ _cogl_rectangle (gint x,
void
_cogl_rectanglex (ClutterFixed x,
ClutterFixed y,
ClutterFixed width,
ClutterFixed height)
_cogl_rectanglex (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
cogl_enable (ctx->color_alpha < 255
? COGL_ENABLE_BLEND : 0);
GE( glRectf (CLUTTER_FIXED_TO_FLOAT (x),
CLUTTER_FIXED_TO_FLOAT (y),
CLUTTER_FIXED_TO_FLOAT (x + width),
CLUTTER_FIXED_TO_FLOAT (y + height)) );
GE( glRectf (COGL_FIXED_TO_FLOAT (x),
COGL_FIXED_TO_FLOAT (y),
COGL_FIXED_TO_FLOAT (x + width),
COGL_FIXED_TO_FLOAT (y + height)) );
}
void
@ -83,8 +83,8 @@ _cogl_path_clear_nodes ()
}
void
_cogl_path_add_node (ClutterFixed x,
ClutterFixed y)
_cogl_path_add_node (CoglFixed x,
CoglFixed y)
{
CoglFloatVec2 *new_nodes = NULL;
@ -102,8 +102,8 @@ _cogl_path_add_node (ClutterFixed x,
ctx->path_nodes_cap *= 2;
}
ctx->path_nodes [ctx->path_nodes_size] .x = CLUTTER_FIXED_TO_FLOAT (x);
ctx->path_nodes [ctx->path_nodes_size] .y = CLUTTER_FIXED_TO_FLOAT (y);
ctx->path_nodes [ctx->path_nodes_size] .x = COGL_FIXED_TO_FLOAT (x);
ctx->path_nodes [ctx->path_nodes_size] .y = COGL_FIXED_TO_FLOAT (y);
ctx->path_nodes_size++;
if (ctx->path_nodes_size == 1)
@ -165,10 +165,10 @@ _cogl_path_fill_nodes ()
GE( glStencilFunc (GL_EQUAL, 0x1, 0x1) );
GE( glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP) );
bounds_x = CLUTTER_FIXED_FLOOR (ctx->path_nodes_min.x);
bounds_y = CLUTTER_FIXED_FLOOR (ctx->path_nodes_min.y);
bounds_w = CLUTTER_FIXED_CEIL (ctx->path_nodes_max.x - ctx->path_nodes_min.x);
bounds_h = CLUTTER_FIXED_CEIL (ctx->path_nodes_max.y - ctx->path_nodes_min.y);
bounds_x = COGL_FIXED_FLOOR (ctx->path_nodes_min.x);
bounds_y = COGL_FIXED_FLOOR (ctx->path_nodes_min.y);
bounds_w = COGL_FIXED_CEIL (ctx->path_nodes_max.x - ctx->path_nodes_min.x);
bounds_h = COGL_FIXED_CEIL (ctx->path_nodes_max.y - ctx->path_nodes_min.y);
cogl_rectangle (bounds_x, bounds_y, bounds_w, bounds_h);

220
gl/cogl-texture.c
View File

@ -58,15 +58,15 @@ struct _CoglSpanIter
gint index;
GArray *array;
CoglTexSliceSpan *span;
ClutterFixed pos;
ClutterFixed next_pos;
ClutterFixed origin;
ClutterFixed cover_start;
ClutterFixed cover_end;
ClutterFixed intersect_start;
ClutterFixed intersect_end;
ClutterFixed intersect_start_local;
ClutterFixed intersect_end_local;
CoglFixed pos;
CoglFixed next_pos;
CoglFixed origin;
CoglFixed cover_start;
CoglFixed cover_end;
CoglFixed intersect_start;
CoglFixed intersect_end;
CoglFixed intersect_start_local;
CoglFixed intersect_end_local;
gboolean intersects;
};
@ -100,8 +100,8 @@ _cogl_span_iter_update (CoglSpanIter *iter)
iter->index);
/* Offset next position by span size */
iter->next_pos = iter->pos +
CLUTTER_INT_TO_FIXED (iter->span->size - iter->span->waste);
iter->next_pos = iter->pos
+ COGL_FIXED_FROM_INT (iter->span->size - iter->span->waste);
/* Check if span intersects the area to cover */
if (iter->next_pos <= iter->cover_start ||
@ -130,9 +130,9 @@ _cogl_span_iter_update (CoglSpanIter *iter)
static void
_cogl_span_iter_begin (CoglSpanIter *iter,
GArray *array,
ClutterFixed origin,
ClutterFixed cover_start,
ClutterFixed cover_end)
CoglFixed origin,
CoglFixed cover_start,
CoglFixed cover_end)
{
/* Copy info */
iter->index = 0;
@ -493,8 +493,8 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
/* Iterate vertical spans */
for (source_y = src_y,
_cogl_span_iter_begin (&y_iter, tex->slice_y_spans,
0, CLUTTER_INT_TO_FIXED (dst_y),
CLUTTER_INT_TO_FIXED (dst_y + height));
0, COGL_FIXED_FROM_INT (dst_y),
COGL_FIXED_FROM_INT (dst_y + height));
!_cogl_span_iter_end (&y_iter);
@ -514,8 +514,8 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
/* Iterate horizontal spans */
for (source_x = src_x,
_cogl_span_iter_begin (&x_iter, tex->slice_x_spans,
0, CLUTTER_INT_TO_FIXED (dst_x),
CLUTTER_INT_TO_FIXED (dst_x + width));
0, COGL_FIXED_FROM_INT (dst_x),
COGL_FIXED_FROM_INT (dst_x + width));
!_cogl_span_iter_end (&x_iter);
@ -533,15 +533,15 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
x_iter.index);
/* Pick intersection width and height */
inter_w = CLUTTER_FIXED_TO_INT (x_iter.intersect_end -
inter_w = COGL_FIXED_TO_INT (x_iter.intersect_end -
x_iter.intersect_start);
inter_h = CLUTTER_FIXED_TO_INT (y_iter.intersect_end -
inter_h = COGL_FIXED_TO_INT (y_iter.intersect_end -
y_iter.intersect_start);
/* Localize intersection top-left corner to slice*/
local_x = CLUTTER_FIXED_TO_INT (x_iter.intersect_start -
local_x = COGL_FIXED_TO_INT (x_iter.intersect_start -
x_iter.pos);
local_y = CLUTTER_FIXED_TO_INT (y_iter.intersect_start -
local_y = COGL_FIXED_TO_INT (y_iter.intersect_start -
y_iter.pos);
/* Pick slice GL handle */
@ -575,14 +575,20 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
&& local_x < x_span->size - x_span->waste
&& local_x + inter_w >= x_span->size - x_span->waste)
{
const guchar *src = source_bmp->data
+ (src_y + CLUTTER_FIXED_TO_INT (y_iter.intersect_start)
- dst_y) * source_bmp->rowstride
+ (src_x + x_span->start + x_span->size - x_span->waste
- dst_x - 1) * bpp;
guchar *dst = waste_buf;
const guchar *src;
guchar *dst;
guint wx, wy;
src = source_bmp->data
+ (src_y + COGL_FIXED_TO_INT (y_iter.intersect_start)
- dst_y)
* source_bmp->rowstride
+ (src_x + x_span->start + x_span->size - x_span->waste
- dst_x - 1)
* bpp;
dst = waste_buf;
for (wy = 0; wy < inter_h; wy++)
{
for (wx = 0; wx < x_span->waste; wx++)
@ -612,15 +618,21 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
&& local_y < y_span->size - y_span->waste
&& local_y + inter_h >= y_span->size - y_span->waste)
{
const guchar *src = source_bmp->data
+ (src_x + CLUTTER_FIXED_TO_INT (x_iter.intersect_start)
- dst_x) * bpp
+ (src_y + y_span->start + y_span->size - y_span->waste
- dst_y - 1) * source_bmp->rowstride;
guchar *dst = waste_buf;
const guchar *src;
guchar *dst;
guint wy, wx;
guint copy_width;
src = source_bmp->data
+ (src_x + COGL_FIXED_TO_INT (x_iter.intersect_start)
- dst_x)
* bpp
+ (src_y + y_span->start + y_span->size - y_span->waste
- dst_y - 1)
* source_bmp->rowstride;
dst = waste_buf;
if (local_x + inter_w >= x_span->size - x_span->waste)
copy_width = x_span->size - local_x;
else
@ -1914,24 +1926,24 @@ cogl_texture_get_data (CoglHandle handle,
static void
_cogl_texture_quad_sw (CoglTexture *tex,
ClutterFixed x1,
ClutterFixed y1,
ClutterFixed x2,
ClutterFixed y2,
ClutterFixed tx1,
ClutterFixed ty1,
ClutterFixed tx2,
ClutterFixed ty2)
CoglFixed x1,
CoglFixed y1,
CoglFixed x2,
CoglFixed y2,
CoglFixed tx1,
CoglFixed ty1,
CoglFixed tx2,
CoglFixed ty2)
{
CoglSpanIter iter_x , iter_y;
ClutterFixed tw , th;
ClutterFixed tqx , tqy;
ClutterFixed first_tx , first_ty;
ClutterFixed first_qx , first_qy;
ClutterFixed slice_tx1 , slice_ty1;
ClutterFixed slice_tx2 , slice_ty2;
ClutterFixed slice_qx1 , slice_qy1;
ClutterFixed slice_qx2 , slice_qy2;
CoglFixed tw , th;
CoglFixed tqx , tqy;
CoglFixed first_tx , first_ty;
CoglFixed first_qx , first_qy;
CoglFixed slice_tx1 , slice_ty1;
CoglFixed slice_tx2 , slice_ty2;
CoglFixed slice_qx1 , slice_qy1;
CoglFixed slice_qx2 , slice_qy2;
GLuint gl_handle;
gulong enable_flags = 0;
@ -1956,27 +1968,27 @@ _cogl_texture_quad_sw (CoglTexture *tex,
cogl_enable (enable_flags);
/* Scale ratio from texture to quad widths */
tw = CLUTTER_INT_TO_FIXED (tex->bitmap.width);
th = CLUTTER_INT_TO_FIXED (tex->bitmap.height);
tw = COGL_FIXED_FROM_INT (tex->bitmap.width);
th = COGL_FIXED_FROM_INT (tex->bitmap.height);
tqx = CFX_QDIV (x2-x1, CFX_QMUL (tw, (tx2 - tx1)));
tqy = CFX_QDIV (y2-y1, CFX_QMUL (th, (ty2 - ty1)));
tqx = COGL_FIXED_DIV (x2 - x1, COGL_FIXED_MUL (tw, (tx2 - tx1)));
tqy = COGL_FIXED_DIV (y2 - y1, COGL_FIXED_MUL (th, (ty2 - ty1)));
/* Integral texture coordinate for first tile */
first_tx = CLUTTER_INT_TO_FIXED (CLUTTER_FIXED_FLOOR (tx1));
first_ty = CLUTTER_INT_TO_FIXED (CLUTTER_FIXED_FLOOR (ty1));
first_tx = COGL_FIXED_FROM_INT (COGL_FIXED_FLOOR (tx1));
first_ty = COGL_FIXED_FROM_INT (COGL_FIXED_FLOOR (ty1));
/* Denormalize texture coordinates */
first_tx = CFX_QMUL (first_tx, tw);
first_ty = CFX_QMUL (first_ty, th);
tx1 = CFX_QMUL (tx1, tw);
ty1 = CFX_QMUL (ty1, th);
tx2 = CFX_QMUL (tx2, tw);
ty2 = CFX_QMUL (ty2, th);
first_tx = COGL_FIXED_MUL (first_tx, tw);
first_ty = COGL_FIXED_MUL (first_ty, th);
tx1 = COGL_FIXED_MUL (tx1, tw);
ty1 = COGL_FIXED_MUL (ty1, th);
tx2 = COGL_FIXED_MUL (tx2, tw);
ty2 = COGL_FIXED_MUL (ty2, th);
/* Quad coordinate of the first tile */
first_qx = x1 - CFX_QMUL (tx1 - first_tx, tqx);
first_qy = y1 - CFX_QMUL (ty1 - first_ty, tqy);
first_qx = x1 - COGL_FIXED_MUL (tx1 - first_tx, tqx);
first_qy = y1 - COGL_FIXED_MUL (ty1 - first_ty, tqy);
/* Iterate until whole quad height covered */
@ -1990,10 +2002,10 @@ _cogl_texture_quad_sw (CoglTexture *tex,
/* Span-quad intersection in quad coordinates */
slice_qy1 = first_qy +
CFX_QMUL (iter_y.intersect_start - first_ty, tqy);
COGL_FIXED_MUL (iter_y.intersect_start - first_ty, tqy);
slice_qy2 = first_qy +
CFX_QMUL (iter_y.intersect_end - first_ty, tqy);
COGL_FIXED_MUL (iter_y.intersect_end - first_ty, tqy);
/* Localize slice texture coordinates */
slice_ty1 = iter_y.intersect_start - iter_y.pos;
@ -2016,10 +2028,10 @@ _cogl_texture_quad_sw (CoglTexture *tex,
/* Span-quad intersection in quad coordinates */
slice_qx1 = first_qx +
CFX_QMUL (iter_x.intersect_start - first_tx, tqx);
COGL_FIXED_MUL (iter_x.intersect_start - first_tx, tqx);
slice_qx2 = first_qx +
CFX_QMUL (iter_x.intersect_end - first_tx, tqx);
COGL_FIXED_MUL (iter_x.intersect_end - first_tx, tqx);
/* Localize slice texture coordinates */
slice_tx1 = iter_x.intersect_start - iter_x.pos;
@ -2032,14 +2044,14 @@ _cogl_texture_quad_sw (CoglTexture *tex,
#if COGL_DEBUG
printf("~~~~~ slice (%d,%d)\n", iter_x.index, iter_y.index);
printf("qx1: %f\n", CLUTTER_FIXED_TO_FLOAT (slice_qx1));
printf("qy1: %f\n", CLUTTER_FIXED_TO_FLOAT (slice_qy1));
printf("qx2: %f\n", CLUTTER_FIXED_TO_FLOAT (slice_qx2));
printf("qy2: %f\n", CLUTTER_FIXED_TO_FLOAT (slice_qy2));
printf("tx1: %f\n", CLUTTER_FIXED_TO_FLOAT (slice_tx1));
printf("ty1: %f\n", CLUTTER_FIXED_TO_FLOAT (slice_ty1));
printf("tx2: %f\n", CLUTTER_FIXED_TO_FLOAT (slice_tx2));
printf("ty2: %f\n", CLUTTER_FIXED_TO_FLOAT (slice_ty2));
printf("qx1: %f\n", COGL_FIXED_TO_FLOAT (slice_qx1));
printf("qy1: %f\n", COGL_FIXED_TO_FLOAT (slice_qy1));
printf("qx2: %f\n", COGL_FIXED_TO_FLOAT (slice_qx2));
printf("qy2: %f\n", COGL_FIXED_TO_FLOAT (slice_qy2));
printf("tx1: %f\n", COGL_FIXED_TO_FLOAT (slice_tx1));
printf("ty1: %f\n", COGL_FIXED_TO_FLOAT (slice_ty1));
printf("tx2: %f\n", COGL_FIXED_TO_FLOAT (slice_tx2));
printf("ty2: %f\n", COGL_FIXED_TO_FLOAT (slice_ty2));
#endif
/* Pick and bind opengl texture object */
@ -2049,7 +2061,7 @@ _cogl_texture_quad_sw (CoglTexture *tex,
GE( glBindTexture (tex->gl_target, gl_handle) );
#define CFX_F CLUTTER_FIXED_TO_FLOAT
#define CFX_F COGL_FIXED_TO_FLOAT
/* Draw textured quad */
glBegin (GL_QUADS);
@ -2075,14 +2087,14 @@ _cogl_texture_quad_sw (CoglTexture *tex,
static void
_cogl_texture_quad_hw (CoglTexture *tex,
ClutterFixed x1,
ClutterFixed y1,
ClutterFixed x2,
ClutterFixed y2,
ClutterFixed tx1,
ClutterFixed ty1,
ClutterFixed tx2,
ClutterFixed ty2)
CoglFixed x1,
CoglFixed y1,
CoglFixed x2,
CoglFixed y2,
CoglFixed tx1,
CoglFixed ty1,
CoglFixed tx2,
CoglFixed ty2)
{
CoglTexSliceSpan *x_span;
CoglTexSliceSpan *y_span;
@ -2122,7 +2134,7 @@ _cogl_texture_quad_hw (CoglTexture *tex,
ty1 = ty1 * (y_span->size - y_span->waste) / y_span->size;
ty2 = ty2 * (y_span->size - y_span->waste) / y_span->size;
#define CFX_F(x) CLUTTER_FIXED_TO_FLOAT(x)
#define CFX_F(x) COGL_FIXED_TO_FLOAT(x)
/* Draw textured quad */
glBegin (GL_QUADS);
@ -2146,17 +2158,17 @@ _cogl_texture_quad_hw (CoglTexture *tex,
void
cogl_texture_rectangle (CoglHandle handle,
ClutterFixed x1,
ClutterFixed y1,
ClutterFixed x2,
ClutterFixed y2,
ClutterFixed tx1,
ClutterFixed ty1,
ClutterFixed tx2,
ClutterFixed ty2)
CoglFixed x1,
CoglFixed y1,
CoglFixed x2,
CoglFixed y2,
CoglFixed tx1,
CoglFixed ty1,
CoglFixed tx2,
CoglFixed ty2)
{
CoglTexture *tex;
ClutterFixed tempx;
CoglFixed tempx;
/* Check if valid texture */
if (!cogl_is_texture (handle))
@ -2214,9 +2226,11 @@ cogl_texture_rectangle (CoglHandle handle,
}
else
{
if (tex->slice_gl_handles->len == 1
&& tx1 >= -CFX_ONE && tx2 <= CFX_ONE
&& ty1 >= -CFX_ONE && ty2 <= CFX_ONE)
if (tex->slice_gl_handles->len == 1 &&
tx1 >= -COGL_FIXED_1 &&
tx2 <= COGL_FIXED_1 &&
ty1 >= -COGL_FIXED_1 &&
ty2 <= COGL_FIXED_1)
{
_cogl_texture_quad_hw (tex, x1,y1, x2,y2, tx1,ty1, tx2,ty2);
}
@ -2317,18 +2331,18 @@ cogl_texture_polygon (CoglHandle handle,
/* Transform the texture co-ordinates so they are
relative to the slice */
tx = (CLUTTER_FIXED_TO_FLOAT (vertices[vnum].tx)
tx = (COGL_FIXED_TO_FLOAT (vertices[vnum].tx)
- x_span->start / (GLfloat) tex->bitmap.width)
* tex->bitmap.width / x_span->size;
ty = (CLUTTER_FIXED_TO_FLOAT (vertices[vnum].ty)
ty = (COGL_FIXED_TO_FLOAT (vertices[vnum].ty)
- y_span->start / (GLfloat) tex->bitmap.height)
* tex->bitmap.height / y_span->size;
glTexCoord2f (tx, ty);
glVertex3f (CLUTTER_FIXED_TO_FLOAT (vertices[vnum].x),
CLUTTER_FIXED_TO_FLOAT (vertices[vnum].y),
CLUTTER_FIXED_TO_FLOAT (vertices[vnum].z));
glVertex3f (COGL_FIXED_TO_FLOAT (vertices[vnum].x),
COGL_FIXED_TO_FLOAT (vertices[vnum].y),
COGL_FIXED_TO_FLOAT (vertices[vnum].z));
}
GE( glEnd () );

299
gl/cogl.c
View File

@ -209,19 +209,19 @@ cogl_pop_matrix (void)
}
void
cogl_scale (ClutterFixed x, ClutterFixed y)
cogl_scale (CoglFixed x, CoglFixed y)
{
glScaled (CLUTTER_FIXED_TO_DOUBLE (x),
CLUTTER_FIXED_TO_DOUBLE (y),
glScaled (COGL_FIXED_TO_DOUBLE (x),
COGL_FIXED_TO_DOUBLE (y),
1.0);
}
void
cogl_translatex (ClutterFixed x, ClutterFixed y, ClutterFixed z)
cogl_translatex (CoglFixed x, CoglFixed y, CoglFixed z)
{
glTranslated (CLUTTER_FIXED_TO_DOUBLE (x),
CLUTTER_FIXED_TO_DOUBLE (y),
CLUTTER_FIXED_TO_DOUBLE (z));
glTranslated (COGL_FIXED_TO_DOUBLE (x),
COGL_FIXED_TO_DOUBLE (y),
COGL_FIXED_TO_DOUBLE (z));
}
void
@ -231,12 +231,12 @@ cogl_translate (gint x, gint y, gint z)
}
void
cogl_rotatex (ClutterFixed angle, gint x, gint y, gint z)
cogl_rotatex (CoglFixed angle, gint x, gint y, gint z)
{
glRotated (CLUTTER_FIXED_TO_DOUBLE (angle),
CLUTTER_FIXED_TO_DOUBLE (x),
CLUTTER_FIXED_TO_DOUBLE (y),
CLUTTER_FIXED_TO_DOUBLE (z));
glRotated (COGL_FIXED_TO_DOUBLE (angle),
COGL_FIXED_TO_DOUBLE (x),
COGL_FIXED_TO_DOUBLE (y),
COGL_FIXED_TO_DOUBLE (z));
}
void
@ -459,24 +459,24 @@ set_clip_plane (GLint plane_num,
}
void
_cogl_set_clip_planes (ClutterFixed x_offset,
ClutterFixed y_offset,
ClutterFixed width,
ClutterFixed height)
_cogl_set_clip_planes (CoglFixed x_offset,
CoglFixed y_offset,
CoglFixed width,
CoglFixed height)
{
GLfloat modelview[16], projection[16];
GLfloat vertex_tl[4] = { CLUTTER_FIXED_TO_FLOAT (x_offset),
CLUTTER_FIXED_TO_FLOAT (y_offset),
GLfloat vertex_tl[4] = { COGL_FIXED_TO_FLOAT (x_offset),
COGL_FIXED_TO_FLOAT (y_offset),
0.0f, 1.0f };
GLfloat vertex_tr[4] = { CLUTTER_FIXED_TO_FLOAT (x_offset + width),
CLUTTER_FIXED_TO_FLOAT (y_offset),
GLfloat vertex_tr[4] = { COGL_FIXED_TO_FLOAT (x_offset + width),
COGL_FIXED_TO_FLOAT (y_offset),
0.0f, 1.0f };
GLfloat vertex_bl[4] = { CLUTTER_FIXED_TO_FLOAT (x_offset),
CLUTTER_FIXED_TO_FLOAT (y_offset + height),
GLfloat vertex_bl[4] = { COGL_FIXED_TO_FLOAT (x_offset),
COGL_FIXED_TO_FLOAT (y_offset + height),
0.0f, 1.0f };
GLfloat vertex_br[4] = { CLUTTER_FIXED_TO_FLOAT (x_offset + width),
CLUTTER_FIXED_TO_FLOAT (y_offset + height),
GLfloat vertex_br[4] = { COGL_FIXED_TO_FLOAT (x_offset + width),
COGL_FIXED_TO_FLOAT (y_offset + height),
0.0f, 1.0f };
GE( glGetFloatv (GL_MODELVIEW_MATRIX, modelview) );
@ -520,10 +520,10 @@ compare_y_coordinate (const void *a, const void *b)
}
void
_cogl_add_stencil_clip (ClutterFixed x_offset,
ClutterFixed y_offset,
ClutterFixed width,
ClutterFixed height,
_cogl_add_stencil_clip (CoglFixed x_offset,
CoglFixed y_offset,
CoglFixed width,
CoglFixed height,
gboolean first)
{
gboolean has_clip_planes
@ -550,10 +550,10 @@ _cogl_add_stencil_clip (ClutterFixed x_offset,
/* Punch out a hole to allow the rectangle */
GE( glStencilFunc (GL_NEVER, 0x1, 0x1) );
GE( glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE) );
GE( glRectf (CLUTTER_FIXED_TO_FLOAT (x_offset),
CLUTTER_FIXED_TO_FLOAT (y_offset),
CLUTTER_FIXED_TO_FLOAT (x_offset + width),
CLUTTER_FIXED_TO_FLOAT (y_offset + height)) );
GE( glRectf (COGL_FIXED_TO_FLOAT (x_offset),
COGL_FIXED_TO_FLOAT (y_offset),
COGL_FIXED_TO_FLOAT (x_offset + width),
COGL_FIXED_TO_FLOAT (y_offset + height)) );
}
else if (ctx->num_stencil_bits > 1)
{
@ -561,10 +561,10 @@ _cogl_add_stencil_clip (ClutterFixed x_offset,
rectangle */
GE( glStencilFunc (GL_NEVER, 0x1, 0x3) );
GE( glStencilOp (GL_INCR, GL_INCR, GL_INCR) );
GE( glRectf (CLUTTER_FIXED_TO_FLOAT (x_offset),
CLUTTER_FIXED_TO_FLOAT (y_offset),
CLUTTER_FIXED_TO_FLOAT (x_offset + width),
CLUTTER_FIXED_TO_FLOAT (y_offset + height)) );
GE( glRectf (COGL_FIXED_TO_FLOAT (x_offset),
COGL_FIXED_TO_FLOAT (y_offset),
COGL_FIXED_TO_FLOAT (x_offset + width),
COGL_FIXED_TO_FLOAT (y_offset + height)) );
/* Subtract one from all pixels in the stencil buffer so that
only pixels where both the original stencil buffer and the
@ -592,17 +592,17 @@ _cogl_add_stencil_clip (ClutterFixed x_offset,
int i;
GLfloat points[16] =
{
CLUTTER_FIXED_TO_FLOAT (x_offset),
CLUTTER_FIXED_TO_FLOAT (y_offset),
COGL_FIXED_TO_FLOAT (x_offset),
COGL_FIXED_TO_FLOAT (y_offset),
0, 1,
CLUTTER_FIXED_TO_FLOAT (x_offset + width),
CLUTTER_FIXED_TO_FLOAT (y_offset),
COGL_FIXED_TO_FLOAT (x_offset + width),
COGL_FIXED_TO_FLOAT (y_offset),
0, 1,
CLUTTER_FIXED_TO_FLOAT (x_offset),
CLUTTER_FIXED_TO_FLOAT (y_offset + height),
COGL_FIXED_TO_FLOAT (x_offset),
COGL_FIXED_TO_FLOAT (y_offset + height),
0, 1,
CLUTTER_FIXED_TO_FLOAT (x_offset + width),
CLUTTER_FIXED_TO_FLOAT (y_offset + height),
COGL_FIXED_TO_FLOAT (x_offset + width),
COGL_FIXED_TO_FLOAT (y_offset + height),
0, 1
};
@ -708,13 +708,13 @@ _cogl_add_stencil_clip (ClutterFixed x_offset,
}
void
_cogl_set_matrix (const ClutterFixed *matrix)
_cogl_set_matrix (const CoglFixed *matrix)
{
float float_matrix[16];
int i;
for (i = 0; i < 16; i++)
float_matrix[i] = CLUTTER_FIXED_TO_FLOAT (matrix[i]);
float_matrix[i] = COGL_FIXED_TO_FLOAT (matrix[i]);
GE( glLoadIdentity () );
GE( glMultMatrixf (float_matrix) );
@ -737,20 +737,20 @@ _cogl_disable_clip_planes (void)
void
cogl_alpha_func (COGLenum func,
ClutterFixed ref)
CoglFixed ref)
{
GE( glAlphaFunc (func, CLUTTER_FIXED_TO_FLOAT(ref)) );
GE( glAlphaFunc (func, COGL_FIXED_TO_FLOAT(ref)) );
}
void
cogl_perspective (ClutterFixed fovy,
ClutterFixed aspect,
ClutterFixed zNear,
ClutterFixed zFar)
cogl_perspective (CoglFixed fovy,
CoglFixed aspect,
CoglFixed zNear,
CoglFixed zFar)
{
ClutterFixed xmax, ymax;
ClutterFixed x, y, c, d;
ClutterFixed fovy_rad_half = CLUTTER_FIXED_MUL (fovy, CFX_PI) / 360;
CoglFixed xmax, ymax;
CoglFixed x, y, c, d;
CoglFixed fovy_rad_half = COGL_FIXED_MUL (fovy, COGL_FIXED_PI) / 360;
GLfloat m[16];
@ -768,22 +768,25 @@ cogl_perspective (ClutterFixed fovy,
* same true for y, hence: a == 0 && b == 0;
*
* 2) When working with small numbers, we are loosing significant
* precision, hence we use clutter_qmulx() here, not the fast macro.
* precision
*/
ymax = clutter_qmulx (zNear, CLUTTER_FIXED_DIV (clutter_sinx (fovy_rad_half),
clutter_cosx (fovy_rad_half)));
xmax = clutter_qmulx (ymax, aspect);
ymax =
COGL_FIXED_MUL (zNear,
COGL_FIXED_FAST_DIV (cogl_fixed_sin (fovy_rad_half),
cogl_fixed_cos (fovy_rad_half)));
x = CLUTTER_FIXED_DIV (zNear, xmax);
y = CLUTTER_FIXED_DIV (zNear, ymax);
c = CLUTTER_FIXED_DIV (-(zFar + zNear), ( zFar - zNear));
d = CLUTTER_FIXED_DIV (-(clutter_qmulx (2*zFar, zNear)), (zFar - zNear));
xmax = COGL_FIXED_FAST_DIV (ymax, aspect);
x = COGL_FIXED_FAST_DIV (zNear, xmax);
y = COGL_FIXED_FAST_DIV (zNear, ymax);
c = COGL_FIXED_FAST_DIV (-(zFar + zNear), ( zFar - zNear));
d = cogl_fixed_mul_div (-(2 * zFar), zNear, (zFar - zNear));
#define M(row,col) m[col*4+row]
M(0,0) = CLUTTER_FIXED_TO_FLOAT (x);
M(1,1) = CLUTTER_FIXED_TO_FLOAT (y);
M(2,2) = CLUTTER_FIXED_TO_FLOAT (c);
M(2,3) = CLUTTER_FIXED_TO_FLOAT (d);
M(0,0) = COGL_FIXED_TO_FLOAT (x);
M(1,1) = COGL_FIXED_TO_FLOAT (y);
M(2,2) = COGL_FIXED_TO_FLOAT (c);
M(2,3) = COGL_FIXED_TO_FLOAT (d);
M(3,2) = -1.0F;
GE( glMultMatrixf (m) );
@ -794,22 +797,22 @@ cogl_perspective (ClutterFixed fovy,
memset (ctx->inverse_projection, 0, sizeof (GLfloat) * 16);
#define m ctx->inverse_projection
M(0, 0) = 1.0f / CLUTTER_FIXED_TO_FLOAT (x);
M(1, 1) = 1.0f / CLUTTER_FIXED_TO_FLOAT (y);
M(0, 0) = 1.0f / COGL_FIXED_TO_FLOAT (x);
M(1, 1) = 1.0f / COGL_FIXED_TO_FLOAT (y);
M(2, 3) = -1.0f;
M(3, 2) = 1.0f / CLUTTER_FIXED_TO_FLOAT (d);
M(3, 3) = CLUTTER_FIXED_TO_FLOAT (c) / CLUTTER_FIXED_TO_FLOAT (d);
M(3, 2) = 1.0f / COGL_FIXED_TO_FLOAT (d);
M(3, 3) = COGL_FIXED_TO_FLOAT (c) / COGL_FIXED_TO_FLOAT (d);
#undef m
#undef M
}
void
cogl_frustum (ClutterFixed left,
ClutterFixed right,
ClutterFixed bottom,
ClutterFixed top,
ClutterFixed z_near,
ClutterFixed z_far)
cogl_frustum (CoglFixed left,
CoglFixed right,
CoglFixed bottom,
CoglFixed top,
CoglFixed z_near,
CoglFixed z_far)
{
GLfloat c, d;
@ -818,32 +821,32 @@ cogl_frustum (ClutterFixed left,
GE( glMatrixMode (GL_PROJECTION) );
GE( glLoadIdentity () );
GE( glFrustum (CLUTTER_FIXED_TO_DOUBLE (left),
CLUTTER_FIXED_TO_DOUBLE (right),
CLUTTER_FIXED_TO_DOUBLE (bottom),
CLUTTER_FIXED_TO_DOUBLE (top),
CLUTTER_FIXED_TO_DOUBLE (z_near),
CLUTTER_FIXED_TO_DOUBLE (z_far)) );
GE( glFrustum (COGL_FIXED_TO_DOUBLE (left),
COGL_FIXED_TO_DOUBLE (right),
COGL_FIXED_TO_DOUBLE (bottom),
COGL_FIXED_TO_DOUBLE (top),
COGL_FIXED_TO_DOUBLE (z_near),
COGL_FIXED_TO_DOUBLE (z_far)) );
GE( glMatrixMode (GL_MODELVIEW) );
/* Calculate and store the inverse of the matrix */
memset (ctx->inverse_projection, 0, sizeof (GLfloat) * 16);
c = -CLUTTER_FIXED_TO_FLOAT (z_far + z_near)
/ CLUTTER_FIXED_TO_FLOAT (z_far - z_near);
d = -CLUTTER_FIXED_TO_FLOAT (2 * CFX_QMUL (z_far, z_near))
/ CLUTTER_FIXED_TO_FLOAT (z_far - z_near);
c = -COGL_FIXED_TO_FLOAT (z_far + z_near)
/ COGL_FIXED_TO_FLOAT (z_far - z_near);
d = -COGL_FIXED_TO_FLOAT (2 * COGL_FIXED_MUL (z_far, z_near))
/ COGL_FIXED_TO_FLOAT (z_far - z_near);
#define M(row,col) ctx->inverse_projection[col*4+row]
M(0,0) = CLUTTER_FIXED_TO_FLOAT (right - left)
/ CLUTTER_FIXED_TO_FLOAT (2 * z_near);
M(0,3) = CLUTTER_FIXED_TO_FLOAT (right + left)
/ CLUTTER_FIXED_TO_FLOAT (2 * z_near);
M(1,1) = CLUTTER_FIXED_TO_FLOAT (top - bottom)
/ CLUTTER_FIXED_TO_FLOAT (2 * z_near);
M(1,3) = CLUTTER_FIXED_TO_FLOAT (top + bottom)
/ CLUTTER_FIXED_TO_FLOAT (2 * z_near);
M(0,0) = COGL_FIXED_TO_FLOAT (right - left)
/ COGL_FIXED_TO_FLOAT (2 * z_near);
M(0,3) = COGL_FIXED_TO_FLOAT (right + left)
/ COGL_FIXED_TO_FLOAT (2 * z_near);
M(1,1) = COGL_FIXED_TO_FLOAT (top - bottom)
/ COGL_FIXED_TO_FLOAT (2 * z_near);
M(1,3) = COGL_FIXED_TO_FLOAT (top + bottom)
/ COGL_FIXED_TO_FLOAT (2 * z_near);
M(2,3) = -1.0f;
M(3,2) = 1.0f / d;
M(3,3) = c / d;
@ -860,10 +863,10 @@ cogl_viewport (guint width,
void
cogl_setup_viewport (guint width,
guint height,
ClutterFixed fovy,
ClutterFixed aspect,
ClutterFixed z_near,
ClutterFixed z_far)
CoglFixed fovy,
CoglFixed aspect,
CoglFixed z_near,
CoglFixed z_far)
{
GLfloat z_camera;
@ -891,13 +894,13 @@ cogl_setup_viewport (guint width,
z_camera = DEFAULT_Z_CAMERA;
if (fovy != CFX_60)
if (fovy != COGL_FIXED_60)
{
ClutterFixed fovy_rad = CFX_MUL (fovy, CFX_PI) / 180;
CoglFixed fovy_rad = COGL_FIXED_MUL (fovy, COGL_FIXED_PI) / 180;
z_camera =
CLUTTER_FIXED_TO_FLOAT (CFX_DIV (clutter_sinx (fovy_rad),
clutter_cosx (fovy_rad)) >> 1);
COGL_FIXED_TO_FLOAT (COGL_FIXED_DIV (cogl_fixed_sin (fovy_rad),
cogl_fixed_cos (fovy_rad)) >> 1);
}
GE( glTranslatef (-0.5f, -0.5f, -z_camera) );
@ -1141,75 +1144,75 @@ cogl_features_available (CoglFeatureFlags features)
}
void
cogl_get_modelview_matrix (ClutterFixed m[16])
cogl_get_modelview_matrix (CoglFixed m[16])
{
GLdouble md[16];
glGetDoublev(GL_MODELVIEW_MATRIX, &md[0]);
#define M(m,row,col) m[col*4+row]
M(m,0,0) = CLUTTER_FLOAT_TO_FIXED (M(md,0,0));
M(m,0,1) = CLUTTER_FLOAT_TO_FIXED (M(md,0,1));
M(m,0,2) = CLUTTER_FLOAT_TO_FIXED (M(md,0,2));
M(m,0,3) = CLUTTER_FLOAT_TO_FIXED (M(md,0,3));
M(m,0,0) = COGL_FIXED_FROM_FLOAT (M(md,0,0));
M(m,0,1) = COGL_FIXED_FROM_FLOAT (M(md,0,1));
M(m,0,2) = COGL_FIXED_FROM_FLOAT (M(md,0,2));
M(m,0,3) = COGL_FIXED_FROM_FLOAT (M(md,0,3));
M(m,1,0) = CLUTTER_FLOAT_TO_FIXED (M(md,1,0));
M(m,1,1) = CLUTTER_FLOAT_TO_FIXED (M(md,1,1));
M(m,1,2) = CLUTTER_FLOAT_TO_FIXED (M(md,1,2));
M(m,1,3) = CLUTTER_FLOAT_TO_FIXED (M(md,1,3));
M(m,1,0) = COGL_FIXED_FROM_FLOAT (M(md,1,0));
M(m,1,1) = COGL_FIXED_FROM_FLOAT (M(md,1,1));
M(m,1,2) = COGL_FIXED_FROM_FLOAT (M(md,1,2));
M(m,1,3) = COGL_FIXED_FROM_FLOAT (M(md,1,3));
M(m,2,0) = CLUTTER_FLOAT_TO_FIXED (M(md,2,0));
M(m,2,1) = CLUTTER_FLOAT_TO_FIXED (M(md,2,1));
M(m,2,2) = CLUTTER_FLOAT_TO_FIXED (M(md,2,2));
M(m,2,3) = CLUTTER_FLOAT_TO_FIXED (M(md,2,3));
M(m,2,0) = COGL_FIXED_FROM_FLOAT (M(md,2,0));
M(m,2,1) = COGL_FIXED_FROM_FLOAT (M(md,2,1));
M(m,2,2) = COGL_FIXED_FROM_FLOAT (M(md,2,2));
M(m,2,3) = COGL_FIXED_FROM_FLOAT (M(md,2,3));
M(m,3,0) = CLUTTER_FLOAT_TO_FIXED (M(md,3,0));
M(m,3,1) = CLUTTER_FLOAT_TO_FIXED (M(md,3,1));
M(m,3,2) = CLUTTER_FLOAT_TO_FIXED (M(md,3,2));
M(m,3,3) = CLUTTER_FLOAT_TO_FIXED (M(md,3,3));
M(m,3,0) = COGL_FIXED_FROM_FLOAT (M(md,3,0));
M(m,3,1) = COGL_FIXED_FROM_FLOAT (M(md,3,1));
M(m,3,2) = COGL_FIXED_FROM_FLOAT (M(md,3,2));
M(m,3,3) = COGL_FIXED_FROM_FLOAT (M(md,3,3));
#undef M
}
void
cogl_get_projection_matrix (ClutterFixed m[16])
cogl_get_projection_matrix (CoglFixed m[16])
{
GLdouble md[16];
glGetDoublev(GL_PROJECTION_MATRIX, &md[0]);
#define M(m,row,col) m[col*4+row]
M(m,0,0) = CLUTTER_FLOAT_TO_FIXED (M(md,0,0));
M(m,0,1) = CLUTTER_FLOAT_TO_FIXED (M(md,0,1));
M(m,0,2) = CLUTTER_FLOAT_TO_FIXED (M(md,0,2));
M(m,0,3) = CLUTTER_FLOAT_TO_FIXED (M(md,0,3));
M(m,0,0) = COGL_FIXED_FROM_FLOAT (M(md,0,0));
M(m,0,1) = COGL_FIXED_FROM_FLOAT (M(md,0,1));
M(m,0,2) = COGL_FIXED_FROM_FLOAT (M(md,0,2));
M(m,0,3) = COGL_FIXED_FROM_FLOAT (M(md,0,3));
M(m,1,0) = CLUTTER_FLOAT_TO_FIXED (M(md,1,0));
M(m,1,1) = CLUTTER_FLOAT_TO_FIXED (M(md,1,1));
M(m,1,2) = CLUTTER_FLOAT_TO_FIXED (M(md,1,2));
M(m,1,3) = CLUTTER_FLOAT_TO_FIXED (M(md,1,3));
M(m,1,0) = COGL_FIXED_FROM_FLOAT (M(md,1,0));
M(m,1,1) = COGL_FIXED_FROM_FLOAT (M(md,1,1));
M(m,1,2) = COGL_FIXED_FROM_FLOAT (M(md,1,2));
M(m,1,3) = COGL_FIXED_FROM_FLOAT (M(md,1,3));
M(m,2,0) = CLUTTER_FLOAT_TO_FIXED (M(md,2,0));
M(m,2,1) = CLUTTER_FLOAT_TO_FIXED (M(md,2,1));
M(m,2,2) = CLUTTER_FLOAT_TO_FIXED (M(md,2,2));
M(m,2,3) = CLUTTER_FLOAT_TO_FIXED (M(md,2,3));
M(m,2,0) = COGL_FIXED_FROM_FLOAT (M(md,2,0));
M(m,2,1) = COGL_FIXED_FROM_FLOAT (M(md,2,1));
M(m,2,2) = COGL_FIXED_FROM_FLOAT (M(md,2,2));
M(m,2,3) = COGL_FIXED_FROM_FLOAT (M(md,2,3));
M(m,3,0) = CLUTTER_FLOAT_TO_FIXED (M(md,3,0));
M(m,3,1) = CLUTTER_FLOAT_TO_FIXED (M(md,3,1));
M(m,3,2) = CLUTTER_FLOAT_TO_FIXED (M(md,3,2));
M(m,3,3) = CLUTTER_FLOAT_TO_FIXED (M(md,3,3));
M(m,3,0) = COGL_FIXED_FROM_FLOAT (M(md,3,0));
M(m,3,1) = COGL_FIXED_FROM_FLOAT (M(md,3,1));
M(m,3,2) = COGL_FIXED_FROM_FLOAT (M(md,3,2));
M(m,3,3) = COGL_FIXED_FROM_FLOAT (M(md,3,3));
#undef M
}
void
cogl_get_viewport (ClutterFixed v[4])
cogl_get_viewport (CoglFixed v[4])
{
GLdouble vd[4];
glGetDoublev(GL_VIEWPORT, &vd[0]);
v[0] = CLUTTER_FLOAT_TO_FIXED (vd[0]);
v[1] = CLUTTER_FLOAT_TO_FIXED (vd[1]);
v[2] = CLUTTER_FLOAT_TO_FIXED (vd[2]);
v[3] = CLUTTER_FLOAT_TO_FIXED (vd[3]);
v[0] = COGL_FIXED_FROM_FLOAT (vd[0]);
v[1] = COGL_FIXED_FROM_FLOAT (vd[1]);
v[2] = COGL_FIXED_FROM_FLOAT (vd[2]);
v[3] = COGL_FIXED_FROM_FLOAT (vd[3]);
}
void
@ -1240,9 +1243,9 @@ cogl_get_bitmasks (gint *red, gint *green, gint *blue, gint *alpha)
void
cogl_fog_set (const ClutterColor *fog_color,
ClutterFixed density,
ClutterFixed start,
ClutterFixed stop)
CoglFixed density,
CoglFixed start,
CoglFixed stop)
{
GLfloat fogColor[4];
@ -1258,7 +1261,7 @@ cogl_fog_set (const ClutterColor *fog_color,
glFogi (GL_FOG_MODE, GL_LINEAR);
glHint (GL_FOG_HINT, GL_NICEST);
glFogf (GL_FOG_DENSITY, CLUTTER_FIXED_TO_FLOAT (density));
glFogf (GL_FOG_START, CLUTTER_FIXED_TO_FLOAT (start));
glFogf (GL_FOG_END, CLUTTER_FIXED_TO_FLOAT (stop));
glFogf (GL_FOG_DENSITY, COGL_FIXED_TO_FLOAT (density));
glFogf (GL_FOG_START, COGL_FIXED_TO_FLOAT (start));
glFogf (GL_FOG_END, COGL_FIXED_TO_FLOAT (stop));
}

7
gles/Makefile.am
View File

@ -1,6 +1,8 @@
libclutterincludedir = $(includedir)/clutter-@CLUTTER_API_VERSION@/cogl
libclutterinclude_HEADERS = $(top_builddir)/clutter/cogl/cogl.h \
$(top_builddir)/clutter/cogl/cogl-defines-gles.h
libclutterinclude_HEADERS = \
$(top_builddir)/clutter/cogl/cogl.h \
$(top_builddir)/clutter/cogl/cogl-defines-gles.h \
$(top_builddir)/clutter/cogl/cogl-fixed.h
INCLUDES = \
-I$(top_srcdir) \
@ -21,6 +23,7 @@ noinst_LTLIBRARIES = libclutter-cogl.la
libclutter_cogl_la_SOURCES = \
$(top_builddir)/clutter/cogl/cogl.h \
$(top_builddir)/clutter/cogl/cogl-defines-gles.h \
$(top_builddir)/clutter/cogl/cogl-fixed.h \
cogl-internal.h \
cogl-texture.h \
cogl-fbo.h \

12
gles/cogl-fbo.c
View File

@ -227,12 +227,12 @@ cogl_draw_buffer (CoglBufferTarget target, CoglHandle offscreen)
/* Setup new viewport and matrices */
GE( glViewport (0, 0, fbo->width, fbo->height) );
GE( cogl_wrap_glTranslatex (-CFX_ONE, -CFX_ONE, 0) );
GE( cogl_wrap_glScalex (CFX_QDIV (CLUTTER_INT_TO_FIXED (2),
CLUTTER_INT_TO_FIXED (fbo->width)),
CFX_QDIV (CLUTTER_INT_TO_FIXED (2),
CLUTTER_INT_TO_FIXED (fbo->height)),
CFX_ONE) );
GE( cogl_wrap_glTranslatex (-COGL_FIXED_1, -COGL_FIXED_1, 0) );
GE( cogl_wrap_glScalex (COGL_FIXED_DIV (COGL_FIXED_FROM_INT (2),
COGL_FIXED_FROM_INT (fbo->width)),
COGL_FIXED_DIV (COGL_FIXED_FROM_INT (2),
COGL_FIXED_FROM_INT (fbo->height)),
COGL_FIXED_1) );
/* Bind offscreen framebuffer object */
GE( glBindFramebuffer (GL_FRAMEBUFFER, fbo->gl_handle) );

88
gles/cogl-gles2-wrapper.c
View File

@ -118,7 +118,7 @@ cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper)
/* Initialize the fogging options */
cogl_wrap_glDisable (GL_FOG);
cogl_wrap_glFogx (GL_FOG_MODE, GL_LINEAR);
cogl_wrap_glFogx (GL_FOG_DENSITY, CFX_ONE);
cogl_wrap_glFogx (GL_FOG_DENSITY, COGL_FIXED_1);
cogl_wrap_glFogx (GL_FOG_START, 0);
cogl_wrap_glFogx (GL_FOG_END, 1);
cogl_wrap_glFogxv (GL_FOG_COLOR, default_fog_color);
@ -506,10 +506,10 @@ cogl_gles2_wrapper_update_matrix (CoglGles2Wrapper *wrapper, GLenum matrix_num)
void
cogl_wrap_glClearColorx (GLclampx r, GLclampx g, GLclampx b, GLclampx a)
{
glClearColor (CLUTTER_FIXED_TO_FLOAT (r),
CLUTTER_FIXED_TO_FLOAT (g),
CLUTTER_FIXED_TO_FLOAT (b),
CLUTTER_FIXED_TO_FLOAT (a));
glClearColor (COGL_FIXED_TO_FLOAT (r),
COGL_FIXED_TO_FLOAT (g),
COGL_FIXED_TO_FLOAT (b),
COGL_FIXED_TO_FLOAT (a));
}
void
@ -661,7 +661,7 @@ cogl_wrap_glMultMatrixx (const GLfixed *m)
int i;
for (i = 0; i < 16; i++)
new_matrix[i] = CLUTTER_FIXED_TO_FLOAT (m[i]);
new_matrix[i] = COGL_FIXED_TO_FLOAT (m[i]);
cogl_wrap_glMultMatrix (new_matrix);
}
@ -672,21 +672,21 @@ cogl_wrap_glFrustumx (GLfixed left, GLfixed right,
GLfixed z_near, GLfixed z_far)
{
float matrix[16];
float two_near = CLUTTER_FIXED_TO_FLOAT (2 * z_near);
float two_near = COGL_FIXED_TO_FLOAT (2 * z_near);
memset (matrix, 0, sizeof (matrix));
matrix[0] = two_near / CLUTTER_FIXED_TO_FLOAT (right - left);
matrix[5] = two_near / CLUTTER_FIXED_TO_FLOAT (top - bottom);
matrix[8] = CLUTTER_FIXED_TO_FLOAT (right + left)
/ CLUTTER_FIXED_TO_FLOAT (right - left);
matrix[9] = CLUTTER_FIXED_TO_FLOAT (top + bottom)
/ CLUTTER_FIXED_TO_FLOAT (top - bottom);
matrix[10] = -CLUTTER_FIXED_TO_FLOAT (z_far + z_near)
/ CLUTTER_FIXED_TO_FLOAT (z_far - z_near);
matrix[0] = two_near / COGL_FIXED_TO_FLOAT (right - left);
matrix[5] = two_near / COGL_FIXED_TO_FLOAT (top - bottom);
matrix[8] = COGL_FIXED_TO_FLOAT (right + left)
/ COGL_FIXED_TO_FLOAT (right - left);
matrix[9] = COGL_FIXED_TO_FLOAT (top + bottom)
/ COGL_FIXED_TO_FLOAT (top - bottom);
matrix[10] = -COGL_FIXED_TO_FLOAT (z_far + z_near)
/ COGL_FIXED_TO_FLOAT (z_far - z_near);
matrix[11] = -1.0f;
matrix[14] = -two_near * CLUTTER_FIXED_TO_FLOAT (z_far)
/ CLUTTER_FIXED_TO_FLOAT (z_far - z_near);
matrix[14] = -two_near * COGL_FIXED_TO_FLOAT (z_far)
/ COGL_FIXED_TO_FLOAT (z_far - z_near);
cogl_wrap_glMultMatrix (matrix);
}
@ -697,9 +697,9 @@ cogl_wrap_glScalex (GLfixed x, GLfixed y, GLfixed z)
float matrix[16];
memset (matrix, 0, sizeof (matrix));
matrix[0] = CLUTTER_FIXED_TO_FLOAT (x);
matrix[5] = CLUTTER_FIXED_TO_FLOAT (y);
matrix[10] = CLUTTER_FIXED_TO_FLOAT (z);
matrix[0] = COGL_FIXED_TO_FLOAT (x);
matrix[5] = COGL_FIXED_TO_FLOAT (y);
matrix[10] = COGL_FIXED_TO_FLOAT (z);
matrix[15] = 1.0f;
cogl_wrap_glMultMatrix (matrix);
@ -714,9 +714,9 @@ cogl_wrap_glTranslatex (GLfixed x, GLfixed y, GLfixed z)
matrix[0] = 1.0f;
matrix[5] = 1.0f;
matrix[10] = 1.0f;
matrix[12] = CLUTTER_FIXED_TO_FLOAT (x);
matrix[13] = CLUTTER_FIXED_TO_FLOAT (y);
matrix[14] = CLUTTER_FIXED_TO_FLOAT (z);
matrix[12] = COGL_FIXED_TO_FLOAT (x);
matrix[13] = COGL_FIXED_TO_FLOAT (y);
matrix[14] = COGL_FIXED_TO_FLOAT (z);
matrix[15] = 1.0f;
cogl_wrap_glMultMatrix (matrix);
@ -726,10 +726,10 @@ void
cogl_wrap_glRotatex (GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
{
float matrix[16];
float xf = CLUTTER_FIXED_TO_FLOAT (x);
float yf = CLUTTER_FIXED_TO_FLOAT (y);
float zf = CLUTTER_FIXED_TO_FLOAT (z);
float anglef = CLUTTER_FIXED_TO_FLOAT (angle) * G_PI / 180.0f;
float xf = COGL_FIXED_TO_FLOAT (x);
float yf = COGL_FIXED_TO_FLOAT (y);
float zf = COGL_FIXED_TO_FLOAT (z);
float anglef = COGL_FIXED_TO_FLOAT (angle) * G_PI / 180.0f;
float c = cosf (anglef);
float s = sinf (anglef);
@ -761,17 +761,17 @@ cogl_wrap_glOrthox (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top,
GLfixed near, GLfixed far)
{
float matrix[16];
float xrange = CLUTTER_FIXED_TO_FLOAT (right - left);
float yrange = CLUTTER_FIXED_TO_FLOAT (top - bottom);
float zrange = CLUTTER_FIXED_TO_FLOAT (far - near);
float xrange = COGL_FIXED_TO_FLOAT (right - left);
float yrange = COGL_FIXED_TO_FLOAT (top - bottom);
float zrange = COGL_FIXED_TO_FLOAT (far - near);
memset (matrix, 0, sizeof (matrix));
matrix[0] = 2.0f / xrange;
matrix[5] = 2.0f / yrange;
matrix[10] = 2.0f / zrange;
matrix[12] = CLUTTER_FIXED_TO_FLOAT (right + left) / xrange;
matrix[13] = CLUTTER_FIXED_TO_FLOAT (top + bottom) / yrange;
matrix[14] = CLUTTER_FIXED_TO_FLOAT (far + near) / zrange;
matrix[12] = COGL_FIXED_TO_FLOAT (right + left) / xrange;
matrix[13] = COGL_FIXED_TO_FLOAT (top + bottom) / yrange;
matrix[14] = COGL_FIXED_TO_FLOAT (far + near) / zrange;
matrix[15] = 1.0f;
cogl_wrap_glMultMatrix (matrix);
@ -1030,10 +1030,10 @@ void
cogl_wrap_glColor4x (GLclampx r, GLclampx g, GLclampx b, GLclampx a)
{
glVertexAttrib4f (COGL_GLES2_WRAPPER_COLOR_ATTRIB,
CLUTTER_FIXED_TO_FLOAT (r),
CLUTTER_FIXED_TO_FLOAT (g),
CLUTTER_FIXED_TO_FLOAT (b),
CLUTTER_FIXED_TO_FLOAT (a));
COGL_FIXED_TO_FLOAT (r),
COGL_FIXED_TO_FLOAT (g),
COGL_FIXED_TO_FLOAT (b),
COGL_FIXED_TO_FLOAT (a));
}
void
@ -1043,11 +1043,12 @@ cogl_wrap_glClipPlanex (GLenum plane, GLfixed *equation)
}
static void
cogl_gles2_float_array_to_fixed (int size, const GLfloat *floats,
cogl_gles2_float_array_to_fixed (int size,
const GLfloat *floats,
GLfixed *fixeds)
{
while (size-- > 0)
*(fixeds++) = CLUTTER_FLOAT_TO_FIXED (*(floats++));
*(fixeds++) = COGL_FIXED_FROM_FLOAT (*(floats++));
}
void
@ -1110,17 +1111,17 @@ cogl_wrap_glFogx (GLenum pname, GLfixed param)
case GL_FOG_DENSITY:
_COGL_GLES2_CHANGE_UNIFORM (w, FOG_DENSITY, fog_density,
CLUTTER_FIXED_TO_FLOAT (param));
COGL_FIXED_TO_FLOAT (param));
break;
case GL_FOG_START:
_COGL_GLES2_CHANGE_UNIFORM (w, FOG_START, fog_start,
CLUTTER_FIXED_TO_FLOAT (param));
COGL_FIXED_TO_FLOAT (param));
break;
case GL_FOG_END:
_COGL_GLES2_CHANGE_UNIFORM (w, FOG_END, fog_end,
CLUTTER_FIXED_TO_FLOAT (param));
COGL_FIXED_TO_FLOAT (param));
break;
}
}
@ -1134,7 +1135,8 @@ cogl_wrap_glFogxv (GLenum pname, const GLfixed *params)
if (pname == GL_FOG_COLOR)
{
for (i = 0; i < 4; i++)
w->fog_color[i] = CLUTTER_FIXED_TO_FLOAT (params[i]);
w->fog_color[i] = COGL_FIXED_TO_FLOAT (params[i]);
w->dirty_uniforms |= COGL_GLES2_DIRTY_FOG_COLOR;
}
}

36
gles/cogl-primitives.c
View File

@ -64,10 +64,10 @@ _cogl_rectangle (gint x,
void
_cogl_rectanglex (ClutterFixed x,
ClutterFixed y,
ClutterFixed width,
ClutterFixed height)
_cogl_rectanglex (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height)
{
GLfixed rect_verts[8] = {
x, y,
@ -102,8 +102,8 @@ _cogl_path_clear_nodes ()
}
void
_cogl_path_add_node (ClutterFixed x,
ClutterFixed y)
_cogl_path_add_node (CoglFixed x,
CoglFixed y)
{
CoglFixedVec2 *new_nodes = NULL;
@ -168,10 +168,10 @@ _cogl_path_fill_nodes ()
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
bounds_x = CLUTTER_FIXED_FLOOR (ctx->path_nodes_min.x);
bounds_y = CLUTTER_FIXED_FLOOR (ctx->path_nodes_min.y);
bounds_w = CLUTTER_FIXED_CEIL (ctx->path_nodes_max.x - ctx->path_nodes_min.x);
bounds_h = CLUTTER_FIXED_CEIL (ctx->path_nodes_max.y - ctx->path_nodes_min.y);
bounds_x = COGL_FIXED_FLOOR (ctx->path_nodes_min.x);
bounds_y = COGL_FIXED_FLOOR (ctx->path_nodes_min.y);
bounds_w = COGL_FIXED_CEIL (ctx->path_nodes_max.x - ctx->path_nodes_min.x);
bounds_h = COGL_FIXED_CEIL (ctx->path_nodes_max.y - ctx->path_nodes_min.y);
if (cogl_features_available (COGL_FEATURE_STENCIL_BUFFER))
{
@ -223,14 +223,14 @@ _cogl_path_fill_nodes ()
for (i=0; i < bounds_h; i++)
scanlines[i]=NULL;
first_x = prev_x = CLUTTER_FIXED_TO_INT (ctx->path_nodes[0].x);
first_y = prev_y = CLUTTER_FIXED_TO_INT (ctx->path_nodes[0].y);
first_x = prev_x = COGL_FIXED_TO_INT (ctx->path_nodes[0].x);
first_y = prev_y = COGL_FIXED_TO_INT (ctx->path_nodes[0].y);
/* create scanline intersection list */
for (i=1; i<ctx->path_nodes_size; i++)
{
gint dest_x = CLUTTER_FIXED_TO_INT (ctx->path_nodes[i].x);
gint dest_y = CLUTTER_FIXED_TO_INT (ctx->path_nodes[i].y);
gint dest_x = COGL_FIXED_TO_INT (ctx->path_nodes[i].x);
gint dest_y = COGL_FIXED_TO_INT (ctx->path_nodes[i].y);
gint ydir;
gint dx;
gint dy;
@ -326,10 +326,10 @@ _cogl_path_fill_nodes ()
if (!next)
break;
x0 = CLUTTER_INT_TO_FIXED (GPOINTER_TO_INT (iter->data));
x1 = CLUTTER_INT_TO_FIXED (GPOINTER_TO_INT (next->data));
y0 = CLUTTER_INT_TO_FIXED (bounds_y + i);
y1 = CLUTTER_INT_TO_FIXED (bounds_y + i + 1) + 2048;
x0 = COGL_FIXED_FROM_INT (GPOINTER_TO_INT (iter->data));
x1 = COGL_FIXED_FROM_INT (GPOINTER_TO_INT (next->data));
y0 = COGL_FIXED_FROM_INT (bounds_y + i);
y1 = COGL_FIXED_FROM_INT (bounds_y + i + 1) + 2048;
/* render scanlines 1.0625 high to avoid gaps when
transformed */

198
gles/cogl-texture.c
View File

@ -55,15 +55,15 @@ struct _CoglSpanIter
gint index;
GArray *array;
CoglTexSliceSpan *span;
ClutterFixed pos;
ClutterFixed next_pos;
ClutterFixed origin;
ClutterFixed cover_start;
ClutterFixed cover_end;
ClutterFixed intersect_start;
ClutterFixed intersect_end;
ClutterFixed intersect_start_local;
ClutterFixed intersect_end_local;
CoglFixed pos;
CoglFixed next_pos;
CoglFixed origin;
CoglFixed cover_start;
CoglFixed cover_end;
CoglFixed intersect_start;
CoglFixed intersect_end;
CoglFixed intersect_start_local;
CoglFixed intersect_end_local;
gboolean intersects;
};
@ -108,7 +108,7 @@ _cogl_span_iter_update (CoglSpanIter *iter)
/* Offset next position by span size */
iter->next_pos = iter->pos +
CLUTTER_INT_TO_FIXED (iter->span->size - iter->span->waste);
COGL_FIXED_FROM_INT (iter->span->size - iter->span->waste);
/* Check if span intersects the area to cover */
if (iter->next_pos <= iter->cover_start ||
@ -137,9 +137,9 @@ _cogl_span_iter_update (CoglSpanIter *iter)
static void
_cogl_span_iter_begin (CoglSpanIter *iter,
GArray *array,
ClutterFixed origin,
ClutterFixed cover_start,
ClutterFixed cover_end)
CoglFixed origin,
CoglFixed cover_start,
CoglFixed cover_end)
{
/* Copy info */
iter->index = 0;
@ -342,10 +342,10 @@ _cogl_texture_draw_and_read (CoglTexture *tex,
GLint *viewport)
{
gint bpp;
ClutterFixed rx1, ry1;
ClutterFixed rx2, ry2;
ClutterFixed tx1, ty1;
ClutterFixed tx2, ty2;
CoglFixed rx1, ry1;
CoglFixed rx2, ry2;
CoglFixed tx1, ty1;
CoglFixed tx2, ty2;
int bw, bh;
CoglBitmap rect_bmp;
CoglHandle handle;
@ -366,9 +366,9 @@ _cogl_texture_draw_and_read (CoglTexture *tex,
/* Draw the texture image */
cogl_texture_rectangle (handle,
0, 0,
CLUTTER_INT_TO_FIXED (tex->bitmap.width),
CLUTTER_INT_TO_FIXED (tex->bitmap.height),
0, 0, CFX_ONE, CFX_ONE);
COGL_FIXED_FROM_INT (tex->bitmap.width),
COGL_FIXED_FROM_INT (tex->bitmap.height),
0, 0, COGL_FIXED_1, COGL_FIXED_1);
/* Read into target bitmap */
GE( glPixelStorei (GL_PACK_ALIGNMENT, 1) );
@ -383,7 +383,7 @@ _cogl_texture_draw_and_read (CoglTexture *tex,
ry1 = 0; ry2 = 0;
ty1 = 0; ty2 = 0;
#define CFIX CLUTTER_INT_TO_FIXED
#define CFIX COGL_FIXED_FROM_INT
/* Walk Y axis until whole bitmap height consumed */
for (bh = tex->bitmap.height; bh > 0; bh -= viewport[3])
@ -394,7 +394,7 @@ _cogl_texture_draw_and_read (CoglTexture *tex,
/* Normalized texture Y coords */
ty1 = ty2;
ty2 = CFX_QDIV (CFIX (ry2), CFIX (tex->bitmap.height));
ty2 = COGL_FIXED_DIV (CFIX (ry2), CFIX (tex->bitmap.height));
rx1 = 0; rx2 = 0;
tx1 = 0; tx2 = 0;
@ -408,7 +408,7 @@ _cogl_texture_draw_and_read (CoglTexture *tex,
/* Normalized texture X coords */
tx1 = tx2;
tx2 = CFX_QDIV (CFIX (rx2), CFIX (tex->bitmap.width));
tx2 = COGL_FIXED_DIV (CFIX (rx2), CFIX (tex->bitmap.width));
/* Clear buffer with transparent black, draw with white
for direct copy to framebuffer */
@ -486,10 +486,10 @@ _cogl_texture_download_from_gl (CoglTexture *tex,
GE( cogl_wrap_glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () );
GE( cogl_wrap_glOrthox (0, CLUTTER_INT_TO_FIXED (viewport[2]),
0, CLUTTER_INT_TO_FIXED (viewport[3]),
CLUTTER_INT_TO_FIXED (0),
CLUTTER_INT_TO_FIXED (100)) );
GE( cogl_wrap_glOrthox (0, COGL_FIXED_FROM_INT (viewport[2]),
0, COGL_FIXED_FROM_INT (viewport[3]),
COGL_FIXED_FROM_INT (0),
COGL_FIXED_FROM_INT (100)) );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPushMatrix () );
@ -608,8 +608,8 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
/* Iterate vertical spans */
for (source_y = src_y,
_cogl_span_iter_begin (&y_iter, tex->slice_y_spans,
0, CLUTTER_INT_TO_FIXED (dst_y),
CLUTTER_INT_TO_FIXED (dst_y + height));
0, COGL_FIXED_FROM_INT (dst_y),
COGL_FIXED_FROM_INT (dst_y + height));
!_cogl_span_iter_end (&y_iter);
@ -629,8 +629,8 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
/* Iterate horizontal spans */
for (source_x = src_x,
_cogl_span_iter_begin (&x_iter, tex->slice_x_spans,
0, CLUTTER_INT_TO_FIXED (dst_x),
CLUTTER_INT_TO_FIXED (dst_x + width));
0, COGL_FIXED_FROM_INT (dst_x),
COGL_FIXED_FROM_INT (dst_x + width));
!_cogl_span_iter_end (&x_iter);
@ -648,15 +648,15 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
x_iter.index);
/* Pick intersection width and height */
inter_w = CLUTTER_FIXED_TO_INT (x_iter.intersect_end -
inter_w = COGL_FIXED_TO_INT (x_iter.intersect_end -
x_iter.intersect_start);
inter_h = CLUTTER_FIXED_TO_INT (y_iter.intersect_end -
inter_h = COGL_FIXED_TO_INT (y_iter.intersect_end -
y_iter.intersect_start);
/* Localize intersection top-left corner to slice*/
local_x = CLUTTER_FIXED_TO_INT (x_iter.intersect_start -
local_x = COGL_FIXED_TO_INT (x_iter.intersect_start -
x_iter.pos);
local_y = CLUTTER_FIXED_TO_INT (y_iter.intersect_start -
local_y = COGL_FIXED_TO_INT (y_iter.intersect_start -
y_iter.pos);
/* Pick slice GL handle */
@ -702,7 +702,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
&& local_x + inter_w >= x_span->size - x_span->waste)
{
const guchar *src = source_bmp->data
+ (src_y + CLUTTER_FIXED_TO_INT (y_iter.intersect_start)
+ (src_y + COGL_FIXED_TO_INT (y_iter.intersect_start)
- dst_y) * source_bmp->rowstride
+ (src_x + x_span->start + x_span->size - x_span->waste
- dst_x - 1) * bpp;
@ -734,7 +734,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
&& local_y + inter_h >= y_span->size - y_span->waste)
{
const guchar *src = source_bmp->data
+ (src_x + CLUTTER_FIXED_TO_INT (x_iter.intersect_start)
+ (src_x + COGL_FIXED_TO_INT (x_iter.intersect_start)
- dst_x) * bpp
+ (src_y + y_span->start + y_span->size - y_span->waste
- dst_y - 1) * source_bmp->rowstride;
@ -1886,24 +1886,24 @@ cogl_texture_get_data (CoglHandle handle,
static void
_cogl_texture_quad_sw (CoglTexture *tex,
ClutterFixed x1,
ClutterFixed y1,
ClutterFixed x2,
ClutterFixed y2,
ClutterFixed tx1,
ClutterFixed ty1,
ClutterFixed tx2,
ClutterFixed ty2)
CoglFixed x1,
CoglFixed y1,
CoglFixed x2,
CoglFixed y2,
CoglFixed tx1,
CoglFixed ty1,
CoglFixed tx2,
CoglFixed ty2)
{
CoglSpanIter iter_x , iter_y;
ClutterFixed tw , th;
ClutterFixed tqx , tqy;
ClutterFixed first_tx , first_ty;
ClutterFixed first_qx , first_qy;
ClutterFixed slice_tx1 , slice_ty1;
ClutterFixed slice_tx2 , slice_ty2;
ClutterFixed slice_qx1 , slice_qy1;
ClutterFixed slice_qx2 , slice_qy2;
CoglFixed tw , th;
CoglFixed tqx , tqy;
CoglFixed first_tx , first_ty;
CoglFixed first_qx , first_qy;
CoglFixed slice_tx1 , slice_ty1;
CoglFixed slice_tx2 , slice_ty2;
CoglFixed slice_qx1 , slice_qy1;
CoglFixed slice_qx2 , slice_qy2;
GLfixed tex_coords[8];
GLfixed quad_coords[8];
GLuint gl_handle;
@ -1933,27 +1933,27 @@ _cogl_texture_quad_sw (CoglTexture *tex,
GE( cogl_wrap_glVertexPointer (2, GL_FIXED, 0, quad_coords) );
/* Scale ratio from texture to quad widths */
tw = CLUTTER_INT_TO_FIXED (tex->bitmap.width);
th = CLUTTER_INT_TO_FIXED (tex->bitmap.height);
tw = COGL_FIXED_FROM_INT (tex->bitmap.width);
th = COGL_FIXED_FROM_INT (tex->bitmap.height);
tqx = CFX_QDIV (x2-x1, CFX_QMUL (tw, (tx2 - tx1)));
tqy = CFX_QDIV (y2-y1, CFX_QMUL (th, (ty2 - ty1)));
tqx = COGL_FIXED_DIV (x2-x1, COGL_FIXED_MUL (tw, (tx2 - tx1)));
tqy = COGL_FIXED_DIV (y2-y1, COGL_FIXED_MUL (th, (ty2 - ty1)));
/* Integral texture coordinate for first tile */
first_tx = CLUTTER_INT_TO_FIXED (CLUTTER_FIXED_FLOOR (tx1));
first_ty = CLUTTER_INT_TO_FIXED (CLUTTER_FIXED_FLOOR (ty1));
first_tx = COGL_FIXED_FROM_INT (COGL_FIXED_FLOOR (tx1));
first_ty = COGL_FIXED_FROM_INT (COGL_FIXED_FLOOR (ty1));
/* Denormalize texture coordinates */
first_tx = CFX_QMUL (first_tx, tw);
first_ty = CFX_QMUL (first_ty, th);
tx1 = CFX_QMUL (tx1, tw);
ty1 = CFX_QMUL (ty1, th);
tx2 = CFX_QMUL (tx2, tw);
ty2 = CFX_QMUL (ty2, th);
first_tx = COGL_FIXED_MUL (first_tx, tw);
first_ty = COGL_FIXED_MUL (first_ty, th);
tx1 = COGL_FIXED_MUL (tx1, tw);
ty1 = COGL_FIXED_MUL (ty1, th);
tx2 = COGL_FIXED_MUL (tx2, tw);
ty2 = COGL_FIXED_MUL (ty2, th);
/* Quad coordinate of the first tile */
first_qx = x1 - CFX_QMUL (tx1 - first_tx, tqx);
first_qy = y1 - CFX_QMUL (ty1 - first_ty, tqy);
first_qx = x1 - COGL_FIXED_MUL (tx1 - first_tx, tqx);
first_qy = y1 - COGL_FIXED_MUL (ty1 - first_ty, tqy);
/* Iterate until whole quad height covered */
@ -1967,10 +1967,10 @@ _cogl_texture_quad_sw (CoglTexture *tex,
/* Span-quad intersection in quad coordinates */
slice_qy1 = first_qy +
CFX_QMUL (iter_y.intersect_start - first_ty, tqy);
COGL_FIXED_MUL (iter_y.intersect_start - first_ty, tqy);
slice_qy2 = first_qy +
CFX_QMUL (iter_y.intersect_end - first_ty, tqy);
COGL_FIXED_MUL (iter_y.intersect_end - first_ty, tqy);
/* Localize slice texture coordinates */
slice_ty1 = iter_y.intersect_start - iter_y.pos;
@ -1992,10 +1992,10 @@ _cogl_texture_quad_sw (CoglTexture *tex,
/* Span-quad intersection in quad coordinates */
slice_qx1 = first_qx +
CFX_QMUL (iter_x.intersect_start - first_tx, tqx);
COGL_FIXED_MUL (iter_x.intersect_start - first_tx, tqx);
slice_qx2 = first_qx +
CFX_QMUL (iter_x.intersect_end - first_tx, tqx);
COGL_FIXED_MUL (iter_x.intersect_end - first_tx, tqx);
/* Localize slice texture coordinates */
slice_tx1 = iter_x.intersect_start - iter_x.pos;
@ -2007,14 +2007,14 @@ _cogl_texture_quad_sw (CoglTexture *tex,
#if COGL_DEBUG
printf("~~~~~ slice (%d,%d)\n", iter_x.index, iter_y.index);
printf("qx1: %f\n", CLUTTER_FIXED_TO_FLOAT (slice_qx1));
printf("qy1: %f\n", CLUTTER_FIXED_TO_FLOAT (slice_qy1));
printf("qx2: %f\n", CLUTTER_FIXED_TO_FLOAT (slice_qx2));
printf("qy2: %f\n", CLUTTER_FIXED_TO_FLOAT (slice_qy2));
printf("tx1: %f\n", CLUTTER_FIXED_TO_FLOAT (slice_tx1));
printf("ty1: %f\n", CLUTTER_FIXED_TO_FLOAT (slice_ty1));
printf("tx2: %f\n", CLUTTER_FIXED_TO_FLOAT (slice_tx2));
printf("ty2: %f\n", CLUTTER_FIXED_TO_FLOAT (slice_ty2));
printf("qx1: %f\n", COGL_FIXED_TO_FLOAT (slice_qx1));
printf("qy1: %f\n", COGL_FIXED_TO_FLOAT (slice_qy1));
printf("qx2: %f\n", COGL_FIXED_TO_FLOAT (slice_qx2));
printf("qy2: %f\n", COGL_FIXED_TO_FLOAT (slice_qy2));
printf("tx1: %f\n", COGL_FIXED_TO_FLOAT (slice_tx1));
printf("ty1: %f\n", COGL_FIXED_TO_FLOAT (slice_ty1));
printf("tx2: %f\n", COGL_FIXED_TO_FLOAT (slice_tx2));
printf("ty2: %f\n", COGL_FIXED_TO_FLOAT (slice_ty2));
#endif
/* Pick and bind opengl texture object */
@ -2043,14 +2043,14 @@ _cogl_texture_quad_sw (CoglTexture *tex,
static void
_cogl_texture_quad_hw (CoglTexture *tex,
ClutterFixed x1,
ClutterFixed y1,
ClutterFixed x2,
ClutterFixed y2,
ClutterFixed tx1,
ClutterFixed ty1,
ClutterFixed tx2,
ClutterFixed ty2)
CoglFixed x1,
CoglFixed y1,
CoglFixed x2,
CoglFixed y2,
CoglFixed tx1,
CoglFixed ty1,
CoglFixed tx2,
CoglFixed ty2)
{
GLfixed tex_coords[8];
GLfixed quad_coords[8];
@ -2111,17 +2111,17 @@ _cogl_texture_quad_hw (CoglTexture *tex,
void
cogl_texture_rectangle (CoglHandle handle,
ClutterFixed x1,
ClutterFixed y1,
ClutterFixed x2,
ClutterFixed y2,
ClutterFixed tx1,
ClutterFixed ty1,
ClutterFixed tx2,
ClutterFixed ty2)
CoglFixed x1,
CoglFixed y1,
CoglFixed x2,
CoglFixed y2,
CoglFixed tx1,
CoglFixed ty1,
CoglFixed tx2,
CoglFixed ty2)
{
CoglTexture *tex;
ClutterFixed tempx;
CoglFixed tempx;
/* Check if valid texture */
if (!cogl_is_texture (handle))
@ -2170,9 +2170,9 @@ cogl_texture_rectangle (CoglHandle handle,
}
/* Tile textured quads */
if (tex->slice_gl_handles->len == 1
&& tx1 >= -CFX_ONE && tx2 <= CFX_ONE
&& ty1 >= -CFX_ONE && ty2 <= CFX_ONE)
if (tex->slice_gl_handles->len == 1 &&
tx1 >= -COGL_FIXED_1 && tx2 <= COGL_FIXED_1 &&
ty1 >= -COGL_FIXED_1 && ty2 <= COGL_FIXED_1)
{
_cogl_texture_quad_hw (tex, x1,y1, x2,y2, tx1,ty1, tx2,ty2);
}

231
gles/cogl.c
View File

@ -116,13 +116,13 @@ cogl_pop_matrix (void)
}
void
cogl_scale (ClutterFixed x, ClutterFixed y)
cogl_scale (CoglFixed x, CoglFixed y)
{
GE( cogl_wrap_glScalex (x, y, CFX_ONE) );
GE( cogl_wrap_glScalex (x, y, COGL_FIXED_1) );
}
void
cogl_translatex (ClutterFixed x, ClutterFixed y, ClutterFixed z)
cogl_translatex (CoglFixed x, CoglFixed y, CoglFixed z)
{
GE( cogl_wrap_glTranslatex (x, y, z) );
}
@ -130,16 +130,16 @@ cogl_translatex (ClutterFixed x, ClutterFixed y, ClutterFixed z)
void
cogl_translate (gint x, gint y, gint z)
{
GE( cogl_wrap_glTranslatex (CLUTTER_INT_TO_FIXED(x),
CLUTTER_INT_TO_FIXED(y),
CLUTTER_INT_TO_FIXED(z)) );
GE( cogl_wrap_glTranslatex (COGL_FIXED_FROM_INT(x),
COGL_FIXED_FROM_INT(y),
COGL_FIXED_FROM_INT(z)) );
}
void
cogl_rotatex (ClutterFixed angle,
ClutterFixed x,
ClutterFixed y,
ClutterFixed z)
cogl_rotatex (CoglFixed angle,
CoglFixed x,
CoglFixed y,
CoglFixed z)
{
GE( cogl_wrap_glRotatex (angle,x,y,z) );
}
@ -147,10 +147,10 @@ cogl_rotatex (ClutterFixed angle,
void
cogl_rotate (gint angle, gint x, gint y, gint z)
{
GE( cogl_wrap_glRotatex (CLUTTER_INT_TO_FIXED(angle),
CLUTTER_INT_TO_FIXED(x),
CLUTTER_INT_TO_FIXED(y),
CLUTTER_INT_TO_FIXED(z)) );
GE( cogl_wrap_glRotatex (COGL_FIXED_FROM_INT(angle),
COGL_FIXED_FROM_INT(x),
COGL_FIXED_FROM_INT(y),
COGL_FIXED_FROM_INT(z)) );
}
static inline gboolean
@ -326,22 +326,22 @@ cogl_color (const ClutterColor *color)
}
static void
apply_matrix (const ClutterFixed *matrix, ClutterFixed *vertex)
apply_matrix (const CoglFixed *matrix, CoglFixed *vertex)
{
int x, y;
ClutterFixed vertex_out[4] = { 0 };
CoglFixed vertex_out[4] = { 0 };
for (y = 0; y < 4; y++)
for (x = 0; x < 4; x++)
vertex_out[y] += CFX_QMUL (vertex[x], matrix[y + x * 4]);
vertex_out[y] += cogl_fixed_mul (vertex[x], matrix[y + x * 4]);
memcpy (vertex, vertex_out, sizeof (vertex_out));
}
static void
project_vertex (ClutterFixed *modelview,
ClutterFixed *project,
ClutterFixed *vertex)
project_vertex (CoglFixed *modelview,
CoglFixed *project,
CoglFixed *vertex)
{
int i;
@ -351,13 +351,13 @@ project_vertex (ClutterFixed *modelview,
apply_matrix (project, vertex);
/* Convert from homogenized coordinates */
for (i = 0; i < 4; i++)
vertex[i] = CFX_QDIV (vertex[i], vertex[3]);
vertex[i] = cogl_fixed_div (vertex[i], vertex[3]);
}
static void
set_clip_plane (GLint plane_num,
const ClutterFixed *vertex_a,
const ClutterFixed *vertex_b)
const CoglFixed *vertex_a,
const CoglFixed *vertex_b)
{
GLfixed plane[4];
GLfixed angle;
@ -365,9 +365,9 @@ set_clip_plane (GLint plane_num,
/* Calculate the angle between the axes and the line crossing the
two points */
angle = CFX_QMUL (clutter_atan2i (vertex_b[1] - vertex_a[1],
angle = cogl_fixed_mul (cogl_fixed_atan2 (vertex_b[1] - vertex_a[1],
vertex_b[0] - vertex_a[0]),
CFX_RADIANS_TO_DEGREES);
COGL_RADIANS_TO_DEGREES);
GE( cogl_wrap_glPushMatrix () );
/* Load the identity matrix and multiply by the reverse of the
@ -383,7 +383,7 @@ set_clip_plane (GLint plane_num,
GE( cogl_wrap_glTranslatex (-vertex_a[0], -vertex_a[1], -vertex_a[2]) );
plane[0] = 0;
plane[1] = -CFX_ONE;
plane[1] = -COGL_FIXED_1;
plane[2] = 0;
plane[3] = vertex_a[1];
GE( cogl_wrap_glClipPlanex (plane_num, plane) );
@ -394,18 +394,18 @@ set_clip_plane (GLint plane_num,
}
void
_cogl_set_clip_planes (ClutterFixed x_offset,
ClutterFixed y_offset,
ClutterFixed width,
ClutterFixed height)
_cogl_set_clip_planes (CoglFixed x_offset,
CoglFixed y_offset,
CoglFixed width,
CoglFixed height)
{
GLfixed modelview[16], projection[16];
ClutterFixed vertex_tl[4] = { x_offset, y_offset, 0, CFX_ONE };
ClutterFixed vertex_tr[4] = { x_offset + width, y_offset, 0, CFX_ONE };
ClutterFixed vertex_bl[4] = { x_offset, y_offset + height, 0, CFX_ONE };
ClutterFixed vertex_br[4] = { x_offset + width, y_offset + height,
0, CFX_ONE };
CoglFixed vertex_tl[4] = { x_offset, y_offset, 0, COGL_FIXED_1 };
CoglFixed vertex_tr[4] = { x_offset + width, y_offset, 0, COGL_FIXED_1 };
CoglFixed vertex_bl[4] = { x_offset, y_offset + height, 0, COGL_FIXED_1 };
CoglFixed vertex_br[4] = { x_offset + width, y_offset + height,
0, COGL_FIXED_1 };
GE( cogl_wrap_glGetFixedv (GL_MODELVIEW_MATRIX, modelview) );
GE( cogl_wrap_glGetFixedv (GL_PROJECTION_MATRIX, projection) );
@ -423,7 +423,7 @@ _cogl_set_clip_planes (ClutterFixed x_offset,
if ((vertex_tl[0] < vertex_tr[0] ? 1 : 0)
!= (vertex_bl[1] < vertex_tl[1] ? 1 : 0))
{
ClutterFixed temp[4];
CoglFixed temp[4];
memcpy (temp, vertex_tl, sizeof (temp));
memcpy (vertex_tl, vertex_tr, sizeof (temp));
memcpy (vertex_tr, temp, sizeof (temp));
@ -448,10 +448,10 @@ compare_y_coordinate (const void *a, const void *b)
}
void
_cogl_add_stencil_clip (ClutterFixed x_offset,
ClutterFixed y_offset,
ClutterFixed width,
ClutterFixed height,
_cogl_add_stencil_clip (CoglFixed x_offset,
CoglFixed y_offset,
CoglFixed width,
CoglFixed height,
gboolean first)
{
gboolean has_clip_planes
@ -498,9 +498,9 @@ _cogl_add_stencil_clip (ClutterFixed x_offset,
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () );
cogl_rectanglex (-CFX_ONE, -CFX_ONE,
CLUTTER_INT_TO_FIXED (2),
CLUTTER_INT_TO_FIXED (2));
cogl_rectanglex (-COGL_FIXED_1, -COGL_FIXED_1,
COGL_FIXED_FROM_INT (2),
COGL_FIXED_FROM_INT (2));
GE( cogl_wrap_glPopMatrix () );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPopMatrix () );
@ -517,10 +517,10 @@ _cogl_add_stencil_clip (ClutterFixed x_offset,
int i;
GLfixed points[16] =
{
x_offset, y_offset, 0, CFX_ONE,
x_offset + width, y_offset, 0, CFX_ONE,
x_offset, y_offset + height, 0, CFX_ONE,
x_offset + width, y_offset + height, 0, CFX_ONE
x_offset, y_offset, 0, COGL_FIXED_1,
x_offset + width, y_offset, 0, COGL_FIXED_1,
x_offset, y_offset + height, 0, COGL_FIXED_1,
x_offset + width, y_offset + height, 0, COGL_FIXED_1
};
GLfixed draw_points[12];
@ -551,10 +551,10 @@ _cogl_add_stencil_clip (ClutterFixed x_offset,
/* If the clip rect goes outside of the screen then use the
extents of the rect instead */
left_edge = MIN (-CFX_ONE, MIN (points[0], points[8]));
right_edge = MAX ( CFX_ONE, MAX (points[4], points[12]));
bottom_edge = MIN (-CFX_ONE, MIN (points[1], points[5]));
top_edge = MAX ( CFX_ONE, MAX (points[9], points[13]));
left_edge = MIN (-COGL_FIXED_1, MIN (points[0], points[8]));
right_edge = MAX ( COGL_FIXED_1, MAX (points[4], points[12]));
bottom_edge = MIN (-COGL_FIXED_1, MIN (points[1], points[5]));
top_edge = MAX ( COGL_FIXED_1, MAX (points[9], points[13]));
/* Using the identity matrix for the projection and
modelview matrix, draw the triangles around the inner
@ -626,7 +626,7 @@ _cogl_add_stencil_clip (ClutterFixed x_offset,
}
void
_cogl_set_matrix (const ClutterFixed *matrix)
_cogl_set_matrix (const CoglFixed *matrix)
{
GE( cogl_wrap_glLoadIdentity () );
GE( cogl_wrap_glMultMatrixx (matrix) );
@ -649,23 +649,23 @@ _cogl_disable_clip_planes (void)
void
cogl_alpha_func (COGLenum func,
ClutterFixed ref)
CoglFixed ref)
{
GE( cogl_wrap_glAlphaFunc (func, CLUTTER_FIXED_TO_FLOAT(ref)) );
GE( cogl_wrap_glAlphaFunc (func, COGL_FIXED_TO_FLOAT(ref)) );
}
/*
* Fixed point implementation of the perspective function
*/
void
cogl_perspective (ClutterFixed fovy,
ClutterFixed aspect,
ClutterFixed zNear,
ClutterFixed zFar)
cogl_perspective (CoglFixed fovy,
CoglFixed aspect,
CoglFixed zNear,
CoglFixed zFar)
{
ClutterFixed xmax, ymax;
ClutterFixed x, y, c, d;
ClutterFixed fovy_rad_half = CFX_MUL (fovy, CFX_PI) / 360;
CoglFixed xmax, ymax;
CoglFixed x, y, c, d;
CoglFixed fovy_rad_half = cogl_fixed_mul (fovy, COGL_FIXED_PI) / 360;
GLfixed m[16];
@ -683,51 +683,52 @@ cogl_perspective (ClutterFixed fovy,
* same true for y, hence: a == 0 && b == 0;
*
* 2) When working with small numbers, we can are loosing significant
* precision, hence we use clutter_qmulx() here, not the fast macro.
* precision
*/
ymax = clutter_qmulx (zNear, CFX_DIV (clutter_sinx (fovy_rad_half),
clutter_cosx (fovy_rad_half)));
xmax = clutter_qmulx (ymax, aspect);
ymax = cogl_fixed_mul (zNear,
cogl_fixed_div (cogl_fixed_sin (fovy_rad_half),
cogl_fixed_cos (fovy_rad_half)));
xmax = cogl_fixed_mul (ymax, aspect);
x = CFX_DIV (zNear, xmax);
y = CFX_DIV (zNear, ymax);
c = CFX_DIV (-(zFar + zNear), ( zFar - zNear));
d = CFX_DIV (-(clutter_qmulx (2*zFar, zNear)), (zFar - zNear));
x = cogl_fixed_div (zNear, xmax);
y = cogl_fixed_div (zNear, ymax);
c = cogl_fixed_div (-(zFar + zNear), ( zFar - zNear));
d = cogl_fixed_div (-(cogl_fixed_mul (2 * zFar, zNear)), (zFar - zNear));
#define M(row,col) m[col*4+row]
M(0,0) = x;
M(1,1) = y;
M(2,2) = c;
M(2,3) = d;
M(3,2) = 1 + ~CFX_ONE;
M(3,2) = 1 + ~COGL_FIXED_1;
GE( cogl_wrap_glMultMatrixx (m) );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
/* Calculate and store the inverse of the matrix */
memset (ctx->inverse_projection, 0, sizeof (ClutterFixed) * 16);
memset (ctx->inverse_projection, 0, sizeof (CoglFixed) * 16);
#define m ctx->inverse_projection
M(0, 0) = CFX_QDIV (CFX_ONE, x);
M(1, 1) = CFX_QDIV (CFX_ONE, y);
M(2, 3) = -CFX_ONE;
M(3, 2) = CFX_QDIV (CFX_ONE, d);
M(3, 3) = CFX_QDIV (c, d);
M(0, 0) = cogl_fixed_div (COGL_FIXED_1, x);
M(1, 1) = cogl_fixed_div (COGL_FIXED_1, y);
M(2, 3) = -COGL_FIXED_1;
M(3, 2) = cogl_fixed_div (COGL_FIXED_1, d);
M(3, 3) = cogl_fixed_div (c, d);
#undef m
#undef M
}
void
cogl_frustum (ClutterFixed left,
ClutterFixed right,
ClutterFixed bottom,
ClutterFixed top,
ClutterFixed z_near,
ClutterFixed z_far)
cogl_frustum (CoglFixed left,
CoglFixed right,
CoglFixed bottom,
CoglFixed top,
CoglFixed z_near,
CoglFixed z_far)
{
ClutterFixed c, d;
CoglFixed c, d;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -741,19 +742,19 @@ cogl_frustum (ClutterFixed left,
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
/* Calculate and store the inverse of the matrix */
memset (ctx->inverse_projection, 0, sizeof (ClutterFixed) * 16);
memset (ctx->inverse_projection, 0, sizeof (CoglFixed) * 16);
c = -CFX_QDIV (z_far + z_near, z_far - z_near);
d = -CFX_QDIV (2 * CFX_QMUL (z_far, z_near), z_far - z_near);
c = -cogl_fixed_div (z_far + z_near, z_far - z_near);
d = -cogl_fixed_div (2 * cogl_fixed_mul (z_far, z_near), z_far - z_near);
#define M(row,col) ctx->inverse_projection[col*4+row]
M(0,0) = CFX_QDIV (right - left, 2 * z_near);
M(0,3) = CFX_QDIV (right + left, 2 * z_near);
M(1,1) = CFX_QDIV (top - bottom, 2 * z_near);
M(1,3) = CFX_QDIV (top + bottom, 2 * z_near);
M(2,3) = -CFX_ONE;
M(3,2) = CFX_QDIV (CFX_ONE, d);
M(3,3) = CFX_QDIV (c, d);
M(0,0) = cogl_fixed_div (right - left, 2 * z_near);
M(0,3) = cogl_fixed_div (right + left, 2 * z_near);
M(1,1) = cogl_fixed_div (top - bottom, 2 * z_near);
M(1,3) = cogl_fixed_div (top + bottom, 2 * z_near);
M(2,3) = -COGL_FIXED_1;
M(3,2) = cogl_fixed_div (COGL_FIXED_1, d);
M(3,3) = cogl_fixed_div (c, d);
#undef M
}
@ -767,14 +768,14 @@ cogl_viewport (guint width,
void
cogl_setup_viewport (guint w,
guint h,
ClutterFixed fovy,
ClutterFixed aspect,
ClutterFixed z_near,
ClutterFixed z_far)
CoglFixed fovy,
CoglFixed aspect,
CoglFixed z_near,
CoglFixed z_far)
{
gint width = (gint) w;
gint height = (gint) h;
ClutterFixed z_camera;
CoglFixed z_camera;
GE( glViewport (0, 0, width, height) );
@ -792,24 +793,24 @@ cogl_setup_viewport (guint w,
* See comments in ../gl/cogl.c
*/
#define DEFAULT_Z_CAMERA 0.869f
z_camera = CLUTTER_FLOAT_TO_FIXED (DEFAULT_Z_CAMERA);
z_camera = COGL_FIXED_FROM_FLOAT (DEFAULT_Z_CAMERA);
if (fovy != CFX_60)
if (fovy != COGL_FIXED_60)
{
ClutterFixed fovy_rad = CFX_MUL (fovy, CFX_PI) / 180;
CoglFixed fovy_rad = cogl_fixed_mul (fovy, COGL_FIXED_PI) / 180;
z_camera = CFX_DIV (clutter_sinx (fovy_rad),
clutter_cosx (fovy_rad)) >> 1;
z_camera = cogl_fixed_div (cogl_fixed_sin (fovy_rad),
cogl_fixed_cos (fovy_rad)) >> 1;
}
GE( cogl_wrap_glTranslatex (-1 << 15, -1 << 15, -z_camera));
GE( cogl_wrap_glTranslatex (-1 << 15, -1 << 15, -z_camera) );
GE( cogl_wrap_glScalex ( CFX_ONE / width,
-CFX_ONE / height,
CFX_ONE / width));
GE( cogl_wrap_glScalex ( COGL_FIXED_1 / width,
-COGL_FIXED_1 / height,
COGL_FIXED_1 / width) );
GE( cogl_wrap_glTranslatex (0, -CFX_ONE * height, 0) );
GE( cogl_wrap_glTranslatex (0, -COGL_FIXED_1 * height, 0) );
}
static void
@ -860,19 +861,19 @@ cogl_features_available (CoglFeatureFlags features)
}
void
cogl_get_modelview_matrix (ClutterFixed m[16])
cogl_get_modelview_matrix (CoglFixed m[16])
{
cogl_wrap_glGetFixedv(GL_MODELVIEW_MATRIX, &m[0]);
}
void
cogl_get_projection_matrix (ClutterFixed m[16])
cogl_get_projection_matrix (CoglFixed m[16])
{
cogl_wrap_glGetFixedv(GL_PROJECTION_MATRIX, &m[0]);
}
void
cogl_get_viewport (ClutterFixed v[4])
cogl_get_viewport (CoglFixed v[4])
{
GLint viewport[4];
int i;
@ -880,7 +881,7 @@ cogl_get_viewport (ClutterFixed v[4])
cogl_wrap_glGetIntegerv (GL_VIEWPORT, viewport);
for (i = 0; i < 4; i++)
v[i] = CLUTTER_INT_TO_FIXED (viewport[i]);
v[i] = COGL_FIXED_FROM_INT (viewport[i]);
}
void
@ -898,9 +899,9 @@ cogl_get_bitmasks (gint *red, gint *green, gint *blue, gint *alpha)
void
cogl_fog_set (const ClutterColor *fog_color,
ClutterFixed density,
ClutterFixed z_near,
ClutterFixed z_far)
CoglFixed density,
CoglFixed z_near,
CoglFixed z_far)
{
GLfixed fogColor[4];