brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'cogl-float'

Browse Source 
Okey; to summarise the changes...

We have converted Clutter and Cogl over to using floating point internally
instead of 16.16 fixed, but we have maintained the cogl-fixed API as a
utility to applications in case they want to implement their own optimizations.

The Clutter API has not changed (though ClutterFixed and ClutterUnit are now
internally floats) but all Cogl entry points have been changed to accept floats
now instead of CoglFixed.

To summarise the rationale...

There have been a number of issues with using fixed point though out Clutter
and Cogl including: lack of precision, lack of range, excessive format
conversion (GPUs tend to work nativly with IEEE floats) and maintainability.
One of the main arguments for fixed point - performance - hasn't shown
itself to be serious in practice so far since we seem to be more limited
by GPU performance and making improvements regarding how we submit data to
OpenGL[ES]/the GPU has had a more significant impact.

Ref: The recent multiple rectangle queuing changes + the
cogl-texture-agressive-batching branch which show significant performance
gains, and that recent tests on the ipodtouch (ARM + MBX) also showed no
loss of performance running with floats.

So finally; please forgive the inevitable fallout, this is a far reaching
change. There are still a few known issues with the fixed to float
conversion but enough works for all our conformance tests to pass, and the
remaining issues hopefully wont be too tricky to solve. For reference two
tags will be available either side of this change: "cogl-fixed-end" and
"cogl-float-start"
This commit is contained in:
Robert Bragg 2009-01-20 17:22:21 +00:00
commit 3014d4ff8a
75 changed files with 4441 additions and 1893 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

217
clutter/clutter-actor.c
View File

@ -774,12 +774,12 @@ clutter_actor_real_allocate (ClutterActor *self,
g_object_thaw_notify (G_OBJECT (self)); g_object_thaw_notify (G_OBJECT (self));
} }
/* like ClutterVertex, but using CoglFixed and with a w component */ /* like ClutterVertex, but using float and with a w component */
typedef struct { typedef struct {
CoglFixed x; float x;
CoglFixed y; float y;
CoglFixed z; float z;
CoglFixed w; float w;
} fixed_vertex_t; } fixed_vertex_t;
/* copies a fixed vertex into a ClutterVertex */ /* copies a fixed vertex into a ClutterVertex */
@ -806,7 +806,7 @@ static inline void
mtx_transform (const ClutterFixed m[], mtx_transform (const ClutterFixed m[],
fixed_vertex_t *vertex) fixed_vertex_t *vertex)
{ {
ClutterFixed _x, _y, _z, _w; float _x, _y, _z, _w;
_x = vertex->x; _x = vertex->x;
_y = vertex->y; _y = vertex->y;
@ -816,25 +816,25 @@ mtx_transform (const ClutterFixed m[],
/* We care lot about precision here, so have to use MUL instead /* We care lot about precision here, so have to use MUL instead
* of FAST_MUL * of FAST_MUL
*/ */
vertex->x = COGL_FIXED_MUL (M (m, 0, 0), _x) vertex->x = CLUTTER_FIXED_MUL (M (m, 0, 0), _x)
+ COGL_FIXED_MUL (M (m, 0, 1), _y) + CLUTTER_FIXED_MUL (M (m, 0, 1), _y)
+ COGL_FIXED_MUL (M (m, 0, 2), _z) + CLUTTER_FIXED_MUL (M (m, 0, 2), _z)
+ COGL_FIXED_MUL (M (m, 0, 3), _w); + CLUTTER_FIXED_MUL (M (m, 0, 3), _w);
vertex->y = COGL_FIXED_MUL (M (m, 1, 0), _x) vertex->y = CLUTTER_FIXED_MUL (M (m, 1, 0), _x)
+ COGL_FIXED_MUL (M (m, 1, 1), _y) + CLUTTER_FIXED_MUL (M (m, 1, 1), _y)
+ COGL_FIXED_MUL (M (m, 1, 2), _z) + CLUTTER_FIXED_MUL (M (m, 1, 2), _z)
+ COGL_FIXED_MUL (M (m, 1, 3), _w); + CLUTTER_FIXED_MUL (M (m, 1, 3), _w);
vertex->z = COGL_FIXED_MUL (M (m, 2, 0), _x) vertex->z = CLUTTER_FIXED_MUL (M (m, 2, 0), _x)
+ COGL_FIXED_MUL (M (m, 2, 1), _y) + CLUTTER_FIXED_MUL (M (m, 2, 1), _y)
+ COGL_FIXED_MUL (M (m, 2, 2), _z) + CLUTTER_FIXED_MUL (M (m, 2, 2), _z)
+ COGL_FIXED_MUL (M (m, 2, 3), _w); + CLUTTER_FIXED_MUL (M (m, 2, 3), _w);
vertex->w = COGL_FIXED_MUL (M (m, 3, 0), _x) vertex->w = CLUTTER_FIXED_MUL (M (m, 3, 0), _x)
+ COGL_FIXED_MUL (M (m, 3, 1), _y) + CLUTTER_FIXED_MUL (M (m, 3, 1), _y)
+ COGL_FIXED_MUL (M (m, 3, 2), _z) + CLUTTER_FIXED_MUL (M (m, 3, 2), _z)
+ COGL_FIXED_MUL (M (m, 3, 3), _w); + CLUTTER_FIXED_MUL (M (m, 3, 3), _w);
/* Specially for Matthew: was going to put a comment here, but could not /* Specially for Matthew: was going to put a comment here, but could not
* think of anything at all to say ;) * think of anything at all to say ;)
@ -846,8 +846,11 @@ mtx_transform (const ClutterFixed m[],
/* Help macros to scale from OpenGL <-1,1> coordinates system to our /* Help macros to scale from OpenGL <-1,1> coordinates system to our
* X-window based <0,window-size> coordinates * X-window based <0,window-size> coordinates
*/ */
#define MTX_GL_SCALE_X(x,w,v1,v2) (COGL_FIXED_MUL (((COGL_FIXED_DIV ((x), (w)) + COGL_FIXED_1) >> 1), (v1)) + (v2)) #define MTX_GL_SCALE_X(x,w,v1,v2) \
#define MTX_GL_SCALE_Y(y,w,v1,v2) ((v1) - COGL_FIXED_MUL (((COGL_FIXED_DIV ((y), (w)) + COGL_FIXED_1) >> 1), (v1)) + (v2)) (CLUTTER_FIXED_MUL (((CLUTTER_FIXED_DIV ((x), (w)) + 1.0) / 2), (v1)) + (v2))
#define MTX_GL_SCALE_Y(y,w,v1,v2) \
((v1) - CLUTTER_FIXED_MUL (((CLUTTER_FIXED_DIV ((y), (w)) + 1.0) / 2), \
(v1)) + (v2))
#define MTX_GL_SCALE_Z(z,w,v1,v2) (MTX_GL_SCALE_X ((z), (w), (v1), (v2))) #define MTX_GL_SCALE_Z(z,w,v1,v2) (MTX_GL_SCALE_X ((z), (w), (v1), (v2)))
/* transforms a 4-tuple of coordinates using @matrix and /* transforms a 4-tuple of coordinates using @matrix and
@ -1024,7 +1027,7 @@ clutter_actor_apply_relative_transform_to_point (ClutterActor *self,
x = CLUTTER_UNITS_TO_FIXED (vertex->x); x = CLUTTER_UNITS_TO_FIXED (vertex->x);
y = CLUTTER_UNITS_TO_FIXED (vertex->y); y = CLUTTER_UNITS_TO_FIXED (vertex->y);
z = CLUTTER_UNITS_TO_FIXED (vertex->z); z = CLUTTER_UNITS_TO_FIXED (vertex->z);
w = COGL_FIXED_1; w = 1.0;
/* First we tranform the point using the OpenGL modelview matrix */ /* First we tranform the point using the OpenGL modelview matrix */
clutter_actor_transform_point_relative (self, ancestor, &x, &y, &z, &w); clutter_actor_transform_point_relative (self, ancestor, &x, &y, &z, &w);
@ -1035,9 +1038,9 @@ clutter_actor_apply_relative_transform_to_point (ClutterActor *self,
* The w[3] parameter should always be 1.0 here, so we ignore it; otherwise * The w[3] parameter should always be 1.0 here, so we ignore it; otherwise
* we would have to divide the original verts with it. * we would have to divide the original verts with it.
*/ */
tmp.x = COGL_FIXED_MUL (CLUTTER_UNITS_TO_FIXED (x) + COGL_FIXED_0_5, v[2]); tmp.x = CLUTTER_FIXED_MUL (CLUTTER_UNITS_TO_FIXED (x) + 0.5, v[2]);
tmp.y = COGL_FIXED_MUL (COGL_FIXED_0_5 - CLUTTER_UNITS_TO_FIXED (y), v[3]); tmp.y = CLUTTER_FIXED_MUL (0.5 - CLUTTER_UNITS_TO_FIXED (y), v[3]);
tmp.z = COGL_FIXED_MUL (CLUTTER_UNITS_TO_FIXED (z) + COGL_FIXED_0_5, v[2]); tmp.z = CLUTTER_FIXED_MUL (CLUTTER_UNITS_TO_FIXED (z) + 0.5, v[2]);
tmp.w = 0; tmp.w = 0;
fixed_vertex_to_units (&tmp, vertex); fixed_vertex_to_units (&tmp, vertex);
@ -1119,10 +1122,10 @@ clutter_actor_transform_vertices_relative (ClutterActor *self,
cogl_get_modelview_matrix (mtx); cogl_get_modelview_matrix (mtx);
fixed_vertex_transform (mtx, 0, 0, 0, COGL_FIXED_1, &vertices[0]); fixed_vertex_transform (mtx, 0, 0, 0, 1.0, &vertices[0]);
fixed_vertex_transform (mtx, width, 0, 0, COGL_FIXED_1, &vertices[1]); fixed_vertex_transform (mtx, width, 0, 0, 1.0, &vertices[1]);
fixed_vertex_transform (mtx, 0, height, 0, COGL_FIXED_1, &vertices[2]); fixed_vertex_transform (mtx, 0, height, 0, 1.0, &vertices[2]);
fixed_vertex_transform (mtx, width, height, 0, COGL_FIXED_1, &vertices[3]); fixed_vertex_transform (mtx, width, height, 0, 1.0, &vertices[3]);
cogl_pop_matrix(); cogl_pop_matrix();
} }
@ -1171,10 +1174,10 @@ clutter_actor_transform_and_project_box (ClutterActor *self,
cogl_get_modelview_matrix (mtx); cogl_get_modelview_matrix (mtx);
fixed_vertex_transform (mtx, 0, 0, 0, COGL_FIXED_1, &vertices[0]); fixed_vertex_transform (mtx, 0, 0, 0, 1.0, &vertices[0]);
fixed_vertex_transform (mtx, width, 0, 0, COGL_FIXED_1, &vertices[1]); fixed_vertex_transform (mtx, width, 0, 0, 1.0, &vertices[1]);
fixed_vertex_transform (mtx, 0, height, 0, COGL_FIXED_1, &vertices[2]); fixed_vertex_transform (mtx, 0, height, 0, 1.0, &vertices[2]);
fixed_vertex_transform (mtx, width, height, 0, COGL_FIXED_1, &vertices[3]); fixed_vertex_transform (mtx, width, height, 0, 1.0, &vertices[3]);
cogl_pop_matrix(); cogl_pop_matrix();
@ -1261,24 +1264,24 @@ clutter_actor_get_allocation_vertices (ClutterActor *self,
* The w[3] parameter should always be 1.0 here, so we ignore it; * The w[3] parameter should always be 1.0 here, so we ignore it;
* otherwise we would have to divide the original verts with it. * otherwise we would have to divide the original verts with it.
*/ */
tmp.x = COGL_FIXED_MUL ((vertices[0].x + COGL_FIXED_0_5), v[2]); tmp.x = CLUTTER_FIXED_MUL ((vertices[0].x + 0.5), v[2]);
tmp.y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - vertices[0].y), v[3]); tmp.y = CLUTTER_FIXED_MUL ((0.5 - vertices[0].y), v[3]);
tmp.z = COGL_FIXED_MUL ((vertices[0].z + COGL_FIXED_0_5), v[2]); tmp.z = CLUTTER_FIXED_MUL ((vertices[0].z + 0.5), v[2]);
fixed_vertex_to_units (&tmp, &verts[0]); fixed_vertex_to_units (&tmp, &verts[0]);
tmp.x = COGL_FIXED_MUL ((vertices[1].x + COGL_FIXED_0_5), v[2]); tmp.x = CLUTTER_FIXED_MUL ((vertices[1].x + 0.5), v[2]);
tmp.y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - vertices[1].y), v[3]); tmp.y = CLUTTER_FIXED_MUL ((0.5 - vertices[1].y), v[3]);
tmp.z = COGL_FIXED_MUL ((vertices[1].z + COGL_FIXED_0_5), v[2]); tmp.z = CLUTTER_FIXED_MUL ((vertices[1].z + 0.5), v[2]);
fixed_vertex_to_units (&tmp, &verts[1]); fixed_vertex_to_units (&tmp, &verts[1]);
tmp.x = COGL_FIXED_MUL ((vertices[2].x + COGL_FIXED_0_5), v[2]); tmp.x = CLUTTER_FIXED_MUL ((vertices[2].x + 0.5), v[2]);
tmp.y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - vertices[2].y), v[3]); tmp.y = CLUTTER_FIXED_MUL ((0.5 - vertices[2].y), v[3]);
tmp.z = COGL_FIXED_MUL ((vertices[2].z + COGL_FIXED_0_5), v[2]); tmp.z = CLUTTER_FIXED_MUL ((vertices[2].z + 0.5), v[2]);
fixed_vertex_to_units (&tmp, &verts[2]); fixed_vertex_to_units (&tmp, &verts[2]);
tmp.x = COGL_FIXED_MUL ((vertices[3].x + COGL_FIXED_0_5), v[2]); tmp.x = CLUTTER_FIXED_MUL ((vertices[3].x + 0.5), v[2]);
tmp.y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - vertices[3].y), v[3]); tmp.y = CLUTTER_FIXED_MUL ((0.5 - vertices[3].y), v[3]);
tmp.z = COGL_FIXED_MUL ((vertices[3].z + COGL_FIXED_0_5), v[2]); tmp.z = CLUTTER_FIXED_MUL ((vertices[3].z + 0.5), v[2]);
fixed_vertex_to_units (&tmp, &verts[3]); fixed_vertex_to_units (&tmp, &verts[3]);
} }
@ -1345,8 +1348,8 @@ _clutter_actor_apply_modelview_transform (ClutterActor *self)
gboolean is_stage = CLUTTER_IS_STAGE (self); gboolean is_stage = CLUTTER_IS_STAGE (self);
if (!is_stage) if (!is_stage)
cogl_translatex (CLUTTER_UNITS_TO_FIXED (priv->allocation.x1), cogl_translate (CLUTTER_UNITS_TO_FLOAT (priv->allocation.x1),
CLUTTER_UNITS_TO_FIXED (priv->allocation.y1), CLUTTER_UNITS_TO_FLOAT (priv->allocation.y1),
0); 0);
/* /*
@ -1355,55 +1358,55 @@ _clutter_actor_apply_modelview_transform (ClutterActor *self)
* the translations included in the rotation are not scaled and so the * the translations included in the rotation are not scaled and so the
* entire object will move on the screen as a result of rotating it). * entire object will move on the screen as a result of rotating it).
*/ */
if (priv->scale_x != COGL_FIXED_1 || priv->scale_y != COGL_FIXED_1) if (priv->scale_x != 1.0 || priv->scale_y != 1.0)
cogl_scale (priv->scale_x, priv->scale_y); cogl_scale (priv->scale_x, priv->scale_y);
if (priv->rzang) if (priv->rzang)
{ {
cogl_translatex (CLUTTER_UNITS_TO_FIXED (priv->rzx), cogl_translate (CLUTTER_UNITS_TO_FLOAT (priv->rzx),
CLUTTER_UNITS_TO_FIXED (priv->rzy), CLUTTER_UNITS_TO_FLOAT (priv->rzy),
0); 0);
cogl_rotatex (priv->rzang, 0, 0, COGL_FIXED_1); cogl_rotate (priv->rzang, 0, 0, 1.0);
cogl_translatex (CLUTTER_UNITS_TO_FIXED (-priv->rzx), cogl_translate (CLUTTER_UNITS_TO_FLOAT (-priv->rzx),
CLUTTER_UNITS_TO_FIXED (-priv->rzy), CLUTTER_UNITS_TO_FLOAT (-priv->rzy),
0); 0);
} }
if (priv->ryang) if (priv->ryang)
{ {
cogl_translatex (CLUTTER_UNITS_TO_FIXED (priv->ryx), cogl_translate (CLUTTER_UNITS_TO_FLOAT (priv->ryx),
0, 0,
CLUTTER_UNITS_TO_FIXED (priv->z + priv->ryz)); CLUTTER_UNITS_TO_FLOAT (priv->z + priv->ryz));
cogl_rotatex (priv->ryang, 0, COGL_FIXED_1, 0); cogl_rotate (priv->ryang, 0, 1.0, 0);
cogl_translatex (CLUTTER_UNITS_TO_FIXED (-priv->ryx), cogl_translate (CLUTTER_UNITS_TO_FLOAT (-priv->ryx),
0, 0,
CLUTTER_UNITS_TO_FIXED (-(priv->z + priv->ryz))); CLUTTER_UNITS_TO_FLOAT (-(priv->z + priv->ryz)));
} }
if (priv->rxang) if (priv->rxang)
{ {
cogl_translatex (0, cogl_translate (0,
CLUTTER_UNITS_TO_FIXED (priv->rxy), CLUTTER_UNITS_TO_FLOAT (priv->rxy),
CLUTTER_UNITS_TO_FIXED (priv->z + priv->rxz)); CLUTTER_UNITS_TO_FLOAT (priv->z + priv->rxz));
cogl_rotatex (priv->rxang, COGL_FIXED_1, 0, 0); cogl_rotate (priv->rxang, 1.0, 0, 0);
cogl_translatex (0, cogl_translate (0,
CLUTTER_UNITS_TO_FIXED (-priv->rxy), CLUTTER_UNITS_TO_FLOAT (-priv->rxy),
CLUTTER_UNITS_TO_FIXED (-(priv->z + priv->rxz))); CLUTTER_UNITS_TO_FLOAT (-(priv->z + priv->rxz)));
} }
if (!is_stage && (priv->anchor_x || priv->anchor_y)) if (!is_stage && (priv->anchor_x || priv->anchor_y))
cogl_translatex (CLUTTER_UNITS_TO_FIXED (-priv->anchor_x), cogl_translate (CLUTTER_UNITS_TO_FLOAT (-priv->anchor_x),
CLUTTER_UNITS_TO_FIXED (-priv->anchor_y), CLUTTER_UNITS_TO_FLOAT (-priv->anchor_y),
0); 0);
if (priv->z) if (priv->z)
cogl_translatex (0, 0, priv->z); cogl_translate (0, 0, priv->z);
} }
/* Recursively applies the transforms associated with this actor and /* Recursively applies the transforms associated with this actor and
@ -1656,14 +1659,14 @@ clutter_actor_set_property (GObject *object,
case PROP_SCALE_X: case PROP_SCALE_X:
clutter_actor_set_scalex clutter_actor_set_scalex
(actor, (actor,
COGL_FIXED_FROM_FLOAT (g_value_get_double (value)), CLUTTER_FLOAT_TO_FIXED (g_value_get_double (value)),
priv->scale_y); priv->scale_y);
break; break;
case PROP_SCALE_Y: case PROP_SCALE_Y:
clutter_actor_set_scalex clutter_actor_set_scalex
(actor, (actor,
priv->scale_x, priv->scale_x,
COGL_FIXED_FROM_FLOAT (g_value_get_double (value))); CLUTTER_FLOAT_TO_FIXED (g_value_get_double (value)));
break; break;
case PROP_CLIP: case PROP_CLIP:
{ {
@ -1681,7 +1684,7 @@ clutter_actor_set_property (GObject *object,
{ {
ClutterFixed angle; ClutterFixed angle;
angle = COGL_FIXED_FROM_FLOAT (g_value_get_double (value)); angle = CLUTTER_FLOAT_TO_FIXED (g_value_get_double (value));
clutter_actor_set_rotation_internal (actor, clutter_actor_set_rotation_internal (actor,
CLUTTER_X_AXIS, CLUTTER_X_AXIS,
angle, angle,
@ -1694,7 +1697,7 @@ clutter_actor_set_property (GObject *object,
{ {
ClutterFixed angle; ClutterFixed angle;
angle = COGL_FIXED_FROM_FLOAT (g_value_get_double (value)); angle = CLUTTER_FLOAT_TO_FIXED (g_value_get_double (value));
clutter_actor_set_rotation_internal (actor, clutter_actor_set_rotation_internal (actor,
CLUTTER_Y_AXIS, CLUTTER_Y_AXIS,
angle, angle,
@ -1707,7 +1710,7 @@ clutter_actor_set_property (GObject *object,
{ {
ClutterFixed angle; ClutterFixed angle;
angle = COGL_FIXED_FROM_FLOAT (g_value_get_double (value)); angle = CLUTTER_FLOAT_TO_FIXED (g_value_get_double (value));
clutter_actor_set_rotation_internal (actor, clutter_actor_set_rotation_internal (actor,
CLUTTER_Z_AXIS, CLUTTER_Z_AXIS,
angle, angle,
@ -1877,22 +1880,22 @@ clutter_actor_get_property (GObject *object,
} }
break; break;
case PROP_SCALE_X: case PROP_SCALE_X:
g_value_set_double (value, COGL_FIXED_TO_DOUBLE (priv->scale_x)); g_value_set_double (value, CLUTTER_FIXED_TO_DOUBLE (priv->scale_x));
break; break;
case PROP_SCALE_Y: case PROP_SCALE_Y:
g_value_set_double (value, COGL_FIXED_TO_DOUBLE (priv->scale_y)); g_value_set_double (value, CLUTTER_FIXED_TO_DOUBLE (priv->scale_y));
break; break;
case PROP_REACTIVE: case PROP_REACTIVE:
g_value_set_boolean (value, clutter_actor_get_reactive (actor)); g_value_set_boolean (value, clutter_actor_get_reactive (actor));
break; break;
case PROP_ROTATION_ANGLE_X: case PROP_ROTATION_ANGLE_X:
g_value_set_double (value, COGL_FIXED_TO_DOUBLE (priv->rxang)); g_value_set_double (value, CLUTTER_FIXED_TO_DOUBLE (priv->rxang));
break; break;
case PROP_ROTATION_ANGLE_Y: case PROP_ROTATION_ANGLE_Y:
g_value_set_double (value, COGL_FIXED_TO_DOUBLE (priv->ryang)); g_value_set_double (value, CLUTTER_FIXED_TO_DOUBLE (priv->ryang));
break; break;
case PROP_ROTATION_ANGLE_Z: case PROP_ROTATION_ANGLE_Z:
g_value_set_double (value, COGL_FIXED_TO_DOUBLE (priv->rzang)); g_value_set_double (value, CLUTTER_FIXED_TO_DOUBLE (priv->rzang));
break; break;
case PROP_ROTATION_CENTER_X: case PROP_ROTATION_CENTER_X:
{ {
@ -3020,8 +3023,8 @@ clutter_actor_init (ClutterActor *self)
priv->has_clip = FALSE; priv->has_clip = FALSE;
priv->opacity = 0xff; priv->opacity = 0xff;
priv->id = clutter_id_pool_add (CLUTTER_CONTEXT()->id_pool, self); priv->id = clutter_id_pool_add (CLUTTER_CONTEXT()->id_pool, self);
priv->scale_x = COGL_FIXED_1; priv->scale_x = 1.0;
priv->scale_y = COGL_FIXED_1; priv->scale_y = 1.0;
priv->shader_data = NULL; priv->shader_data = NULL;
priv->show_on_set_parent = TRUE; priv->show_on_set_parent = TRUE;
@ -4916,8 +4919,8 @@ clutter_actor_set_scale (ClutterActor *self,
g_return_if_fail (CLUTTER_IS_ACTOR (self)); g_return_if_fail (CLUTTER_IS_ACTOR (self));
clutter_actor_set_scalex (self, clutter_actor_set_scalex (self,
COGL_FIXED_FROM_FLOAT (scale_x), CLUTTER_FLOAT_TO_FIXED (scale_x),
COGL_FIXED_FROM_FLOAT (scale_y)); CLUTTER_FLOAT_TO_FIXED (scale_y));
} }
/** /**
@ -4964,10 +4967,10 @@ clutter_actor_get_scale (ClutterActor *self,
g_return_if_fail (CLUTTER_IS_ACTOR (self)); g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (scale_x) if (scale_x)
*scale_x = COGL_FIXED_TO_FLOAT (self->priv->scale_x); *scale_x = CLUTTER_FIXED_TO_FLOAT (self->priv->scale_x);
if (scale_y) if (scale_y)
*scale_y = COGL_FIXED_TO_FLOAT (self->priv->scale_y); *scale_y = CLUTTER_FIXED_TO_FLOAT (self->priv->scale_y);
} }
/** /**
@ -5224,7 +5227,7 @@ clutter_actor_set_rotationu (ClutterActor *self,
g_return_if_fail (CLUTTER_IS_ACTOR (self)); g_return_if_fail (CLUTTER_IS_ACTOR (self));
clutter_actor_set_rotation_internal (self, axis, clutter_actor_set_rotation_internal (self, axis,
COGL_FIXED_FROM_FLOAT (angle), CLUTTER_FLOAT_TO_FIXED (angle),
x, y, z); x, y, z);
} }
@ -5294,7 +5297,7 @@ clutter_actor_set_rotation (ClutterActor *self,
g_return_if_fail (CLUTTER_IS_ACTOR (self)); g_return_if_fail (CLUTTER_IS_ACTOR (self));
clutter_actor_set_rotationx (self, axis, clutter_actor_set_rotationx (self, axis,
COGL_FIXED_FROM_FLOAT (angle), CLUTTER_FLOAT_TO_FIXED (angle),
x, y, z); x, y, z);
} }
@ -5335,7 +5338,7 @@ clutter_actor_get_rotationu (ClutterActor *self,
switch (axis) switch (axis)
{ {
case CLUTTER_X_AXIS: case CLUTTER_X_AXIS:
retval = COGL_FIXED_TO_DOUBLE (priv->rxang); retval = CLUTTER_FIXED_TO_DOUBLE (priv->rxang);
if (y) if (y)
*y = priv->rxy; *y = priv->rxy;
if (z) if (z)
@ -5343,7 +5346,7 @@ clutter_actor_get_rotationu (ClutterActor *self,
break; break;
case CLUTTER_Y_AXIS: case CLUTTER_Y_AXIS:
retval = COGL_FIXED_TO_DOUBLE (priv->ryang); retval = CLUTTER_FIXED_TO_DOUBLE (priv->ryang);
if (x) if (x)
*x = priv->ryx; *x = priv->ryx;
if (z) if (z)
@ -5351,7 +5354,7 @@ clutter_actor_get_rotationu (ClutterActor *self,
break; break;
case CLUTTER_Z_AXIS: case CLUTTER_Z_AXIS:
retval = COGL_FIXED_TO_DOUBLE (priv->rzang); retval = CLUTTER_FIXED_TO_DOUBLE (priv->rzang);
if (x) if (x)
*x = priv->rzx; *x = priv->rzx;
if (y) if (y)
@ -5450,7 +5453,7 @@ clutter_actor_get_rotation (ClutterActor *self,
{ {
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0.0); g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0.0);
return COGL_FIXED_TO_FLOAT (clutter_actor_get_rotationx (self, return CLUTTER_FIXED_TO_FLOAT (clutter_actor_get_rotationx (self,
axis, axis,
x, y, z)); x, y, z));
} }
@ -6612,7 +6615,7 @@ parse_rotation_array (ClutterActor *actor,
/* angle */ /* angle */
element = json_array_get_element (array, 0); element = json_array_get_element (array, 0);
if (JSON_NODE_TYPE (element) == JSON_NODE_VALUE) if (JSON_NODE_TYPE (element) == JSON_NODE_VALUE)
info->angle = COGL_FIXED_FROM_FLOAT (json_node_get_double (element)); info->angle = CLUTTER_FLOAT_TO_FIXED (json_node_get_double (element));
else else
return FALSE; return FALSE;
@ -6918,12 +6921,12 @@ clutter_actor_transform_stage_point (ClutterActor *self,
if (!du || !dv) if (!du || !dv)
return FALSE; return FALSE;
#define FP2FX COGL_FIXED_FROM_FLOAT #define FP2FX CLUTTER_FLOAT_TO_FIXED
#define FX2FP COGL_FIXED_TO_DOUBLE #define FX2FP CLUTTER_FIXED_TO_DOUBLE
#define UX2FP CLUTTER_UNITS_TO_FLOAT #define UX2FP CLUTTER_UNITS_TO_FLOAT
#define UX2FX CLUTTER_UNITS_TO_FIXED #define UX2FX CLUTTER_UNITS_TO_FIXED
#define FP2INT CLUTTER_FLOAT_TO_INT #define FP2INT CLUTTER_FLOAT_TO_INT
#define DET2X(a,b,c,d) (COGL_FIXED_MUL ((a), (d)) - COGL_FIXED_MUL ((b), (c))) #define DET2X(a,b,c,d) ((a * d) - (b * c))
#define DET2FP(a,b,c,d) ((a) * (d) - (b) * (c)) #define DET2FP(a,b,c,d) ((a) * (d) - (b) * (c))
/* /*
@ -6946,7 +6949,7 @@ clutter_actor_transform_stage_point (ClutterActor *self,
RQ[2][1] = UX2FX (v[0].y); RQ[2][1] = UX2FX (v[0].y);
RQ[0][2] = 0; RQ[0][2] = 0;
RQ[1][2] = 0; RQ[1][2] = 0;
RQ[2][2] = COGL_FIXED_1; RQ[2][2] = 1.0;
} }
else else
{ {
@ -6976,16 +6979,16 @@ clutter_actor_transform_stage_point (ClutterActor *self,
RQ[0][2] = FP2FX (DET2FP (UX2FP (px), dx2, UX2FP (py), dy2) / del); RQ[0][2] = FP2FX (DET2FP (UX2FP (px), dx2, UX2FP (py), dy2) / del);
RQ[1][2] = FP2FX (DET2FP (dx1, UX2FP (px), dy1, UX2FP (py)) / del); RQ[1][2] = FP2FX (DET2FP (dx1, UX2FP (px), dy1, UX2FP (py)) / del);
RQ[1][2] = FP2FX (DET2FP (dx1, UX2FP (px), dy1, UX2FP (py)) / del); RQ[1][2] = FP2FX (DET2FP (dx1, UX2FP (px), dy1, UX2FP (py)) / del);
RQ[2][2] = COGL_FIXED_1; RQ[2][2] = 1.0;
RQ[0][0] = UX2FX (v[1].x - v[0].x) RQ[0][0] = UX2FX (v[1].x - v[0].x)
+ COGL_FIXED_MUL (RQ[0][2], UX2FX (v[1].x)); + CLUTTER_FIXED_MUL (RQ[0][2], UX2FX (v[1].x));
RQ[1][0] = UX2FX (v[2].x - v[0].x) RQ[1][0] = UX2FX (v[2].x - v[0].x)
+ COGL_FIXED_MUL (RQ[1][2], UX2FX (v[2].x)); + CLUTTER_FIXED_MUL (RQ[1][2], UX2FX (v[2].x));
RQ[2][0] = UX2FX (v[0].x); RQ[2][0] = UX2FX (v[0].x);
RQ[0][1] = UX2FX (v[1].y - v[0].y) RQ[0][1] = UX2FX (v[1].y - v[0].y)
+ COGL_FIXED_MUL (RQ[0][2], UX2FX (v[1].y)); + CLUTTER_FIXED_MUL (RQ[0][2], UX2FX (v[1].y));
RQ[1][1] = UX2FX (v[2].y - v[0].y) RQ[1][1] = UX2FX (v[2].y - v[0].y)
+ COGL_FIXED_MUL (RQ[1][2], UX2FX (v[2].y)); + CLUTTER_FIXED_MUL (RQ[1][2], UX2FX (v[2].y));
RQ[2][1] = UX2FX (v[0].y); RQ[2][1] = UX2FX (v[0].y);
} }
@ -7017,9 +7020,9 @@ clutter_actor_transform_stage_point (ClutterActor *self,
/* /*
* Check the resutling martix is OK. * Check the resutling martix is OK.
*/ */
det = COGL_FIXED_MUL (RQ[0][0], ST[0][0]) det = CLUTTER_FIXED_MUL (RQ[0][0], ST[0][0])
+ COGL_FIXED_MUL (RQ[0][1], ST[0][1]) + CLUTTER_FIXED_MUL (RQ[0][1], ST[0][1])
+ COGL_FIXED_MUL (RQ[0][2], ST[0][2]); + CLUTTER_FIXED_MUL (RQ[0][2], ST[0][2]);
if (!det) if (!det)
return FALSE; return FALSE;
@ -7481,7 +7484,7 @@ clutter_actor_is_scaled (ClutterActor *self)
priv = self->priv; priv = self->priv;
if (priv->scale_x != COGL_FIXED_1 || priv->scale_y != COGL_FIXED_1) if (priv->scale_x != 1.0 || priv->scale_y != 1.0)
return TRUE; return TRUE;
return FALSE; return FALSE;

153
clutter/clutter-alpha.c
View File

@ -840,14 +840,19 @@ clutter_ramp_func (ClutterAlpha *alpha,
} }
} }
#if 0
/*
* The following three functions are left in place for reference
* purposes.
*/
static guint32 static guint32
sincx1024_func (ClutterAlpha *alpha, sincx1024_func (ClutterAlpha *alpha,
ClutterAngle angle, float angle,
ClutterFixed offset) ClutterFixed offset)
{ {
ClutterTimeline *timeline; ClutterTimeline *timeline;
gint current_frame_num, n_frames; gint current_frame_num, n_frames;
ClutterAngle x; float x;
ClutterFixed sine; ClutterFixed sine;
timeline = clutter_alpha_get_timeline (alpha); timeline = clutter_alpha_get_timeline (alpha);
@ -867,11 +872,6 @@ sincx1024_func (ClutterAlpha *alpha,
return sine; return sine;
} }
#if 0
/*
* The following two functions are left in place for reference
* purposes.
*/
static guint32 static guint32
sincx_func (ClutterAlpha *alpha, sincx_func (ClutterAlpha *alpha,
ClutterFixed angle, ClutterFixed angle,
@ -887,14 +887,14 @@ sincx_func (ClutterAlpha *alpha,
n_frames = clutter_timeline_get_n_frames (timeline); n_frames = clutter_timeline_get_n_frames (timeline);
x = angle * current_frame_num / n_frames; x = angle * current_frame_num / n_frames;
x = COGL_FIXED_FAST_MUL (x, COGL_FIXED_PI) x = CLUTTER_FIXED_MUL (x, CFX_PI)
- COGL_FIXED_FAST_DIV (COGL_FIXED_PI, angle); - CLUTTER_FIXED_DIV (CFX_PI, angle);
sine = (cogl_fixed_sin (x) + offset) / 2; sine = (cogl_angle_sin (x) + offset) / 2;
CLUTTER_NOTE (ALPHA, "sine: %2f\n", COGL_FIXED_TO_DOUBLE (sine)); CLUTTER_NOTE (ALPHA, "sine: %2f\n", CLUTTER_FIXED_TO_DOUBLE (sine));
return COGL_FIXED_TO_INT (sine * CLUTTER_ALPHA_MAX_ALPHA); return (sine * CLUTTER_ALPHA_MAX_ALPHA);
} }
/* NB: angle is not in radians but in muliples of PI, i.e., 2.0 /* NB: angle is not in radians but in muliples of PI, i.e., 2.0
@ -949,11 +949,30 @@ guint32
clutter_sine_func (ClutterAlpha *alpha, clutter_sine_func (ClutterAlpha *alpha,
gpointer dummy) gpointer dummy)
{ {
#if 0 #if 1
ClutterTimeline *timeline;
gint current_frame_num, n_frames;
float radians, sine;
timeline = clutter_alpha_get_timeline (alpha);
current_frame_num = clutter_timeline_get_current_frame (timeline);
n_frames = clutter_timeline_get_n_frames (timeline);
radians = ((float)current_frame_num / n_frames) * (2.0 * G_PI);
sine = sinf (radians);
/* shift from range [-1, 1] -> [0, 1] */
sine = (sine + 1.0) / 2.0;
CLUTTER_NOTE (ALPHA, "sine: %2f\n", sine);
return sine * CLUTTER_ALPHA_MAX_ALPHA;
#elif 0
return sinc_func (alpha, 2.0, 1.0); return sinc_func (alpha, 2.0, 1.0);
#else #elif 0
/* 2.0 above represents full circle */ /* 2.0 above represents full circle */
return sincx1024_func (alpha, 1024, COGL_FIXED_1); return sincx1024_func (alpha, 1024, 1.0);
#endif #endif
} }
@ -985,18 +1004,17 @@ clutter_sine_inc_func (ClutterAlpha *alpha,
ClutterTimeline * timeline; ClutterTimeline * timeline;
gint frame; gint frame;
gint n_frames; gint n_frames;
ClutterAngle x; float radians;
ClutterFixed sine; float sine;
timeline = clutter_alpha_get_timeline (alpha); timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline); frame = clutter_timeline_get_current_frame (timeline);
n_frames = clutter_timeline_get_n_frames (timeline); n_frames = clutter_timeline_get_n_frames (timeline);
x = 256 * frame / n_frames; radians = ((float)frame / n_frames) * (G_PI / 2);
sine = sinf (radians);
sine = cogl_angle_sin (x) * CLUTTER_ALPHA_MAX_ALPHA; return (guint32) (sine * CLUTTER_ALPHA_MAX_ALPHA);
return ((guint32) sine) >> COGL_FIXED_Q;
} }
/** /**
@ -1027,18 +1045,17 @@ clutter_sine_dec_func (ClutterAlpha *alpha,
ClutterTimeline * timeline; ClutterTimeline * timeline;
gint frame; gint frame;
gint n_frames; gint n_frames;
ClutterAngle x; float radians;
ClutterFixed sine; float sine;
timeline = clutter_alpha_get_timeline (alpha); timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline); frame = clutter_timeline_get_current_frame (timeline);
n_frames = clutter_timeline_get_n_frames (timeline); n_frames = clutter_timeline_get_n_frames (timeline);
x = 256 * frame / n_frames + 256; radians = ((float)frame / n_frames) * (G_PI / 2);
sine = sinf (radians + (G_PI / 2));
sine = cogl_angle_sin (x) * CLUTTER_ALPHA_MAX_ALPHA; return (guint32) (sine * CLUTTER_ALPHA_MAX_ALPHA);
return ((guint32) sine) >> COGL_FIXED_Q;
} }
/** /**
@ -1069,18 +1086,17 @@ clutter_sine_half_func (ClutterAlpha *alpha,
ClutterTimeline *timeline; ClutterTimeline *timeline;
gint frame; gint frame;
gint n_frames; gint n_frames;
ClutterAngle x; float radians;
ClutterFixed sine; float sine;
timeline = clutter_alpha_get_timeline (alpha); timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline); frame = clutter_timeline_get_current_frame (timeline);
n_frames = clutter_timeline_get_n_frames (timeline); n_frames = clutter_timeline_get_n_frames (timeline);
x = 512 * frame / n_frames; radians = ((float)frame / n_frames) * G_PI;
sine = sinf (radians);
sine = cogl_angle_sin (x) * CLUTTER_ALPHA_MAX_ALPHA; return (guint32) (sine * CLUTTER_ALPHA_MAX_ALPHA);
return ((guint32) sine) >> COGL_FIXED_Q;
} }
/** /**
@ -1105,19 +1121,20 @@ clutter_sine_in_func (ClutterAlpha *alpha,
ClutterTimeline *timeline; ClutterTimeline *timeline;
gint frame; gint frame;
gint n_frames; gint n_frames;
ClutterAngle x; float radians;
ClutterFixed sine; float sine;
timeline = clutter_alpha_get_timeline (alpha); timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline); frame = clutter_timeline_get_current_frame (timeline);
n_frames = clutter_timeline_get_n_frames (timeline); n_frames = clutter_timeline_get_n_frames (timeline);
/* XXX- if we use 768 we overflow */ radians = ((float)frame / n_frames) * (G_PI / 2);
x = 256 * frame / n_frames + 767; sine = sinf (radians - (G_PI / 2));
sine = (cogl_angle_sin (x) + 1) * CLUTTER_ALPHA_MAX_ALPHA; /* shift from range [-1, 0] -> [0, 1] */
sine = sine + 1.0;
return ((guint32) sine) >> COGL_FIXED_Q; return (guint32) (sine * CLUTTER_ALPHA_MAX_ALPHA);
} }
/** /**
@ -1141,18 +1158,17 @@ clutter_sine_out_func (ClutterAlpha *alpha,
ClutterTimeline *timeline; ClutterTimeline *timeline;
gint frame; gint frame;
gint n_frames; gint n_frames;
ClutterAngle x; float radians;
ClutterFixed sine; float sine;
timeline = clutter_alpha_get_timeline (alpha); timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline); frame = clutter_timeline_get_current_frame (timeline);
n_frames = clutter_timeline_get_n_frames (timeline); n_frames = clutter_timeline_get_n_frames (timeline);
x = 256 * frame / n_frames; radians = ((float)frame / n_frames) * (G_PI / 2);
sine = sinf (radians);
sine = cogl_angle_sin (x) * CLUTTER_ALPHA_MAX_ALPHA; return (guint32) (sine * CLUTTER_ALPHA_MAX_ALPHA);
return ((guint32) sine) >> COGL_FIXED_Q;
} }
/** /**
@ -1177,18 +1193,20 @@ clutter_sine_in_out_func (ClutterAlpha *alpha,
ClutterTimeline *timeline; ClutterTimeline *timeline;
gint frame; gint frame;
gint n_frames; gint n_frames;
ClutterAngle x; float radians;
ClutterFixed sine; float sine;
timeline = clutter_alpha_get_timeline (alpha); timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline); frame = clutter_timeline_get_current_frame (timeline);
n_frames = clutter_timeline_get_n_frames (timeline); n_frames = clutter_timeline_get_n_frames (timeline);
x = -256 * frame / n_frames + 256; radians = ((float)frame / n_frames) * G_PI;
sine = sinf (radians - (G_PI / 2));
sine = (cogl_angle_sin (x) + 1) / 2 * CLUTTER_ALPHA_MAX_ALPHA; /* shift from range [-1, 1] -> [0, 1] */
sine = (sine + 1.0) / 2.0;
return ((guint32) sine) >> COGL_FIXED_Q; return (guint32) (sine * CLUTTER_ALPHA_MAX_ALPHA);
} }
/** /**
@ -1256,32 +1274,25 @@ clutter_smoothstep_inc_func (ClutterAlpha *alpha,
ClutterTimeline *timeline; ClutterTimeline *timeline;
gint frame; gint frame;
gint n_frames; gint n_frames;
guint32 r; float r;
guint32 x; float x;
/* /*
* The smoothstep function uses f(x) = -2x^3 + 3x^2 where x is from <0,1>, * The smoothstep function uses f(x) = -2x^3 + 3x^2 where x is from <0,1>,
* and precission is critical -- we use 8.24 fixed format for this operation. * and precission is critical.
* The earlier operations involve division, which we cannot do in 8.24 for
* numbers in <0,1> we use ClutterFixed.
*/ */
timeline = clutter_alpha_get_timeline (alpha); timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline); frame = clutter_timeline_get_current_frame (timeline);
n_frames = clutter_timeline_get_n_frames (timeline); n_frames = clutter_timeline_get_n_frames (timeline);
/* x = (float)frame / n_frames;
* Convert x to 8.24 for next step.
*/
x = COGL_FIXED_FAST_DIV (frame, n_frames) << 8;
/* /*
* f(x) = -2x^3 + 3x^2 * f(x) = -2x^3 + 3x^2
*
* Convert result to ClutterFixed to avoid overflow in next step.
*/ */
r = ((x >> 12) * (x >> 12) * 3 - (x >> 15) * (x >> 16) * (x >> 16)) >> 8; r = -2 * x * x * x + 3 * x * x;
return COGL_FIXED_TO_INT (r * CLUTTER_ALPHA_MAX_ALPHA); return (r * CLUTTER_ALPHA_MAX_ALPHA);
} }
/** /**
@ -1347,9 +1358,9 @@ clutter_exp_inc_func (ClutterAlpha *alpha,
* *
* (2^x_alpha_max) - 1 == CLUTTER_ALPHA_MAX_ALPHA * (2^x_alpha_max) - 1 == CLUTTER_ALPHA_MAX_ALPHA
*/ */
#if CLUTTER_ALPHA_MAX_ALPHA != 0xffff /* XXX: If this fails:
#error Adjust x_alpha_max to match CLUTTER_ALPHA_MAX_ALPHA * Adjust x_alpha_max to match CLUTTER_ALPHA_MAX_ALPHA */
#endif g_assert (CLUTTER_ALPHA_MAX_ALPHA == 65535.0);
timeline = clutter_alpha_get_timeline (alpha); timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline); frame = clutter_timeline_get_current_frame (timeline);
@ -1357,7 +1368,7 @@ clutter_exp_inc_func (ClutterAlpha *alpha,
x = x_alpha_max * frame / n_frames; x = x_alpha_max * frame / n_frames;
result = CLAMP (cogl_fixed_pow2 (x) - 1, 0, CLUTTER_ALPHA_MAX_ALPHA); result = CLAMP (powf (2, x) - 1, 0, CLUTTER_ALPHA_MAX_ALPHA);
return result; return result;
} }
@ -1398,9 +1409,9 @@ clutter_exp_dec_func (ClutterAlpha *alpha,
* *
* (2^x_alpha_max) - 1 == CLUTTER_ALPHA_MAX_ALPHA * (2^x_alpha_max) - 1 == CLUTTER_ALPHA_MAX_ALPHA
*/ */
#if CLUTTER_ALPHA_MAX_ALPHA != 0xffff /* XXX: If this fails:
#error Adjust x_alpha_max to match CLUTTER_ALPHA_MAX_ALPHA * Adjust x_alpha_max to match CLUTTER_ALPHA_MAX_ALPHA */
#endif g_assert (CLUTTER_ALPHA_MAX_ALPHA == 65535.0);
timeline = clutter_alpha_get_timeline (alpha); timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline); frame = clutter_timeline_get_current_frame (timeline);
@ -1408,7 +1419,7 @@ clutter_exp_dec_func (ClutterAlpha *alpha,
x = (x_alpha_max * (n_frames - frame)) / n_frames; x = (x_alpha_max * (n_frames - frame)) / n_frames;
result = CLAMP (cogl_fixed_pow2 (x) - 1, 0, CLUTTER_ALPHA_MAX_ALPHA); result = CLAMP (powf (2, x) - 1, 0, CLUTTER_ALPHA_MAX_ALPHA);
return result; return result;
} }

2
clutter/clutter-alpha.h
View File

@ -105,7 +105,7 @@ struct _ClutterAlphaClass
* *
* Since: 0.2 * Since: 0.2
*/ */
#define CLUTTER_ALPHA_MAX_ALPHA (0xffff) #define CLUTTER_ALPHA_MAX_ALPHA (65535.0f)
GType clutter_alpha_get_type (void) G_GNUC_CONST; GType clutter_alpha_get_type (void) G_GNUC_CONST;

4
clutter/clutter-backend.c
View File

@ -416,7 +416,7 @@ clutter_backend_set_resolution (ClutterBackend *backend,
priv = backend->priv; priv = backend->priv;
fixed_dpi = COGL_FIXED_FROM_FLOAT (dpi); fixed_dpi = CLUTTER_FLOAT_TO_FIXED (dpi);
if (priv->resolution != fixed_dpi) if (priv->resolution != fixed_dpi)
priv->resolution = fixed_dpi; priv->resolution = fixed_dpi;
@ -443,7 +443,7 @@ clutter_backend_get_resolution (ClutterBackend *backend)
{ {
g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), -1.0); g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), -1.0);
return COGL_FIXED_TO_FLOAT (backend->priv->resolution); return CLUTTER_FIXED_TO_FLOAT (backend->priv->resolution);
} }
/** /**

4
clutter/clutter-behaviour-depth.c
View File

@ -83,9 +83,9 @@ clutter_behaviour_depth_alpha_notify (ClutterBehaviour *behaviour,
priv = CLUTTER_BEHAVIOUR_DEPTH (behaviour)->priv; priv = CLUTTER_BEHAVIOUR_DEPTH (behaviour)->priv;
/* Need to create factor as to avoid borking signedness */ /* Need to create factor as to avoid borking signedness */
factor = COGL_FIXED_FROM_INT (alpha_value) / CLUTTER_ALPHA_MAX_ALPHA; factor = (float)(alpha_value) / CLUTTER_ALPHA_MAX_ALPHA;
depth = priv->depth_start depth = priv->depth_start
+ COGL_FIXED_TO_INT (factor * (priv->depth_end - priv->depth_start)); + (factor * (priv->depth_end - priv->depth_start));
CLUTTER_NOTE (BEHAVIOUR, "alpha: %d, depth: %d", alpha_value, depth); CLUTTER_NOTE (BEHAVIOUR, "alpha: %d, depth: %d", alpha_value, depth);

210
clutter/clutter-behaviour-ellipse.c
View File

@ -86,11 +86,11 @@ struct _ClutterBehaviourEllipsePrivate
gint a; gint a;
gint b; gint b;
ClutterAngle angle_start; float angle_start;
ClutterAngle angle_end; float angle_end;
ClutterAngle angle_tilt_x; float angle_tilt_x;
ClutterAngle angle_tilt_y; float angle_tilt_y;
ClutterAngle angle_tilt_z; float angle_tilt_z;
ClutterRotateDirection direction; ClutterRotateDirection direction;
}; };
@ -104,14 +104,14 @@ typedef struct _knot3d
static void static void
clutter_behaviour_ellipse_advance (ClutterBehaviourEllipse *e, clutter_behaviour_ellipse_advance (ClutterBehaviourEllipse *e,
ClutterAngle angle, float angle,
knot3d *knot) knot3d *knot)
{ {
ClutterBehaviourEllipsePrivate *priv = e->priv; ClutterBehaviourEllipsePrivate *priv = e->priv;
gint x, y, z; gint x, y, z;
x = COGL_FIXED_TO_INT (priv->a * cogl_angle_cos (angle)); x = (priv->a * cosf (angle * (G_PI/180.0)));
y = COGL_FIXED_TO_INT (priv->b * cogl_angle_sin (angle)); y = (priv->b * sinf (angle * (G_PI/180.0)));
z = 0; z = 0;
if (priv->angle_tilt_z) if (priv->angle_tilt_z)
@ -126,40 +126,40 @@ clutter_behaviour_ellipse_advance (ClutterBehaviourEllipse *e,
*/ */
ClutterFixed x2, y2; ClutterFixed x2, y2;
x2 = x * cogl_angle_cos (priv->angle_tilt_z) x2 = x * cosf (priv->angle_tilt_z * (G_PI/180.0))
- y * cogl_angle_sin (priv->angle_tilt_z); - y * sinf (priv->angle_tilt_z * (G_PI/180.0));
y2 = y * cogl_angle_cos (priv->angle_tilt_z) y2 = y * cosf (priv->angle_tilt_z * (G_PI/180.0))
+ x * cogl_angle_sin (priv->angle_tilt_z); + x * sinf (priv->angle_tilt_z * (G_PI/180.0));
x = COGL_FIXED_TO_INT (x2); x = (x2);
y = COGL_FIXED_TO_INT (y2); y = (y2);
} }
if (priv->angle_tilt_x) if (priv->angle_tilt_x)
{ {
ClutterFixed z2, y2; ClutterFixed z2, y2;
z2 = - y * cogl_angle_sin (priv->angle_tilt_x); z2 = - y * sinf (priv->angle_tilt_x * (G_PI/180.0));
y2 = y * cogl_angle_cos (priv->angle_tilt_x); y2 = y * cosf (priv->angle_tilt_x * (G_PI/180.0));
z = COGL_FIXED_TO_INT (z2); z = (z2);
y = COGL_FIXED_TO_INT (y2); y = (y2);
} }
if (priv->angle_tilt_y) if (priv->angle_tilt_y)
{ {
ClutterFixed x2, z2; ClutterFixed x2, z2;
x2 = x * cogl_angle_cos (priv->angle_tilt_y) x2 = x * cosf (priv->angle_tilt_y * (G_PI/180.0))
- z * cogl_angle_sin (priv->angle_tilt_y); - z * sinf (priv->angle_tilt_y * (G_PI/180.0));
z2 = z * cogl_angle_cos (priv->angle_tilt_y) z2 = z * cosf (priv->angle_tilt_y * (G_PI/180.0))
+ x * cogl_angle_sin (priv->angle_tilt_y); + x * sinf (priv->angle_tilt_y * (G_PI/180.0));
x = COGL_FIXED_TO_INT (x2); x = (x2);
z = COGL_FIXED_TO_INT (z2); z = (z2);
} }
knot->x = x; knot->x = x;
@ -187,20 +187,16 @@ actor_apply_knot_foreach (ClutterBehaviour *behave,
clutter_actor_set_depth (actor, knot->z); clutter_actor_set_depth (actor, knot->z);
} }
static inline ClutterAngle static inline float
clamp_angle (ClutterAngle a) clamp_angle (float a)
{ {
ClutterAngle a1, a2;
gint rounds; gint rounds;
/* Need to add the 256 offset here, since the user space 0 maps to our rounds = a / 360;
* -256 if (a < 0)
*/ rounds--;
rounds = (a + 256) / 1024;
a1 = rounds * 1024;
a2 = a - a1;
return a2; return a - 360 * rounds;
} }
static void static void
@ -209,20 +205,20 @@ clutter_behaviour_ellipse_alpha_notify (ClutterBehaviour *behave,
{ {
ClutterBehaviourEllipse *self = CLUTTER_BEHAVIOUR_ELLIPSE (behave); ClutterBehaviourEllipse *self = CLUTTER_BEHAVIOUR_ELLIPSE (behave);
ClutterBehaviourEllipsePrivate *priv = self->priv; ClutterBehaviourEllipsePrivate *priv = self->priv;
ClutterAngle start, end; float start, end;
knot3d knot; knot3d knot;
ClutterAngle angle = 0; float angle = 0;
start = priv->angle_start; start = priv->angle_start;
end = priv->angle_end; end = priv->angle_end;
if (priv->direction == CLUTTER_ROTATE_CW && start >= end) if (priv->direction == CLUTTER_ROTATE_CW && start >= end)
{ {
end += 1024; end += 360;
} }
else if (priv->direction == CLUTTER_ROTATE_CCW && start <= end) else if (priv->direction == CLUTTER_ROTATE_CCW && start <= end)
{ {
end -= 1024; end -= 360;
} }
angle = (end - start) * alpha / CLUTTER_ALPHA_MAX_ALPHA + start; angle = (end - start) * alpha / CLUTTER_ALPHA_MAX_ALPHA + start;
@ -247,30 +243,25 @@ clutter_behaviour_ellipse_set_property (GObject *gobject,
switch (prop_id) switch (prop_id)
{ {
case PROP_ANGLE_START: case PROP_ANGLE_START:
priv->angle_start = priv->angle_start = g_value_get_double (value);
COGL_ANGLE_FROM_DEG (g_value_get_double (value)) - 256;
break; break;
case PROP_ANGLE_END: case PROP_ANGLE_END:
priv->angle_end = priv->angle_end = g_value_get_double (value);
COGL_ANGLE_FROM_DEG (g_value_get_double (value)) - 256;
break; break;
case PROP_ANGLE_TILT_X: case PROP_ANGLE_TILT_X:
priv->angle_tilt_x = priv->angle_tilt_x = g_value_get_double (value);
COGL_ANGLE_FROM_DEG (g_value_get_double (value));
break; break;
case PROP_ANGLE_TILT_Y: case PROP_ANGLE_TILT_Y:
priv->angle_tilt_y = priv->angle_tilt_y = g_value_get_double (value);
COGL_ANGLE_FROM_DEG (g_value_get_double (value));
break; break;
case PROP_ANGLE_TILT_Z: case PROP_ANGLE_TILT_Z:
priv->angle_tilt_z = priv->angle_tilt_z = g_value_get_double (value);
COGL_ANGLE_FROM_DEG (g_value_get_double (value));
break; break;
case PROP_WIDTH: case PROP_WIDTH:
priv->a = g_value_get_int (value) >> 1; priv->a = g_value_get_int (value) / 2;
break; break;
case PROP_HEIGHT: case PROP_HEIGHT:
priv->b = g_value_get_int (value) >> 1; priv->b = g_value_get_int (value) / 2;
break; break;
case PROP_CENTER: case PROP_CENTER:
{ {
@ -301,30 +292,25 @@ clutter_behaviour_ellipse_get_property (GObject *gobject,
switch (prop_id) switch (prop_id)
{ {
case PROP_ANGLE_START: case PROP_ANGLE_START:
g_value_set_double (value, g_value_set_double (value, priv->angle_start);
COGL_ANGLE_TO_DEG (priv->angle_start + 256));
break; break;
case PROP_ANGLE_END: case PROP_ANGLE_END:
g_value_set_double (value, g_value_set_double (value, priv->angle_end);
COGL_ANGLE_TO_DEG (priv->angle_end + 256));
break; break;
case PROP_ANGLE_TILT_X: case PROP_ANGLE_TILT_X:
g_value_set_double (value, g_value_set_double (value, priv->angle_tilt_x);
COGL_ANGLE_TO_DEG (priv->angle_tilt_x));
break; break;
case PROP_ANGLE_TILT_Y: case PROP_ANGLE_TILT_Y:
g_value_set_double (value, g_value_set_double (value, priv->angle_tilt_y);
COGL_ANGLE_TO_DEG (priv->angle_tilt_y));
break; break;
case PROP_ANGLE_TILT_Z: case PROP_ANGLE_TILT_Z:
g_value_set_double (value, g_value_set_double (value, priv->angle_tilt_z);
COGL_ANGLE_TO_DEG (priv->angle_tilt_z));
break; break;
case PROP_WIDTH: case PROP_WIDTH:
g_value_set_int (value, (priv->a << 1)); g_value_set_int (value, (priv->a * 2));
break; break;
case PROP_HEIGHT: case PROP_HEIGHT:
g_value_set_int (value, (priv->b << 1)); g_value_set_int (value, (priv->b * 2));
break; break;
case PROP_CENTER: case PROP_CENTER:
g_value_set_boxed (value, &priv->center); g_value_set_boxed (value, &priv->center);
@ -513,12 +499,8 @@ clutter_behaviour_ellipse_init (ClutterBehaviourEllipse * self)
priv->direction = CLUTTER_ROTATE_CW; priv->direction = CLUTTER_ROTATE_CW;
/* The inital values have to reflect the 90 degree offset between the normal priv->angle_start = 0;
* mathematical space and the clutter clock-based space; the default end priv->angle_end = 0;
* value of 360 is clamped to 0.
*/
priv->angle_start = -256;
priv->angle_end = -256;
} }
/** /**
@ -611,8 +593,8 @@ clutter_behaviour_ellipse_newx (ClutterAlpha * alpha,
"width", width, "width", width,
"height", height, "height", height,
"direction", direction, "direction", direction,
"angle-start", COGL_ANGLE_FROM_DEGX (start), "angle-start", (double)CLUTTER_FIXED_TO_FLOAT (start),
"angle-end", COGL_ANGLE_FROM_DEGX (end), "angle-end", (double)CLUTTER_FIXED_TO_FLOAT (end),
NULL); NULL);
} }
@ -695,9 +677,9 @@ clutter_behaviour_ellipse_set_width (ClutterBehaviourEllipse * self,
priv = self->priv; priv = self->priv;
if (priv->a != width >> 1) if (priv->a != width / 2)
{ {
priv->a = width >> 1; priv->a = width / 2;
g_object_notify (G_OBJECT (self), "width"); g_object_notify (G_OBJECT (self), "width");
} }
@ -718,7 +700,7 @@ clutter_behaviour_ellipse_get_width (ClutterBehaviourEllipse *self)
{ {
g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0); g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0);
return self->priv->a << 1; return self->priv->a * 2;
} }
/** /**
@ -740,9 +722,9 @@ clutter_behaviour_ellipse_set_height (ClutterBehaviourEllipse *self,
priv = self->priv; priv = self->priv;
if (priv->b != height >> 1) if (priv->b != height / 2)
{ {
priv->b = height >> 1; priv->b = height / 2;
g_object_notify (G_OBJECT (self), "height"); g_object_notify (G_OBJECT (self), "height");
} }
@ -763,7 +745,7 @@ clutter_behaviour_ellipse_get_height (ClutterBehaviourEllipse *self)
{ {
g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0); g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0);
return self->priv->b << 1; return self->priv->b * 2;
} }
/** /**
@ -780,10 +762,11 @@ void
clutter_behaviour_ellipse_set_angle_start (ClutterBehaviourEllipse *self, clutter_behaviour_ellipse_set_angle_start (ClutterBehaviourEllipse *self,
gdouble angle_start) gdouble angle_start)
{ {
ClutterFixed new_angle = CLUTTER_FLOAT_TO_FIXED (angle_start);
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self)); g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
clutter_behaviour_ellipse_set_angle_startx (self, clutter_behaviour_ellipse_set_angle_startx (self, new_angle);
COGL_FIXED_FROM_FLOAT (angle_start));
} }
/** /**
@ -802,10 +785,10 @@ clutter_behaviour_ellipse_set_angle_startx (ClutterBehaviourEllipse *self,
ClutterFixed angle_start) ClutterFixed angle_start)
{ {
ClutterBehaviourEllipsePrivate *priv; ClutterBehaviourEllipsePrivate *priv;
ClutterAngle new_angle; float new_angle;
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self)); g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
new_angle = clamp_angle (COGL_ANGLE_FROM_DEGX (angle_start) - 256); new_angle = clamp_angle (CLUTTER_FIXED_TO_FLOAT (angle_start));
priv = self->priv; priv = self->priv;
if (priv->angle_start != new_angle) if (priv->angle_start != new_angle)
@ -830,7 +813,7 @@ clutter_behaviour_ellipse_get_angle_start (ClutterBehaviourEllipse *self)
{ {
g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0.0); g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0.0);
return COGL_ANGLE_TO_DEG (self->priv->angle_start + 256); return (double)self->priv->angle_start;
} }
/** /**
@ -848,7 +831,7 @@ clutter_behaviour_ellipse_get_angle_startx (ClutterBehaviourEllipse *self)
{ {
g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0); g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0);
return COGL_ANGLE_TO_DEGX (self->priv->angle_start); return CLUTTER_FLOAT_TO_FIXED (self->priv->angle_start);
} }
/** /**
@ -865,10 +848,11 @@ void
clutter_behaviour_ellipse_set_angle_end (ClutterBehaviourEllipse *self, clutter_behaviour_ellipse_set_angle_end (ClutterBehaviourEllipse *self,
gdouble angle_end) gdouble angle_end)
{ {
ClutterFixed new_angle = CLUTTER_FLOAT_TO_FIXED (angle_end);
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self)); g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
clutter_behaviour_ellipse_set_angle_endx (self, clutter_behaviour_ellipse_set_angle_endx (self, new_angle);
COGL_FIXED_FROM_FLOAT (angle_end));
} }
/** /**
@ -887,11 +871,11 @@ clutter_behaviour_ellipse_set_angle_endx (ClutterBehaviourEllipse *self,
ClutterFixed angle_end) ClutterFixed angle_end)
{ {
ClutterBehaviourEllipsePrivate *priv; ClutterBehaviourEllipsePrivate *priv;
ClutterAngle new_angle; float new_angle;
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self)); g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
new_angle = clamp_angle (COGL_ANGLE_FROM_DEGX (angle_end) - 256); new_angle = clamp_angle (CLUTTER_FIXED_TO_FLOAT (angle_end));
priv = self->priv; priv = self->priv;
@ -918,7 +902,7 @@ clutter_behaviour_ellipse_get_angle_end (ClutterBehaviourEllipse *self)
{ {
g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0.0); g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0.0);
return COGL_ANGLE_TO_DEG (self->priv->angle_end + 256); return self->priv->angle_end;
} }
/** /**
@ -936,7 +920,7 @@ clutter_behaviour_ellipse_get_angle_endx (ClutterBehaviourEllipse *self)
{ {
g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0); g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0);
return COGL_ANGLE_TO_DEGX (self->priv->angle_end); return CLUTTER_FLOAT_TO_FIXED (self->priv->angle_end);
} }
/** /**
@ -955,11 +939,11 @@ clutter_behaviour_ellipse_set_angle_tilt (ClutterBehaviourEllipse *self,
ClutterRotateAxis axis, ClutterRotateAxis axis,
gdouble angle_tilt) gdouble angle_tilt)
{ {
ClutterFixed new_angle = CLUTTER_FLOAT_TO_FIXED (angle_tilt);
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self)); g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
clutter_behaviour_ellipse_set_angle_tiltx (self, clutter_behaviour_ellipse_set_angle_tiltx (self, axis, new_angle);
axis,
COGL_FIXED_FROM_FLOAT (angle_tilt));
} }
/** /**
@ -979,11 +963,11 @@ clutter_behaviour_ellipse_set_angle_tiltx (ClutterBehaviourEllipse *self,
ClutterFixed angle_tilt) ClutterFixed angle_tilt)
{ {
ClutterBehaviourEllipsePrivate *priv; ClutterBehaviourEllipsePrivate *priv;
ClutterAngle new_angle; float new_angle;
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self)); g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
new_angle = COGL_ANGLE_FROM_DEGX (angle_tilt); new_angle = CLUTTER_FIXED_TO_FLOAT (angle_tilt);
priv = self->priv; priv = self->priv;
@ -1038,11 +1022,11 @@ clutter_behaviour_ellipse_get_angle_tilt (ClutterBehaviourEllipse *self,
switch (axis) switch (axis)
{ {
case CLUTTER_X_AXIS: case CLUTTER_X_AXIS:
return COGL_ANGLE_TO_DEG (self->priv->angle_tilt_x); return self->priv->angle_tilt_x;
case CLUTTER_Y_AXIS: case CLUTTER_Y_AXIS:
return COGL_ANGLE_TO_DEG (self->priv->angle_tilt_y); return self->priv->angle_tilt_y;
case CLUTTER_Z_AXIS: case CLUTTER_Z_AXIS:
return COGL_ANGLE_TO_DEG (self->priv->angle_tilt_z); return self->priv->angle_tilt_z;
} }
return 0; return 0;
@ -1068,11 +1052,11 @@ clutter_behaviour_ellipse_get_angle_tiltx (ClutterBehaviourEllipse *self,
switch (axis) switch (axis)
{ {
case CLUTTER_X_AXIS: case CLUTTER_X_AXIS:
return COGL_ANGLE_TO_DEGX (self->priv->angle_tilt_x); return CLUTTER_FLOAT_TO_FIXED (self->priv->angle_tilt_x);
case CLUTTER_Y_AXIS: case CLUTTER_Y_AXIS:
return COGL_ANGLE_TO_DEGX (self->priv->angle_tilt_y); return CLUTTER_FLOAT_TO_FIXED (self->priv->angle_tilt_y);
case CLUTTER_Z_AXIS: case CLUTTER_Z_AXIS:
return COGL_ANGLE_TO_DEGX (self->priv->angle_tilt_z); return CLUTTER_FLOAT_TO_FIXED (self->priv->angle_tilt_z);
} }
return 0; return 0;
@ -1096,13 +1080,13 @@ clutter_behaviour_ellipse_set_tilt (ClutterBehaviourEllipse *self,
gdouble angle_tilt_z) gdouble angle_tilt_z)
{ {
ClutterBehaviourEllipsePrivate *priv; ClutterBehaviourEllipsePrivate *priv;
ClutterAngle new_angle_x, new_angle_y, new_angle_z; float new_angle_x, new_angle_y, new_angle_z;
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self)); g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
new_angle_x = COGL_ANGLE_FROM_DEG (angle_tilt_x); new_angle_x = (float)angle_tilt_x;
new_angle_y = COGL_ANGLE_FROM_DEG (angle_tilt_y); new_angle_y = (float)angle_tilt_y;
new_angle_z = COGL_ANGLE_FROM_DEG (angle_tilt_z); new_angle_z = (float)angle_tilt_z;
priv = self->priv; priv = self->priv;
@ -1150,13 +1134,13 @@ clutter_behaviour_ellipse_set_tiltx (ClutterBehaviourEllipse *self,
ClutterFixed angle_tilt_z) ClutterFixed angle_tilt_z)
{ {
ClutterBehaviourEllipsePrivate *priv; ClutterBehaviourEllipsePrivate *priv;
ClutterAngle new_angle_x, new_angle_y, new_angle_z; float new_angle_x, new_angle_y, new_angle_z;
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self)); g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
new_angle_x = COGL_ANGLE_FROM_DEGX (angle_tilt_x); new_angle_x = CLUTTER_FIXED_TO_FLOAT (angle_tilt_x);
new_angle_y = COGL_ANGLE_FROM_DEGX (angle_tilt_y); new_angle_y = CLUTTER_FIXED_TO_FLOAT (angle_tilt_y);
new_angle_z = COGL_ANGLE_FROM_DEGX (angle_tilt_z); new_angle_z = CLUTTER_FIXED_TO_FLOAT (angle_tilt_z);
priv = self->priv; priv = self->priv;
@ -1210,13 +1194,13 @@ clutter_behaviour_ellipse_get_tilt (ClutterBehaviourEllipse *self,
priv = self->priv; priv = self->priv;
if (angle_tilt_x) if (angle_tilt_x)
*angle_tilt_x = COGL_ANGLE_TO_DEG (priv->angle_tilt_x); *angle_tilt_x = priv->angle_tilt_x;
if (angle_tilt_y) if (angle_tilt_y)
*angle_tilt_y = COGL_ANGLE_TO_DEG (priv->angle_tilt_y); *angle_tilt_y = priv->angle_tilt_y;
if (angle_tilt_z) if (angle_tilt_z)
*angle_tilt_z = COGL_ANGLE_TO_DEG (priv->angle_tilt_z); *angle_tilt_z = priv->angle_tilt_z;
} }
/** /**
@ -1246,13 +1230,13 @@ clutter_behaviour_ellipse_get_tiltx (ClutterBehaviourEllipse *self,
priv = self->priv; priv = self->priv;
if (angle_tilt_x) if (angle_tilt_x)
*angle_tilt_x = COGL_ANGLE_TO_DEGX (priv->angle_tilt_x); *angle_tilt_x = priv->angle_tilt_x;
if (angle_tilt_y) if (angle_tilt_y)
*angle_tilt_y = COGL_ANGLE_TO_DEGX (priv->angle_tilt_y); *angle_tilt_y = priv->angle_tilt_y;
if (angle_tilt_z) if (angle_tilt_z)
*angle_tilt_z = COGL_ANGLE_TO_DEGX (priv->angle_tilt_z); *angle_tilt_z = priv->angle_tilt_z;
} }
/** /**

32
clutter/clutter-behaviour-rotate.c
View File

@ -108,8 +108,8 @@ ClutterFixed clamp_angle (ClutterFixed a)
ClutterFixed a1, a2; ClutterFixed a1, a2;
gint rounds; gint rounds;
rounds = a / COGL_FIXED_360; rounds = a / 360.0;
a1 = rounds * COGL_FIXED_360; a1 = rounds * 360.0;
a2 = a - a1; a2 = a - a1;
return a2; return a2;
@ -126,7 +126,7 @@ clutter_behaviour_rotate_alpha_notify (ClutterBehaviour *behaviour,
rotate_behaviour = CLUTTER_BEHAVIOUR_ROTATE (behaviour); rotate_behaviour = CLUTTER_BEHAVIOUR_ROTATE (behaviour);
priv = rotate_behaviour->priv; priv = rotate_behaviour->priv;
factor = COGL_FIXED_FROM_INT (alpha_value) / CLUTTER_ALPHA_MAX_ALPHA; factor = (float)(alpha_value) / CLUTTER_ALPHA_MAX_ALPHA;
angle = 0; angle = 0;
start = priv->angle_start; start = priv->angle_start;
@ -134,14 +134,14 @@ clutter_behaviour_rotate_alpha_notify (ClutterBehaviour *behaviour,
if (priv->direction == CLUTTER_ROTATE_CW && start >= end) if (priv->direction == CLUTTER_ROTATE_CW && start >= end)
{ {
end += COGL_FIXED_360; end += 360.0;
} }
else if (priv->direction == CLUTTER_ROTATE_CCW && start <= end) else if (priv->direction == CLUTTER_ROTATE_CCW && start <= end)
{ {
end -= COGL_FIXED_360; end -= 360.0;
} }
angle = COGL_FIXED_FAST_MUL ((end - start), factor) + start; angle = CLUTTER_FIXED_MUL ((end - start), factor) + start;
clutter_behaviour_actors_foreach (behaviour, clutter_behaviour_actors_foreach (behaviour,
alpha_notify_foreach, alpha_notify_foreach,
@ -163,10 +163,10 @@ clutter_behaviour_rotate_set_property (GObject *gobject,
switch (prop_id) switch (prop_id)
{ {
case PROP_ANGLE_START: case PROP_ANGLE_START:
priv->angle_start = COGL_FIXED_FROM_FLOAT (g_value_get_double (value)); priv->angle_start = CLUTTER_FLOAT_TO_FIXED (g_value_get_double (value));
break; break;
case PROP_ANGLE_END: case PROP_ANGLE_END:
priv->angle_end = COGL_FIXED_FROM_FLOAT (g_value_get_double (value)); priv->angle_end = CLUTTER_FLOAT_TO_FIXED (g_value_get_double (value));
break; break;
case PROP_AXIS: case PROP_AXIS:
priv->axis = g_value_get_enum (value); priv->axis = g_value_get_enum (value);
@ -211,10 +211,10 @@ clutter_behaviour_rotate_get_property (GObject *gobject,
switch (prop_id) switch (prop_id)
{ {
case PROP_ANGLE_START: case PROP_ANGLE_START:
g_value_set_double (value, COGL_FIXED_TO_DOUBLE (priv->angle_start)); g_value_set_double (value, CLUTTER_FIXED_TO_DOUBLE (priv->angle_start));
break; break;
case PROP_ANGLE_END: case PROP_ANGLE_END:
g_value_set_double (value, COGL_FIXED_TO_DOUBLE (priv->angle_end)); g_value_set_double (value, CLUTTER_FIXED_TO_DOUBLE (priv->angle_end));
break; break;
case PROP_AXIS: case PROP_AXIS:
g_value_set_enum (value, priv->axis); g_value_set_enum (value, priv->axis);
@ -367,8 +367,8 @@ clutter_behaviour_rotate_init (ClutterBehaviourRotate *rotate)
rotate->priv = priv = CLUTTER_BEHAVIOUR_ROTATE_GET_PRIVATE (rotate); rotate->priv = priv = CLUTTER_BEHAVIOUR_ROTATE_GET_PRIVATE (rotate);
priv->angle_start = COGL_FIXED_FROM_FLOAT (0.0); priv->angle_start = CLUTTER_FLOAT_TO_FIXED (0.0);
priv->angle_end = COGL_FIXED_FROM_FLOAT (0.0); priv->angle_end = CLUTTER_FLOAT_TO_FIXED (0.0);
priv->axis = CLUTTER_Z_AXIS; priv->axis = CLUTTER_Z_AXIS;
priv->direction = CLUTTER_ROTATE_CW; priv->direction = CLUTTER_ROTATE_CW;
priv->center_x = priv->center_y = priv->center_z = 0; priv->center_x = priv->center_y = priv->center_z = 0;
@ -568,10 +568,10 @@ clutter_behaviour_rotate_get_bounds (ClutterBehaviourRotate *rotate,
priv = rotate->priv; priv = rotate->priv;
if (angle_start) if (angle_start)
*angle_start = COGL_FIXED_TO_DOUBLE (priv->angle_start); *angle_start = CLUTTER_FIXED_TO_DOUBLE (priv->angle_start);
if (angle_end) if (angle_end)
*angle_end = COGL_FIXED_TO_DOUBLE (priv->angle_end); *angle_end = CLUTTER_FIXED_TO_DOUBLE (priv->angle_end);
} }
/** /**
@ -593,8 +593,8 @@ clutter_behaviour_rotate_set_bounds (ClutterBehaviourRotate *rotate,
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ROTATE (rotate)); g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ROTATE (rotate));
clutter_behaviour_rotate_set_boundsx (rotate, clutter_behaviour_rotate_set_boundsx (rotate,
COGL_FIXED_FROM_FLOAT (angle_start), CLUTTER_FLOAT_TO_FIXED (angle_start),
COGL_FIXED_FROM_FLOAT (angle_end)); CLUTTER_FLOAT_TO_FIXED (angle_end));
} }
/** /**

50
clutter/clutter-behaviour-scale.c
View File

@ -115,14 +115,14 @@ clutter_behaviour_scale_alpha_notify (ClutterBehaviour *behave,
{ {
ClutterFixed factor; ClutterFixed factor;
factor = COGL_FIXED_FROM_INT (alpha_value) / CLUTTER_ALPHA_MAX_ALPHA; factor = (float)(alpha_value) / CLUTTER_ALPHA_MAX_ALPHA;
scale_x = scale_x =
COGL_FIXED_FAST_MUL (factor, (priv->x_scale_end - priv->x_scale_start)); CLUTTER_FIXED_MUL (factor, (priv->x_scale_end - priv->x_scale_start));
scale_x += priv->x_scale_start; scale_x += priv->x_scale_start;
scale_y = scale_y =
COGL_FIXED_FAST_MUL (factor, (priv->y_scale_end - priv->y_scale_start)); CLUTTER_FIXED_MUL (factor, (priv->y_scale_end - priv->y_scale_start));
scale_y += priv->y_scale_start; scale_y += priv->y_scale_start;
} }
@ -147,16 +147,16 @@ clutter_behaviour_scale_set_property (GObject *gobject,
switch (prop_id) switch (prop_id)
{ {
case PROP_X_SCALE_START: case PROP_X_SCALE_START:
priv->x_scale_start = COGL_FIXED_FROM_FLOAT (g_value_get_double (value)); priv->x_scale_start = CLUTTER_FLOAT_TO_FIXED (g_value_get_double (value));
break; break;
case PROP_X_SCALE_END: case PROP_X_SCALE_END:
priv->x_scale_end = COGL_FIXED_FROM_FLOAT (g_value_get_double (value)); priv->x_scale_end = CLUTTER_FLOAT_TO_FIXED (g_value_get_double (value));
break; break;
case PROP_Y_SCALE_START: case PROP_Y_SCALE_START:
priv->y_scale_start = COGL_FIXED_FROM_FLOAT (g_value_get_double (value)); priv->y_scale_start = CLUTTER_FLOAT_TO_FIXED (g_value_get_double (value));
break; break;
case PROP_Y_SCALE_END: case PROP_Y_SCALE_END:
priv->y_scale_end = COGL_FIXED_FROM_FLOAT (g_value_get_double (value)); priv->y_scale_end = CLUTTER_FLOAT_TO_FIXED (g_value_get_double (value));
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
@ -177,16 +177,16 @@ clutter_behaviour_scale_get_property (GObject *gobject,
switch (prop_id) switch (prop_id)
{ {
case PROP_X_SCALE_START: case PROP_X_SCALE_START:
g_value_set_double (value, COGL_FIXED_TO_FLOAT (priv->x_scale_start)); g_value_set_double (value, CLUTTER_FIXED_TO_FLOAT (priv->x_scale_start));
break; break;
case PROP_X_SCALE_END: case PROP_X_SCALE_END:
g_value_set_double (value, COGL_FIXED_TO_FLOAT (priv->x_scale_end)); g_value_set_double (value, CLUTTER_FIXED_TO_FLOAT (priv->x_scale_end));
break; break;
case PROP_Y_SCALE_START: case PROP_Y_SCALE_START:
g_value_set_double (value, COGL_FIXED_TO_FLOAT (priv->y_scale_start)); g_value_set_double (value, CLUTTER_FIXED_TO_FLOAT (priv->y_scale_start));
break; break;
case PROP_Y_SCALE_END: case PROP_Y_SCALE_END:
g_value_set_double (value, COGL_FIXED_TO_FLOAT (priv->y_scale_end)); g_value_set_double (value, CLUTTER_FIXED_TO_FLOAT (priv->y_scale_end));
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
@ -276,8 +276,8 @@ clutter_behaviour_scale_init (ClutterBehaviourScale *self)
self->priv = priv = CLUTTER_BEHAVIOUR_SCALE_GET_PRIVATE (self); self->priv = priv = CLUTTER_BEHAVIOUR_SCALE_GET_PRIVATE (self);
priv->x_scale_start = priv->x_scale_end = COGL_FIXED_1; priv->x_scale_start = priv->x_scale_end = 1.0;
priv->y_scale_start = priv->y_scale_end = COGL_FIXED_1; priv->y_scale_start = priv->y_scale_end = 1.0;
} }
/** /**
@ -304,10 +304,10 @@ clutter_behaviour_scale_new (ClutterAlpha *alpha,
g_return_val_if_fail (alpha == NULL || CLUTTER_IS_ALPHA (alpha), NULL); g_return_val_if_fail (alpha == NULL || CLUTTER_IS_ALPHA (alpha), NULL);
return clutter_behaviour_scale_newx (alpha, return clutter_behaviour_scale_newx (alpha,
COGL_FIXED_FROM_FLOAT (x_scale_start), CLUTTER_FLOAT_TO_FIXED (x_scale_start),
COGL_FIXED_FROM_FLOAT (y_scale_start), CLUTTER_FLOAT_TO_FIXED (y_scale_start),
COGL_FIXED_FROM_FLOAT (x_scale_end), CLUTTER_FLOAT_TO_FIXED (x_scale_end),
COGL_FIXED_FROM_FLOAT (y_scale_end)); CLUTTER_FLOAT_TO_FIXED (y_scale_end));
} }
/** /**
@ -367,10 +367,10 @@ clutter_behaviour_scale_set_bounds (ClutterBehaviourScale *scale,
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_SCALE (scale)); g_return_if_fail (CLUTTER_IS_BEHAVIOUR_SCALE (scale));
clutter_behaviour_scale_set_boundsx (scale, clutter_behaviour_scale_set_boundsx (scale,
COGL_FIXED_FROM_FLOAT (x_scale_start), CLUTTER_FLOAT_TO_FIXED (x_scale_start),
COGL_FIXED_FROM_FLOAT (y_scale_start), CLUTTER_FLOAT_TO_FIXED (y_scale_start),
COGL_FIXED_FROM_FLOAT (x_scale_end), CLUTTER_FLOAT_TO_FIXED (x_scale_end),
COGL_FIXED_FROM_FLOAT (y_scale_end)); CLUTTER_FLOAT_TO_FIXED (y_scale_end));
} }
/** /**
@ -403,16 +403,16 @@ clutter_behaviour_scale_get_bounds (ClutterBehaviourScale *scale,
priv = scale->priv; priv = scale->priv;
if (x_scale_start) if (x_scale_start)
*x_scale_start = COGL_FIXED_TO_DOUBLE (priv->x_scale_start); *x_scale_start = CLUTTER_FIXED_TO_DOUBLE (priv->x_scale_start);
if (x_scale_end) if (x_scale_end)
*x_scale_end = COGL_FIXED_TO_DOUBLE (priv->x_scale_end); *x_scale_end = CLUTTER_FIXED_TO_DOUBLE (priv->x_scale_end);
if (y_scale_start) if (y_scale_start)
*y_scale_start = COGL_FIXED_TO_DOUBLE (priv->y_scale_start); *y_scale_start = CLUTTER_FIXED_TO_DOUBLE (priv->y_scale_start);
if (y_scale_end) if (y_scale_end)
*y_scale_end = COGL_FIXED_TO_DOUBLE (priv->y_scale_end); *y_scale_end = CLUTTER_FIXED_TO_DOUBLE (priv->y_scale_end);
} }
/** /**

2
clutter/clutter-bezier.c
View File

@ -252,7 +252,7 @@ _clutter_bezier_init (ClutterBezier *b,
int x = _clutter_bezier_t2x (b, t); int x = _clutter_bezier_t2x (b, t);
int y = _clutter_bezier_t2y (b, t); int y = _clutter_bezier_t2y (b, t);
guint l = clutter_sqrti ((y - yp)*(y - yp) + (x - xp)*(x - xp)); guint l = cogl_sqrti ((y - yp)*(y - yp) + (x - xp)*(x - xp));
l += length[i-1]; l += length[i-1];

16
clutter/clutter-clone-texture.c
View File

@ -196,20 +196,20 @@ clutter_clone_texture_paint (ClutterActor *self)
tex_height = cogl_texture_get_height (cogl_texture); tex_height = cogl_texture_get_height (cogl_texture);
if (priv->repeat_x && tex_width > 0) if (priv->repeat_x && tex_width > 0)
t_w = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (x_2 - x_1), t_w = CLUTTER_FIXED_DIV ((float)(x_2 - x_1),
COGL_FIXED_FROM_INT (tex_width)); (float)(tex_width));
else else
t_w = COGL_FIXED_1; t_w = 1.0;
if (priv->repeat_y && tex_height > 0) if (priv->repeat_y && tex_height > 0)
t_h = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (y_2 - y_1), t_h = CLUTTER_FIXED_DIV ((float)(y_2 - y_1),
COGL_FIXED_FROM_INT (tex_height)); (float)(tex_height));
else else
t_h = COGL_FIXED_1; t_h = 1.0;
/* Parent paint translated us into position */ /* Parent paint translated us into position */
cogl_texture_rectangle (cogl_texture, 0, 0, cogl_texture_rectangle (cogl_texture, 0, 0,
COGL_FIXED_FROM_INT (x_2 - x_1), (float)(x_2 - x_1),
COGL_FIXED_FROM_INT (y_2 - y_1), (float)(y_2 - y_1),
0, 0, t_w, t_h); 0, 0, t_w, t_h);
} }

152
clutter/clutter-color.c
View File

@ -154,9 +154,9 @@ clutter_color_to_hlsx (const ClutterColor *src,
g_return_if_fail (src != NULL); g_return_if_fail (src != NULL);
red = COGL_FIXED_FROM_INT (src->red) / 255; red = (float)(src->red) / 255;
green = COGL_FIXED_FROM_INT (src->green) / 255; green = (float)(src->green) / 255;
blue = COGL_FIXED_FROM_INT (src->blue) / 255; blue = (float)(src->blue) / 255;
if (red > green) if (red > green)
{ {
@ -189,31 +189,31 @@ clutter_color_to_hlsx (const ClutterColor *src,
if (max != min) if (max != min)
{ {
if (l <= COGL_FIXED_0_5) if (l <= 0.5)
s = COGL_FIXED_FAST_DIV ((max - min), (max + min)); s = CLUTTER_FIXED_DIV ((max - min), (max + min));
else else
s = COGL_FIXED_FAST_DIV ((max - min), s = CLUTTER_FIXED_DIV ((max - min),
(COGL_FIXED_FROM_INT (2) - max - min)); ((float)(2) - max - min));
delta = max - min; delta = max - min;
if (red == max) if (red == max)
h = COGL_FIXED_FAST_DIV ((green - blue), delta); h = CLUTTER_FIXED_DIV ((green - blue), delta);
else if (green == max) else if (green == max)
{ {
h = COGL_FIXED_FROM_INT (2) h = (float)(2)
+ COGL_FIXED_FAST_DIV ((blue - red), delta); + CLUTTER_FIXED_DIV ((blue - red), delta);
} }
else if (blue == max) else if (blue == max)
{ {
h = COGL_FIXED_FROM_INT (4) h = (float)(4)
+ COGL_FIXED_FAST_DIV ((red - green), delta); + CLUTTER_FIXED_DIV ((red - green), delta);
} }
h *= 60; h *= 60;
if (h < 0) if (h < 0)
h += COGL_FIXED_360; h += 360.0;
} }
if (hue) if (hue)
@ -251,102 +251,102 @@ clutter_color_from_hlsx (ClutterColor *dest,
l = luminance; l = luminance;
s = saturation; s = saturation;
if (l <= COGL_FIXED_0_5) if (l <= 0.5)
m2 = COGL_FIXED_FAST_MUL (l, (COGL_FIXED_1 + s)); m2 = CLUTTER_FIXED_MUL (l, (1.0 + s));
else else
m2 = l + s - COGL_FIXED_FAST_MUL (l, s); m2 = l + s - CLUTTER_FIXED_MUL (l, s);
m1 = 2 * l - m2; m1 = 2 * l - m2;
if (s == 0) if (s == 0)
{ {
dest->red = (guint8) COGL_FIXED_TO_INT (l * 255); dest->red = (guint8) (l * 255);
dest->green = (guint8) COGL_FIXED_TO_INT (l * 255); dest->green = (guint8) (l * 255);
dest->blue = (guint8) COGL_FIXED_TO_INT (l * 255); dest->blue = (guint8) (l * 255);
} }
else else
{ {
h = hue + COGL_FIXED_120; h = hue + 120.0;
while (h > COGL_FIXED_360) while (h > 360.0)
h -= COGL_FIXED_360; h -= 360.0;
while (h < 0) while (h < 0)
h += COGL_FIXED_360; h += 360.0;
if (h < COGL_FIXED_60) if (h < 60.0)
{ {
CoglFixed tmp; float tmp;
tmp = (m1 + COGL_FIXED_FAST_MUL ((m2 - m1), h) / 60); tmp = (m1 + CLUTTER_FIXED_MUL ((m2 - m1), h) / 60);
dest->red = (guint8) COGL_FIXED_TO_INT (tmp * 255); dest->red = (guint8) (tmp * 255);
} }
else if (h < COGL_FIXED_180) else if (h < 180.0)
dest->red = (guint8) COGL_FIXED_TO_INT (m2 * 255); dest->red = (guint8) (m2 * 255);
else if (h < COGL_FIXED_240) else if (h < 240.0)
{ {
CoglFixed tmp; float tmp;
tmp = (m1 + COGL_FIXED_FAST_MUL ((m2 - m1), (COGL_FIXED_240 - h))) tmp = (m1 + CLUTTER_FIXED_MUL ((m2 - m1), (240.0 - h)))
/ 60; / 60;
dest->red = (guint8) COGL_FIXED_TO_INT (tmp * 255); dest->red = (guint8) (tmp * 255);
} }
else else
dest->red = (guint8) COGL_FIXED_TO_INT (m1 * 255); dest->red = (guint8) (m1 * 255);
h = hue; h = hue;
while (h > COGL_FIXED_360) while (h > 360.0)
h -= COGL_FIXED_360; h -= 360.0;
while (h < 0) while (h < 0)
h += COGL_FIXED_360; h += 360.0;
if (h < COGL_FIXED_60) if (h < 60.0)
{ {
CoglFixed tmp; float tmp;
tmp = (m1 + COGL_FIXED_FAST_MUL ((m2 - m1), h) / 60); tmp = (m1 + CLUTTER_FIXED_MUL ((m2 - m1), h) / 60);
dest->green = (guint8) COGL_FIXED_TO_INT (tmp * 255); dest->green = (guint8) (tmp * 255);
} }
else if (h < COGL_FIXED_180) else if (h < 180.0)
dest->green = (guint8) COGL_FIXED_TO_INT (m2 * 255); dest->green = (guint8) (m2 * 255);
else if (h < COGL_FIXED_240) else if (h < 240.0)
{ {
CoglFixed tmp; float tmp;
tmp = (m1 + COGL_FIXED_FAST_MUL ((m2 - m1) , (COGL_FIXED_240 - h))) tmp = (m1 + CLUTTER_FIXED_MUL ((m2 - m1) , (240.0 - h)))
/ 60; / 60;
dest->green = (guint8) COGL_FIXED_TO_INT (tmp * 255); dest->green = (guint8) (tmp * 255);
} }
else else
dest->green = (guint8) COGL_FIXED_TO_INT (m1 * 255); dest->green = (guint8) (m1 * 255);
h = hue - COGL_FIXED_120; h = hue - 120.0;
while (h > COGL_FIXED_360) while (h > 360.0)
h -= COGL_FIXED_360; h -= 360.0;
while (h < 0) while (h < 0)
h += COGL_FIXED_360; h += 360.0;
if (h < COGL_FIXED_60) if (h < 60.0)
{ {
CoglFixed tmp; float tmp;
tmp = (m1 + COGL_FIXED_FAST_MUL ((m2 - m1), h) / 60); tmp = (m1 + CLUTTER_FIXED_MUL ((m2 - m1), h) / 60);
dest->blue = (guint8) COGL_FIXED_TO_INT (tmp * 255); dest->blue = (guint8) (tmp * 255);
} }
else if (h < COGL_FIXED_180) else if (h < 180.0)
dest->blue = (guint8) COGL_FIXED_TO_INT (m2 * 255); dest->blue = (guint8) (m2 * 255);
else if (h < COGL_FIXED_240) else if (h < 240.0)
{ {
CoglFixed tmp; float tmp;
tmp = (m1 + COGL_FIXED_FAST_MUL ((m2 - m1), (COGL_FIXED_240 - h))) tmp = (m1 + CLUTTER_FIXED_MUL ((m2 - m1), (240.0 - h)))
/ 60; / 60;
dest->blue = (guint8) COGL_FIXED_TO_INT (tmp * 255); dest->blue = (guint8) (tmp * 255);
} }
else else
dest->blue = (guint8) COGL_FIXED_TO_INT (m1 * 255); dest->blue = (guint8) (m1 * 255);
} }
} }
@ -371,13 +371,13 @@ clutter_color_to_hls (const ClutterColor *src,
clutter_color_to_hlsx (src, &h, &l, &s); clutter_color_to_hlsx (src, &h, &l, &s);
if (hue) if (hue)
*hue = (guint8) COGL_FIXED_TO_INT (h * 255) / 360; *hue = (guint8) (h * 255) / 360;
if (luminance) if (luminance)
*luminance = (guint8) COGL_FIXED_TO_INT (l * 255); *luminance = (guint8) (l * 255);
if (saturation) if (saturation)
*saturation = (guint8) COGL_FIXED_TO_INT (s * 255); *saturation = (guint8) (s * 255);
} }
/** /**
@ -399,9 +399,9 @@ clutter_color_from_hls (ClutterColor *dest,
{ {
ClutterFixed h, l, s; ClutterFixed h, l, s;
h = COGL_FIXED_FROM_INT (hue * 360) / 255; h = (float)(hue * 360) / 255;
l = COGL_FIXED_FROM_INT (luminance) / 255; l = (float)(luminance) / 255;
s = COGL_FIXED_FROM_INT (saturation) / 255; s = (float)(saturation) / 255;
clutter_color_from_hlsx (dest, h, l, s); clutter_color_from_hlsx (dest, h, l, s);
} }
@ -420,7 +420,7 @@ clutter_color_shade (const ClutterColor *src,
ClutterColor *dest, ClutterColor *dest,
gdouble shade) gdouble shade)
{ {
clutter_color_shadex (src, dest, COGL_FIXED_FROM_FLOAT (shade)); clutter_color_shadex (src, dest, CLUTTER_FLOAT_TO_FIXED (shade));
} }
/** /**
@ -448,15 +448,15 @@ clutter_color_shadex (const ClutterColor *src,
clutter_color_to_hlsx (src, &h, &l, &s); clutter_color_to_hlsx (src, &h, &l, &s);
l = COGL_FIXED_FAST_MUL (l, shade); l = CLUTTER_FIXED_MUL (l, shade);
if (l > COGL_FIXED_1) if (l > 1.0)
l = COGL_FIXED_1; l = 1.0;
else if (l < 0) else if (l < 0)
l = 0; l = 0;
s = COGL_FIXED_FAST_MUL (s, shade); s = CLUTTER_FIXED_MUL (s, shade);
if (s > COGL_FIXED_1) if (s > 1.0)
s = COGL_FIXED_1; s = 1.0;
else if (s < 0) else if (s < 0)
s = 0; s = 0;

20
clutter/clutter-fixed.c
View File

@ -130,42 +130,42 @@ static void
clutter_value_transform_fixed_int (const GValue *src, clutter_value_transform_fixed_int (const GValue *src,
GValue *dest) GValue *dest)
{ {
dest->data[0].v_int = COGL_FIXED_TO_INT (src->data[0].v_int); dest->data[0].v_int = (src->data[0].v_int);
} }
static void static void
clutter_value_transform_fixed_double (const GValue *src, clutter_value_transform_fixed_double (const GValue *src,
GValue *dest) GValue *dest)
{ {
dest->data[0].v_double = COGL_FIXED_TO_DOUBLE (src->data[0].v_int); dest->data[0].v_double = CLUTTER_FIXED_TO_DOUBLE (src->data[0].v_int);
} }
static void static void
clutter_value_transform_fixed_float (const GValue *src, clutter_value_transform_fixed_float (const GValue *src,
GValue *dest) GValue *dest)
{ {
dest->data[0].v_float = COGL_FIXED_TO_FLOAT (src->data[0].v_int); dest->data[0].v_float = CLUTTER_FIXED_TO_FLOAT (src->data[0].v_int);
} }
static void static void
clutter_value_transform_int_fixed (const GValue *src, clutter_value_transform_int_fixed (const GValue *src,
GValue *dest) GValue *dest)
{ {
dest->data[0].v_int = COGL_FIXED_FROM_INT (src->data[0].v_int); dest->data[0].v_int = (float)(src->data[0].v_int);
} }
static void static void
clutter_value_transform_double_fixed (const GValue *src, clutter_value_transform_double_fixed (const GValue *src,
GValue *dest) GValue *dest)
{ {
dest->data[0].v_int = COGL_FIXED_FROM_FLOAT (src->data[0].v_double); dest->data[0].v_int = CLUTTER_FLOAT_TO_FIXED (src->data[0].v_double);
} }
static void static void
clutter_value_transform_float_fixed (const GValue *src, clutter_value_transform_float_fixed (const GValue *src,
GValue *dest) GValue *dest)
{ {
dest->data[0].v_int = COGL_FIXED_FROM_FLOAT (src->data[0].v_float); dest->data[0].v_int = CLUTTER_FLOAT_TO_FIXED (src->data[0].v_float);
} }
@ -251,8 +251,8 @@ param_fixed_init (GParamSpec *pspec)
{ {
ClutterParamSpecFixed *fspec = CLUTTER_PARAM_SPEC_FIXED (pspec); ClutterParamSpecFixed *fspec = CLUTTER_PARAM_SPEC_FIXED (pspec);
fspec->minimum = COGL_FIXED_MIN; fspec->minimum = CLUTTER_MAXFIXED;
fspec->maximum = COGL_FIXED_MAX; fspec->maximum = CLUTTER_MINFIXED;
fspec->default_value = 0; fspec->default_value = 0;
} }
@ -268,7 +268,7 @@ param_fixed_validate (GParamSpec *pspec,
GValue *value) GValue *value)
{ {
ClutterParamSpecFixed *fspec = CLUTTER_PARAM_SPEC_FIXED (pspec); ClutterParamSpecFixed *fspec = CLUTTER_PARAM_SPEC_FIXED (pspec);
gint oval = COGL_FIXED_TO_INT (value->data[0].v_int); gint oval = (value->data[0].v_int);
gint min, max, val; gint min, max, val;
g_assert (CLUTTER_IS_PARAM_SPEC_FIXED (pspec)); g_assert (CLUTTER_IS_PARAM_SPEC_FIXED (pspec));
@ -279,7 +279,7 @@ param_fixed_validate (GParamSpec *pspec,
min = fspec->minimum; min = fspec->minimum;
max = fspec->maximum; max = fspec->maximum;
val = COGL_FIXED_TO_INT (value->data[0].v_int); val = (value->data[0].v_int);
val = CLAMP (val, min, max); val = CLAMP (val, min, max);
if (val != oval) if (val != oval)

132
clutter/clutter-fixed.h
View File

@ -39,126 +39,118 @@ G_BEGIN_DECLS
* *
* Fixed point number (16.16) * Fixed point number (16.16)
*/ */
typedef CoglFixed ClutterFixed; typedef float ClutterFixed;
/** /**
* ClutterAngle: * ClutterAngle:
* *
* Integer representation of an angle such that 1024 corresponds to * An abstract representation of an angle.
* full circle (i.e., 2*Pi).
*/ */
typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */ typedef float ClutterAngle;
#define CLUTTER_ANGLE_FROM_DEG(x) (COGL_ANGLE_FROM_DEG (x)) #define CLUTTER_ANGLE_FROM_DEG(x) ((float)(x))
#define CLUTTER_ANGLE_FROM_DEGX(x) (COGL_ANGLE_FROM_DEGX (x)) #define CLUTTER_ANGLE_FROM_DEGX(x) (CLUTTER_FIXED_TO_FLOAT (x))
#define CLUTTER_ANGLE_TO_DEG(x) (COGL_ANGLE_TO_DEG (x)) #define CLUTTER_ANGLE_TO_DEG(x) ((float)(x))
#define CLUTTER_ANGLE_TO_DEGX(x) (COGL_ANGLE_TO_DEGX (x)) #define CLUTTER_ANGLE_TO_DEGX(x) (CLUTTER_FLOAT_TO_FIXED (x))
/* /*
* some commonly used constants * some commonly used constants
*/ */
/**
* CFX_Q:
*
* Size in bits of decimal part of floating point value.
*/
#define CFX_Q COGL_FIXED_Q
/** /**
* CFX_ONE: * CFX_ONE:
* *
* 1.0 represented as a fixed point value. * 1.0 represented as a fixed point value.
*/ */
#define CFX_ONE COGL_FIXED_1 #define CFX_ONE 1.0
/** /**
* CFX_HALF: * CFX_HALF:
* *
* 0.5 represented as a fixed point value. * 0.5 represented as a fixed point value.
*/ */
#define CFX_HALF COGL_FIXED_0_5 #define CFX_HALF 0.5
/** /**
* CFX_MAX: * CFX_MAX:
* *
* Maximum fixed point value. * Maximum fixed point value.
*/ */
#define CFX_MAX COGL_FIXED_MAX #define CFX_MAX G_MAXFLOAT
/** /**
* CFX_MIN: * CFX_MIN:
* *
* Minimum fixed point value. * Minimum fixed point value.
*/ */
#define CFX_MIN COGL_FIXED_MIN #define CFX_MIN (-G_MAXFLOAT)
/** /**
* CFX_PI: * CFX_PI:
* *
* Fixed point representation of Pi * Fixed point representation of Pi
*/ */
#define CFX_PI COGL_FIXED_PI #define CFX_PI G_PI
/** /**
* CFX_2PI: * CFX_2PI:
* *
* Fixed point representation of Pi*2 * Fixed point representation of Pi*2
*/ */
#define CFX_2PI COGL_FIXED_2_PI #define CFX_2PI (G_PI * 2)
/** /**
* CFX_PI_2: * CFX_PI_2:
* *
* Fixed point representation of Pi/2 * Fixed point representation of Pi/2
*/ */
#define CFX_PI_2 COGL_FIXED_PI_2 #define CFX_PI_2 (G_PI / 2)
/** /**
* CFX_PI_4: * CFX_PI_4:
* *
* Fixed point representation of Pi/4 * Fixed point representation of Pi/4
*/ */
#define CFX_PI_4 COGL_FIXED_PI_4 #define CFX_PI_4 (G_PI / 4)
/** /**
* CFX_360: * CFX_360:
* *
* Fixed point representation of the number 360 * Fixed point representation of the number 360
*/ */
#define CFX_360 COGL_FIXED_360 #define CFX_360 360.0
/** /**
* CFX_240: * CFX_240:
* *
* Fixed point representation of the number 240 * Fixed point representation of the number 240
*/ */
#define CFX_240 COGL_FIXED_240 #define CFX_240 240.0
/** /**
* CFX_180: * CFX_180:
* *
* Fixed point representation of the number 180 * Fixed point representation of the number 180
*/ */
#define CFX_180 COGL_FIXED_180 #define CFX_180 180.0
/** /**
* CFX_120: * CFX_120:
* *
* Fixed point representation of the number 120 * Fixed point representation of the number 120
*/ */
#define CFX_120 COGL_FIXED_120 #define CFX_120 120.0
/** /**
* CFX_60: * CFX_60:
* *
* Fixed point representation of the number 60 * Fixed point representation of the number 60
*/ */
#define CFX_60 COGL_FIXED_60 #define CFX_60 60.0
/** /**
* CFX_RADIANS_TO_DEGREES: * CFX_RADIANS_TO_DEGREES:
* *
* Fixed point representation of the number 180 / pi * Fixed point representation of the number 180 / pi
*/ */
#define CFX_RADIANS_TO_DEGREES COGL_RADIANS_TO_DEGREES #define CFX_RADIANS_TO_DEGREES (180.0 / G_PI)
/** /**
* CFX_255: * CFX_255:
* *
* Fixed point representation of the number 255 * Fixed point representation of the number 255
*/ */
#define CFX_255 COGL_FIXED_255 #define CFX_255 255.0
/** /**
* CLUTTER_FIXED_TO_FLOAT: * CLUTTER_FIXED_TO_FLOAT:
@ -166,7 +158,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
* *
* Convert a fixed point value to float. * Convert a fixed point value to float.
*/ */
#define CLUTTER_FIXED_TO_FLOAT(x) COGL_FIXED_TO_FLOAT ((x)) #define CLUTTER_FIXED_TO_FLOAT(x) (x)
/** /**
* CLUTTER_FIXED_TO_DOUBLE: * CLUTTER_FIXED_TO_DOUBLE:
@ -174,7 +166,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
* *
* Convert a fixed point value to double. * Convert a fixed point value to double.
*/ */
#define CLUTTER_FIXED_TO_DOUBLE(x) COGL_FIXED_TO_DOUBLE ((x)) #define CLUTTER_FIXED_TO_DOUBLE(x) ((double)(x))
/** /**
* CLUTTER_FLOAT_TO_FIXED: * CLUTTER_FLOAT_TO_FIXED:
@ -182,7 +174,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
* *
* Convert a float value to fixed. * Convert a float value to fixed.
*/ */
#define CLUTTER_FLOAT_TO_FIXED(x) COGL_FIXED_FROM_FLOAT ((x)) #define CLUTTER_FLOAT_TO_FIXED(x) ((x))
/** /**
* CLUTTER_FLOAT_TO_INT: * CLUTTER_FLOAT_TO_INT:
@ -190,7 +182,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
* *
* Convert a float value to int. * Convert a float value to int.
*/ */
#define CLUTTER_FLOAT_TO_INT(x) COGL_FLOAT_TO_INT ((x)) #define CLUTTER_FLOAT_TO_INT(x) ((int)(x))
/** /**
* CLUTTER_FLOAT_TO_UINT: * CLUTTER_FLOAT_TO_UINT:
@ -198,7 +190,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
* *
* Convert a float value to unsigned int. * Convert a float value to unsigned int.
*/ */
#define CLUTTER_FLOAT_TO_UINT(x) COGL_FLOAT_TO_UINT ((x)) #define CLUTTER_FLOAT_TO_UINT(x) ((unsigned int)(x))
/** /**
* CLUTTER_INT_TO_FIXED: * CLUTTER_INT_TO_FIXED:
@ -206,7 +198,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
* *
* Convert an integer value to fixed point. * Convert an integer value to fixed point.
*/ */
#define CLUTTER_INT_TO_FIXED(x) COGL_FIXED_FROM_INT ((x)) #define CLUTTER_INT_TO_FIXED(x) ((float)(x))
/** /**
* CLUTTER_FIXED_TO_INT: * CLUTTER_FIXED_TO_INT:
@ -216,7 +208,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
* *
* Since: 0.6 * Since: 0.6
*/ */
#define CLUTTER_FIXED_TO_INT(x) COGL_FIXED_TO_INT ((x)) #define CLUTTER_FIXED_TO_INT(x) ((int)(x))
/** /**
* CLUTTER_FIXED_FRACTION: * CLUTTER_FIXED_FRACTION:
@ -224,7 +216,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
* *
* Retrieves the fractionary part of a fixed point value * Retrieves the fractionary part of a fixed point value
*/ */
#define CLUTTER_FIXED_FRACTION(x) COGL_FIXED_FRACTION ((x)) #define CLUTTER_FIXED_FRACTION(x) ((x)-floorf (x))
/** /**
* CLUTTER_FIXED_FLOOR: * CLUTTER_FIXED_FLOOR:
@ -232,7 +224,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
* *
* Round down a fixed point value to an integer. * Round down a fixed point value to an integer.
*/ */
#define CLUTTER_FIXED_FLOOR(x) COGL_FIXED_FLOOR ((x)) #define CLUTTER_FIXED_FLOOR(x) (floorf (x))
/** /**
* CLUTTER_FIXED_CEIL: * CLUTTER_FIXED_CEIL:
@ -240,7 +232,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
* *
* Round up a fixed point value to an integer. * Round up a fixed point value to an integer.
*/ */
#define CLUTTER_FIXED_CEIL(x) COGL_FIXED_CEIL ((x)) #define CLUTTER_FIXED_CEIL(x) (ceilf (x))
/** /**
* CLUTTER_FIXED_MUL: * CLUTTER_FIXED_MUL:
@ -249,7 +241,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
* *
* Multiply two fixed point values * Multiply two fixed point values
*/ */
#define CLUTTER_FIXED_MUL(x,y) COGL_FIXED_MUL ((x), (y)) #define CLUTTER_FIXED_MUL(x,y) ((x) * (y))
/** /**
* CLUTTER_FIXED_DIV: * CLUTTER_FIXED_DIV:
@ -258,54 +250,16 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
* *
* Divide two fixed point values * Divide two fixed point values
*/ */
#define CLUTTER_FIXED_DIV(x,y) COGL_FIXED_DIV ((x), (y)) #define CLUTTER_FIXED_DIV(x,y) ((x) / (y))
#define clutter_qmulx(x,y) cogl_fixed_mul ((x), (y)) #define clutter_qmulx(x,y) ((x) * (y))
#define clutter_qdivx(x,y) cogl_fixed_div ((x), (y)) #define clutter_qdivx(x,y) ((x) / (y))
#define clutter_sinx(a) cogl_fixed_sin ((a)) #define clutter_sinx(a) sinf (a * (G_PI/180.0))
#define clutter_sini(a) cogl_angle_sin ((a)) #define clutter_tanx(a) tanf (a * (G_PI/180.0))
#define clutter_tani(a) cogl_angle_tan ((a)) #define clutter_atanx(a) atanf (a * (G_PI/180.0))
#define clutter_atani(a) cogl_fixed_atan ((a)) #define clutter_atan2x(x,y) atan2f (x, y)
#define clutter_atan2i(x,y) cogl_fixed_atan2 ((x), (y)) #define clutter_cosx(a) cosf (a * (G_PI/180.0))
#define clutter_cosx(a) cogl_fixed_cos ((a))
#define clutter_cosi(a) cogl_angle_cos ((a))
/**
* CLUTTER_SQRTI_ARG_MAX
*
* Maximum argument that can be passed to #clutter_sqrti function.
*
* Since: 0.6
*/
#define CLUTTER_SQRTI_ARG_MAX COGL_SQRTI_ARG_MAX
/**
* CLUTTER_SQRTI_ARG_5_PERCENT
*
* Maximum argument that can be passed to #clutter_sqrti for which the
* resulting error is < 5%
*
* Since: 0.6
*/
#define CLUTTER_SQRTI_ARG_5_PERCENT COGL_SQRTI_ARG_5_PERCENT
/**
* CLUTTER_SQRTI_ARG_10_PERCENT
*
* Maximum argument that can be passed to #clutter_sqrti for which the
* resulting error is < 10%
*
* Since: 0.6
*/
#define CLUTTER_SQRTI_ARG_10_PERCENT COGL_SQRTI_ARG_10_PERCENT
#define clutter_sqrtx(x) cogl_fixed_sqrt ((x))
#define clutter_sqrti(x) cogl_sqrti ((x))
#define clutter_log2x(x) cogl_fixed_log2 ((x))
#define clutter_pow2x(x) cogl_fixed_pow2 ((x))
#define clutter_powx(x,y) cogl_fixed_pow ((x), (y))
#define CLUTTER_TYPE_FIXED (clutter_fixed_get_type ()) #define CLUTTER_TYPE_FIXED (clutter_fixed_get_type ())
#define CLUTTER_TYPE_PARAM_FIXED (clutter_param_fixed_get_type ()) #define CLUTTER_TYPE_PARAM_FIXED (clutter_param_fixed_get_type ())
@ -331,7 +285,7 @@ typedef struct _ClutterParamSpecFixed ClutterParamSpecFixed;
* *
* Since: 0.8 * Since: 0.8
*/ */
#define CLUTTER_MAXFIXED COGL_FIXED_MAX #define CLUTTER_MAXFIXED G_MAXFLOAT
/** /**
* CLUTTER_MINFIXED: * CLUTTER_MINFIXED:
@ -340,7 +294,7 @@ typedef struct _ClutterParamSpecFixed ClutterParamSpecFixed;
* *
* Since: 0.8 * Since: 0.8
*/ */
#define CLUTTER_MINFIXED COGL_FIXED_MIN #define CLUTTER_MINFIXED (-G_MAXFLOAT)
/** /**
* ClutterParamSpecFixed * ClutterParamSpecFixed

2
clutter/clutter-interval.c
View File

@ -280,7 +280,7 @@ clutter_interval_real_compute_value (ClutterInterval *interval,
break; break;
case G_TYPE_BOOLEAN: case G_TYPE_BOOLEAN:
if (COGL_FIXED_FROM_FLOAT (factor) > COGL_FIXED_0_5) if (CLUTTER_FLOAT_TO_FIXED (factor) > 0.5)
g_value_set_boolean (value, TRUE); g_value_set_boolean (value, TRUE);
else else
g_value_set_boolean (value, FALSE); g_value_set_boolean (value, FALSE);

4
clutter/clutter-path.c
View File

@ -1217,11 +1217,11 @@ clutter_path_node_distance (const ClutterKnot *start,
* If we are using limited precision sqrti implementation, fallback on * If we are using limited precision sqrti implementation, fallback on
* clib sqrt if the precission would be less than 10% * clib sqrt if the precission would be less than 10%
*/ */
#if INT_MAX > CLUTTER_SQRTI_ARG_10_PERCENT #if INT_MAX > COGL_SQRTI_ARG_10_PERCENT
if (t <= COGL_SQRTI_ARG_10_PERCENT) if (t <= COGL_SQRTI_ARG_10_PERCENT)
return cogl_sqrti (t); return cogl_sqrti (t);
else else
return COGL_FLOAT_TO_INT (sqrt(t)); return COGL_FLOAT_TO_INT (sqrtf(t));
#else #else
return cogl_sqrti (t); return cogl_sqrti (t);
#endif #endif

44
clutter/clutter-stage.c
View File

@ -815,15 +815,15 @@ clutter_stage_init (ClutterStage *self)
priv->color = default_stage_color; priv->color = default_stage_color;
priv->perspective.fovy = COGL_FIXED_60; /* 60 Degrees */ priv->perspective.fovy = 60.0; /* 60 Degrees */
priv->perspective.aspect = COGL_FIXED_1; priv->perspective.aspect = 1.0;
priv->perspective.z_near = COGL_FIXED_FROM_FLOAT (0.1); priv->perspective.z_near = CLUTTER_FLOAT_TO_FIXED (0.1);
priv->perspective.z_far = COGL_FIXED_FROM_FLOAT (100.0); priv->perspective.z_far = CLUTTER_FLOAT_TO_FIXED (100.0);
/* depth cueing */ /* depth cueing */
priv->fog.density = COGL_FIXED_FROM_FLOAT (0.1); priv->fog.density = CLUTTER_FLOAT_TO_FIXED (0.1);
priv->fog.z_near = COGL_FIXED_FROM_FLOAT (1.0); priv->fog.z_near = CLUTTER_FLOAT_TO_FIXED (1.0);
priv->fog.z_far = COGL_FIXED_FROM_FLOAT (2.0); priv->fog.z_far = CLUTTER_FLOAT_TO_FIXED (2.0);
clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE); clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE);
clutter_stage_set_key_focus (self, NULL); clutter_stage_set_key_focus (self, NULL);
@ -979,10 +979,10 @@ clutter_stage_set_perspective (ClutterStage *stage,
priv = stage->priv; priv = stage->priv;
priv->perspective.fovy = COGL_FIXED_FROM_FLOAT (fovy); priv->perspective.fovy = CLUTTER_FLOAT_TO_FIXED (fovy);
priv->perspective.aspect = COGL_FIXED_FROM_FLOAT (aspect); priv->perspective.aspect = CLUTTER_FLOAT_TO_FIXED (aspect);
priv->perspective.z_near = COGL_FIXED_FROM_FLOAT (z_near); priv->perspective.z_near = CLUTTER_FLOAT_TO_FIXED (z_near);
priv->perspective.z_far = COGL_FIXED_FROM_FLOAT (z_far); priv->perspective.z_far = CLUTTER_FLOAT_TO_FIXED (z_far);
/* this will cause the viewport to be reset; see /* this will cause the viewport to be reset; see
* clutter_maybe_setup_viewport() inside clutter-main.c * clutter_maybe_setup_viewport() inside clutter-main.c
@ -1018,16 +1018,16 @@ clutter_stage_get_perspective (ClutterStage *stage,
priv = stage->priv; priv = stage->priv;
if (fovy) if (fovy)
*fovy = COGL_FIXED_TO_FLOAT (priv->perspective.fovy); *fovy = CLUTTER_FIXED_TO_FLOAT (priv->perspective.fovy);
if (aspect) if (aspect)
*aspect = COGL_FIXED_TO_FLOAT (priv->perspective.aspect); *aspect = CLUTTER_FIXED_TO_FLOAT (priv->perspective.aspect);
if (z_near) if (z_near)
*z_near = COGL_FIXED_TO_FLOAT (priv->perspective.z_near); *z_near = CLUTTER_FIXED_TO_FLOAT (priv->perspective.z_near);
if (z_far) if (z_far)
*z_far = COGL_FIXED_TO_FLOAT (priv->perspective.z_far); *z_far = CLUTTER_FIXED_TO_FLOAT (priv->perspective.z_far);
} }
/** /**
@ -1627,11 +1627,11 @@ clutter_stage_get_fog (ClutterStage *stage,
priv = stage->priv; priv = stage->priv;
if (density) if (density)
*density = COGL_FIXED_TO_FLOAT (priv->fog.density); *density = CLUTTER_FIXED_TO_FLOAT (priv->fog.density);
if (z_near) if (z_near)
*z_near = COGL_FIXED_TO_FLOAT (priv->fog.z_near); *z_near = CLUTTER_FIXED_TO_FLOAT (priv->fog.z_near);
if (z_far) if (z_far)
*z_far = COGL_FIXED_TO_FLOAT (priv->fog.z_far); *z_far = CLUTTER_FIXED_TO_FLOAT (priv->fog.z_far);
} }
/** /**
@ -1663,9 +1663,9 @@ clutter_stage_set_fog (ClutterStage *stage,
priv = stage->priv; priv = stage->priv;
priv->fog.density = COGL_FIXED_FROM_FLOAT (density); priv->fog.density = CLUTTER_FLOAT_TO_FIXED (density);
priv->fog.z_near = COGL_FIXED_FROM_FLOAT (z_near); priv->fog.z_near = CLUTTER_FLOAT_TO_FIXED (z_near);
priv->fog.z_far = COGL_FIXED_FROM_FLOAT (z_far); priv->fog.z_far = CLUTTER_FLOAT_TO_FIXED (z_far);
if (priv->use_fog && CLUTTER_ACTOR_IS_VISIBLE (stage)) if (priv->use_fog && CLUTTER_ACTOR_IS_VISIBLE (stage))
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage)); clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
@ -1761,7 +1761,7 @@ clutter_stage_get_resolutionx (ClutterStage *stage)
res = clutter_backend_get_resolution (context->backend); res = clutter_backend_get_resolution (context->backend);
return COGL_FIXED_FROM_FLOAT (res); return CLUTTER_FLOAT_TO_FIXED (res);
} }
/*** Perspective boxed type ******/ /*** Perspective boxed type ******/

56
clutter/clutter-texture.c
View File

@ -343,13 +343,13 @@ clutter_texture_get_preferred_width (ClutterActor *self,
/* Set the natural width so as to preserve the aspect ratio */ /* Set the natural width so as to preserve the aspect ratio */
ClutterFixed ratio, height; ClutterFixed ratio, height;
ratio = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (priv->width), ratio = CLUTTER_FIXED_DIV ((float)(priv->width),
COGL_FIXED_FROM_INT (priv->height)); (float)(priv->height));
height = CLUTTER_UNITS_TO_FIXED (for_height); height = CLUTTER_UNITS_TO_FIXED (for_height);
*natural_width_p = *natural_width_p =
CLUTTER_UNITS_FROM_FIXED (COGL_FIXED_MUL (ratio, height)); CLUTTER_UNITS_FROM_FIXED (CLUTTER_FIXED_MUL (ratio, height));
} }
} }
} }
@ -388,13 +388,13 @@ clutter_texture_get_preferred_height (ClutterActor *self,
/* Set the natural height so as to preserve the aspect ratio */ /* Set the natural height so as to preserve the aspect ratio */
ClutterFixed ratio, width; ClutterFixed ratio, width;
ratio = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (priv->height), ratio = CLUTTER_FIXED_DIV ((float)(priv->height),
COGL_FIXED_FROM_INT (priv->width)); (float)(priv->width));
width = CLUTTER_UNITS_TO_FIXED (for_width); width = CLUTTER_UNITS_TO_FIXED (for_width);
*natural_height_p = *natural_height_p =
CLUTTER_UNITS_FROM_FIXED (COGL_FIXED_MUL (ratio, width)); CLUTTER_UNITS_FROM_FIXED (CLUTTER_FIXED_MUL (ratio, width));
} }
} }
} }
@ -463,24 +463,24 @@ clutter_texture_set_fbo_projection (ClutterActor *self)
/* Convert the coordinates back to [-1,1] range */ /* Convert the coordinates back to [-1,1] range */
cogl_get_viewport (viewport); cogl_get_viewport (viewport);
tx_min = COGL_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (x_min), viewport[2]) tx_min = CLUTTER_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (x_min), viewport[2])
* 2 - COGL_FIXED_1; * 2 - 1.0;
tx_max = COGL_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (x_max), viewport[2]) tx_max = CLUTTER_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (x_max), viewport[2])
* 2 - COGL_FIXED_1; * 2 - 1.0;
ty_min = COGL_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (y_min), viewport[3]) ty_min = CLUTTER_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (y_min), viewport[3])
* 2 - COGL_FIXED_1; * 2 - 1.0;
ty_max = COGL_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (y_max), viewport[3]) ty_max = CLUTTER_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (y_max), viewport[3])
* 2 - COGL_FIXED_1; * 2 - 1.0;
/* Set up a projection matrix so that the actor will be projected as /* Set up a projection matrix so that the actor will be projected as
if it was drawn at its original location */ if it was drawn at its original location */
tan_angle = cogl_angle_tan (COGL_ANGLE_FROM_DEGX (perspective.fovy / 2)); tan_angle = tanf ((perspective.fovy / 2) * (G_PI/180.0));
near_size = COGL_FIXED_MUL (perspective.z_near, tan_angle); near_size = CLUTTER_FIXED_MUL (perspective.z_near, tan_angle);
cogl_frustum (COGL_FIXED_MUL (tx_min, near_size), cogl_frustum (CLUTTER_FIXED_MUL (tx_min, near_size),
COGL_FIXED_MUL (tx_max, near_size), CLUTTER_FIXED_MUL (tx_max, near_size),
COGL_FIXED_MUL (-ty_min, near_size), CLUTTER_FIXED_MUL (-ty_min, near_size),
COGL_FIXED_MUL (-ty_max, near_size), CLUTTER_FIXED_MUL (-ty_max, near_size),
perspective.z_near, perspective.z_far); perspective.z_near, perspective.z_far);
} }
@ -594,21 +594,21 @@ clutter_texture_paint (ClutterActor *self)
clutter_actor_get_opacity (self)); clutter_actor_get_opacity (self));
if (priv->repeat_x && priv->width > 0) if (priv->repeat_x && priv->width > 0)
t_w = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (x_2 - x_1), t_w = CLUTTER_FIXED_DIV ((float)(x_2 - x_1),
COGL_FIXED_FROM_INT (priv->width)); (float)(priv->width));
else else
t_w = COGL_FIXED_1; t_w = 1.0;
if (priv->repeat_y && priv->height > 0) if (priv->repeat_y && priv->height > 0)
t_h = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (y_2 - y_1), t_h = CLUTTER_FIXED_DIV ((float)(y_2 - y_1),
COGL_FIXED_FROM_INT (priv->height)); (float)(priv->height));
else else
t_h = COGL_FIXED_1; t_h = 1.0;
/* Paint will have translated us */ /* Paint will have translated us */
cogl_texture_rectangle (priv->texture, 0, 0, cogl_texture_rectangle (priv->texture, 0, 0,
COGL_FIXED_FROM_INT (x_2 - x_1), (float)(x_2 - x_1),
COGL_FIXED_FROM_INT (y_2 - y_1), (float)(y_2 - y_1),
0, 0, t_w, t_h); 0, 0, t_w, t_h);
} }

8
clutter/clutter-timeline.c
View File

@ -1347,7 +1347,7 @@ clutter_timeline_get_progress (ClutterTimeline *timeline)
{ {
g_return_val_if_fail (CLUTTER_IS_TIMELINE (timeline), 0.); g_return_val_if_fail (CLUTTER_IS_TIMELINE (timeline), 0.);
return COGL_FIXED_TO_DOUBLE (clutter_timeline_get_progressx (timeline)); return CLUTTER_FIXED_TO_DOUBLE (clutter_timeline_get_progressx (timeline));
} }
/** /**
@ -1370,11 +1370,11 @@ clutter_timeline_get_progressx (ClutterTimeline *timeline)
priv = timeline->priv; priv = timeline->priv;
progress = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (priv->current_frame_num), progress = CLUTTER_FIXED_DIV ((float)(priv->current_frame_num),
COGL_FIXED_FROM_INT (priv->n_frames)); (float)(priv->n_frames));
if (priv->direction == CLUTTER_TIMELINE_BACKWARD) if (priv->direction == CLUTTER_TIMELINE_BACKWARD)
progress = COGL_FIXED_1 - progress; progress = 1.0 - progress;
return progress; return progress;
} }

26
clutter/clutter-units.h
View File

@ -42,7 +42,7 @@ G_BEGIN_DECLS
* *
* Since: 0.4 * Since: 0.4
*/ */
typedef gint32 ClutterUnit; typedef float ClutterUnit;
/* /*
* Currently CLUTTER_UNIT maps directly onto ClutterFixed. Nevertheless, the * Currently CLUTTER_UNIT maps directly onto ClutterFixed. Nevertheless, the
@ -50,16 +50,16 @@ typedef gint32 ClutterUnit;
* decide to change this relationship in the future. * decide to change this relationship in the future.
*/ */
#define CLUTTER_UNITS_FROM_INT(x) (COGL_FIXED_FROM_INT ((x))) #define CLUTTER_UNITS_FROM_INT(x) ((float)(x))
#define CLUTTER_UNITS_TO_INT(x) (COGL_FIXED_TO_INT ((x))) #define CLUTTER_UNITS_TO_INT(x) ((int)(x))
#define CLUTTER_UNITS_FROM_FLOAT(x) (COGL_FIXED_FROM_FLOAT ((x))) #define CLUTTER_UNITS_FROM_FLOAT(x) (x)
#define CLUTTER_UNITS_TO_FLOAT(x) (COGL_FIXED_TO_FLOAT ((x))) #define CLUTTER_UNITS_TO_FLOAT(x) (x)
#define CLUTTER_UNITS_FROM_FIXED(x) (x) #define CLUTTER_UNITS_FROM_FIXED(x) (x)
#define CLUTTER_UNITS_TO_FIXED(x) (x) #define CLUTTER_UNITS_TO_FIXED(x) (x)
#define CLUTTER_UNITS_FORMAT "d" #define CLUTTER_UNITS_FORMAT "f"
/** /**
* CLUTTER_UNITS_FROM_DEVICE: * CLUTTER_UNITS_FROM_DEVICE:
@ -92,7 +92,7 @@ typedef gint32 ClutterUnit;
* *
* Since: 0.6 * Since: 0.6
*/ */
#define CLUTTER_UNITS_FROM_PANGO_UNIT(x) ((x) << 6) #define CLUTTER_UNITS_FROM_PANGO_UNIT(x) ((float)(x / 1024))
/** /**
* CLUTTER_UNITS_TO_PANGO_UNIT: * CLUTTER_UNITS_TO_PANGO_UNIT:
@ -102,7 +102,7 @@ typedef gint32 ClutterUnit;
* *
* Since: 0.6 * Since: 0.6
*/ */
#define CLUTTER_UNITS_TO_PANGO_UNIT(x) ((x) >> 6) #define CLUTTER_UNITS_TO_PANGO_UNIT(x) ((int)(x * 1024))
#define CLUTTER_UNITS_FROM_STAGE_WIDTH_PERCENTAGE(x) \ #define CLUTTER_UNITS_FROM_STAGE_WIDTH_PERCENTAGE(x) \
((clutter_actor_get_widthu (clutter_stage_get_default ()) * x) / 100) ((clutter_actor_get_widthu (clutter_stage_get_default ()) * x) / 100)
@ -127,8 +127,7 @@ typedef gint32 ClutterUnit;
#define CLUTTER_UNITS_FROM_MM(x) \ #define CLUTTER_UNITS_FROM_MM(x) \
(CLUTTER_UNITS_FROM_FLOAT ((((x) * clutter_stage_get_resolution ((ClutterStage *) clutter_stage_get_default ())) / 25.4))) (CLUTTER_UNITS_FROM_FLOAT ((((x) * clutter_stage_get_resolution ((ClutterStage *) clutter_stage_get_default ())) / 25.4)))
#define CLUTTER_UNITS_FROM_MMX(x) \ #define CLUTTER_UNITS_FROM_MMX(x) CLUTTER_UNITS_FROM_MM
(CFX_DIV (CFX_MUL ((x), clutter_stage_get_resolutionx ((ClutterStage *) clutter_stage_get_default ())), 0x196666))
/** /**
* CLUTTER_UNITS_FROM_POINTS: * CLUTTER_UNITS_FROM_POINTS:
@ -141,9 +140,6 @@ typedef gint32 ClutterUnit;
#define CLUTTER_UNITS_FROM_POINTS(x) \ #define CLUTTER_UNITS_FROM_POINTS(x) \
CLUTTER_UNITS_FROM_FLOAT ((((x) * clutter_stage_get_resolution ((ClutterStage *) clutter_stage_get_default ())) / 72.0)) CLUTTER_UNITS_FROM_FLOAT ((((x) * clutter_stage_get_resolution ((ClutterStage *) clutter_stage_get_default ())) / 72.0))
#define CLUTTER_UNITS_FROM_POINTSX(x) \
(CFX_MUL ((x), clutter_stage_get_resolutionx ((ClutterStage *) clutter_stage_get_default ())) / 72)
#define CLUTTER_TYPE_UNIT (clutter_unit_get_type ()) #define CLUTTER_TYPE_UNIT (clutter_unit_get_type ())
#define CLUTTER_TYPE_PARAM_UNIT (clutter_param_unit_get_type ()) #define CLUTTER_TYPE_PARAM_UNIT (clutter_param_unit_get_type ())
#define CLUTTER_PARAM_SPEC_UNIT(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), CLUTTER_TYPE_PARAM_UNIT, ClutterParamSpecUnit)) #define CLUTTER_PARAM_SPEC_UNIT(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), CLUTTER_TYPE_PARAM_UNIT, ClutterParamSpecUnit))
@ -156,7 +152,7 @@ typedef gint32 ClutterUnit;
* *
* Since: 0.8 * Since: 0.8
*/ */
#define CLUTTER_MAXUNIT (0x7fffffff) #define CLUTTER_MAXUNIT (G_MAXFLOAT)
/** /**
* CLUTTER_MINUNIT: * CLUTTER_MINUNIT:
@ -165,7 +161,7 @@ typedef gint32 ClutterUnit;
* *
* Since: 0.8 * Since: 0.8
*/ */
#define CLUTTER_MINUNIT (0x80000000) #define CLUTTER_MINUNIT (-G_MAXFLOAT)
/** /**
* CLUTTER_VALUE_HOLDS_UNIT: * CLUTTER_VALUE_HOLDS_UNIT:

58
clutter/cogl/cogl-color.h
View File

@ -68,22 +68,22 @@ void cogl_color_set_from_4d (CoglColor *dest,
gdouble alpha); gdouble alpha);
/** /**
* cogl_color_set_from_4x: * cogl_color_set_from_4f:
* @dest: return location for a #CoglColor * @dest: return location for a #CoglColor
* @red: value of the red channel, between 0 and %COGL_FIXED_1 * @red: value of the red channel, between 0 and %1.0
* @green: value of the green channel, between 0 and %COGL_FIXED_1 * @green: value of the green channel, between 0 and %1.0
* @blue: value of the blue channel, between 0 and %COGL_FIXED_1 * @blue: value of the blue channel, between 0 and %1.0
* @alpha: value of the alpha channel, between 0 and %COGL_FIXED_1 * @alpha: value of the alpha channel, between 0 and %1.0
* *
* Sets the values of the passed channels into a #CoglColor * Sets the values of the passed channels into a #CoglColor
* *
* Since: 1.0 * Since: 1.0
*/ */
void cogl_color_set_from_4x (CoglColor *dest, void cogl_color_set_from_4f (CoglColor *dest,
CoglFixed red, float red,
CoglFixed green, float green,
CoglFixed blue, float blue,
CoglFixed alpha); float alpha);
/** /**
* cogl_color_get_red_byte: * cogl_color_get_red_byte:
@ -194,52 +194,52 @@ float cogl_color_get_alpha_float (const CoglColor *color);
* @color: a #CoglColor * @color: a #CoglColor
* *
* Retrieves the red channel of @color as a fixed point * Retrieves the red channel of @color as a fixed point
* value between 0 and %COGL_FIXED_1. * value between 0 and %1.0.
* *
* Return value: the red channel of the passed color * Return value: the red channel of the passed color
* *
* Since: 1.0 * Since: 1.0
*/ */
CoglFixed cogl_color_get_red (const CoglColor *color); float cogl_color_get_red (const CoglColor *color);
/** /**
* cogl_color_get_green: * cogl_color_get_green:
* @color: a #CoglColor * @color: a #CoglColor
* *
* Retrieves the green channel of @color as a fixed point * Retrieves the green channel of @color as a fixed point
* value between 0 and %COGL_FIXED_1. * value between 0 and %1.0.
* *
* Return value: the green channel of the passed color * Return value: the green channel of the passed color
* *
* Since: 1.0 * Since: 1.0
*/ */
CoglFixed cogl_color_get_green (const CoglColor *color); float cogl_color_get_green (const CoglColor *color);
/** /**
* cogl_color_get_blue: * cogl_color_get_blue:
* @color: a #CoglColor * @color: a #CoglColor
* *
* Retrieves the blue channel of @color as a fixed point * Retrieves the blue channel of @color as a fixed point
* value between 0 and %COGL_FIXED_1. * value between 0 and %1.0.
* *
* Return value: the blue channel of the passed color * Return value: the blue channel of the passed color
* *
* Since: 1.0 * Since: 1.0
*/ */
CoglFixed cogl_color_get_blue (const CoglColor *color); float cogl_color_get_blue (const CoglColor *color);
/** /**
* cogl_color_get_alpha: * cogl_color_get_alpha:
* @color: a #CoglColor * @color: a #CoglColor
* *
* Retrieves the alpha channel of @color as a fixed point * Retrieves the alpha channel of @color as a fixed point
* value between 0 and %COGL_FIXED_1. * value between 0 and %1.0.
* *
* Return value: the alpha channel of the passed color * Return value: the alpha channel of the passed color
* *
* Since: 1.0 * Since: 1.0
*/ */
CoglFixed cogl_color_get_alpha (const CoglColor *color); float cogl_color_get_alpha (const CoglColor *color);
/** /**
* cogl_set_source_color: * cogl_set_source_color:
@ -248,7 +248,7 @@ CoglFixed cogl_color_get_alpha (const CoglColor *color);
* Sets the source color using normalized values for each component. * Sets the source color using normalized values for each component.
* This color will be used for any subsequent drawing operation. * This color will be used for any subsequent drawing operation.
* *
* See also cogl_set_source_color4ub() and cogl_set_source_color4x() * See also cogl_set_source_color4ub() and cogl_set_source_color4f()
* if you already have the color components. * if you already have the color components.
* *
* Since: 1.0 * Since: 1.0
@ -276,25 +276,25 @@ void cogl_set_source_color4ub (guint8 red,
guint8 alpha); guint8 alpha);
/** /**
* cogl_set_source_color4x: * cogl_set_source_color4f:
* @red: value of the red channel, between 0 and %COGL_FIXED_1 * @red: value of the red channel, between 0 and %1.0
* @green: value of the green channel, between 0 and %COGL_FIXED_1 * @green: value of the green channel, between 0 and %1.0
* @blue: value of the blue channel, between 0 and %COGL_FIXED_1 * @blue: value of the blue channel, between 0 and %1.0
* @alpha: value of the alpha channel, between 0 and %COGL_FIXED_1 * @alpha: value of the alpha channel, between 0 and %1.0
* *
* Sets the source color using normalized values for each component. * Sets the source color using normalized values for each component.
* This color will be used for any subsequent drawing operation. * This color will be used for any subsequent drawing operation.
* *
* The value for each component is a fixed point number in the range * The value for each component is a fixed point number in the range
* between 0 and %COGL_FIXED_1. If the values passed in are outside that * between 0 and %1.0. If the values passed in are outside that
* range, they will be clamped. * range, they will be clamped.
* *
* Since: 1.0 * Since: 1.0
*/ */
void cogl_set_source_color4x (CoglFixed red, void cogl_set_source_color4f (float red,
CoglFixed green, float green,
CoglFixed blue, float blue,
CoglFixed alpha); float alpha);
G_END_DECLS G_END_DECLS

12
clutter/cogl/cogl-fixed.h
View File

@ -455,6 +455,18 @@ G_BEGIN_DECLS
*/ */
CoglFixed cogl_fixed_sin (CoglFixed angle); CoglFixed cogl_fixed_sin (CoglFixed angle);
/**
* cogl_fixed_tan:
* @angle: a #CoglFixed number
*
* Computes the tangent of @angle.
*
* Return value: the tangent of the passed angle, in fixed point notation
*
* Since: 1.0
*/
CoglFixed cogl_fixed_tan (CoglFixed angle);
/** /**
* cogl_fixed_cos: * cogl_fixed_cos:
* @angle: a #CoglFixed number * @angle: a #CoglFixed number

114
clutter/cogl/cogl-path.h
View File

@ -60,24 +60,10 @@ G_BEGIN_DECLS
* Fills a rectangle at the given coordinates with the current * Fills a rectangle at the given coordinates with the current
* drawing color in a highly optimizied fashion. * drawing color in a highly optimizied fashion.
**/ **/
void cogl_rectangle (gint x, void cogl_rectangle (float x,
gint y, float y,
guint width, float width,
guint height); float height);
/**
* cogl_rectanglex:
* @x: X coordinate of the top-left corner
* @y: Y coordinate of the top-left corner
* @width: Width of the rectangle
* @height: Height of the rectangle
*
* A fixed-point version of cogl_fast_fill_rectangle.
**/
void cogl_rectanglex (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height);
/** /**
* cogl_path_fill: * cogl_path_fill:
@ -136,8 +122,8 @@ void cogl_path_new (void);
* Moves the pen to the given location. If there is an existing path * Moves the pen to the given location. If there is an existing path
* this will start a new disjoint subpath. * this will start a new disjoint subpath.
**/ **/
void cogl_path_move_to (CoglFixed x, void cogl_path_move_to (float x,
CoglFixed y); float y);
/** /**
@ -149,8 +135,8 @@ void cogl_path_move_to (CoglFixed x,
* location. If there is an existing path this will start a new * location. If there is an existing path this will start a new
* disjoint subpath. * disjoint subpath.
**/ **/
void cogl_path_rel_move_to (CoglFixed x, void cogl_path_rel_move_to (float x,
CoglFixed y); float y);
/** /**
* cogl_path_line_to: * cogl_path_line_to:
@ -160,8 +146,8 @@ void cogl_path_rel_move_to (CoglFixed x,
* Adds a straight line segment to the current path that ends at the * Adds a straight line segment to the current path that ends at the
* given coordinates. * given coordinates.
**/ **/
void cogl_path_line_to (CoglFixed x, void cogl_path_line_to (float x,
CoglFixed y); float y);
/** /**
* cogl_path_rel_line_to: * cogl_path_rel_line_to:
@ -171,8 +157,8 @@ void cogl_path_line_to (CoglFixed x,
* Adds a straight line segment to the current path that ends at the * Adds a straight line segment to the current path that ends at the
* given coordinates relative to the current pen location. * given coordinates relative to the current pen location.
**/ **/
void cogl_path_rel_line_to (CoglFixed x, void cogl_path_rel_line_to (float x,
CoglFixed y); float y);
/** /**
@ -189,12 +175,12 @@ void cogl_path_rel_line_to (CoglFixed x,
* of the arc. If you perform a move_to to the arcs start just before * of the arc. If you perform a move_to to the arcs start just before
* drawing it you create a free standing arc. * drawing it you create a free standing arc.
**/ **/
void cogl_path_arc (CoglFixed center_x, void cogl_path_arc (float center_x,
CoglFixed center_y, float center_y,
CoglFixed radius_x, float radius_x,
CoglFixed radius_y, float radius_y,
CoglAngle angle_1, float angle_1,
CoglAngle angle_2); float angle_2);
@ -211,12 +197,12 @@ void cogl_path_arc (CoglFixed center_x,
* second, third and fourth control points and using current pen location * second, third and fourth control points and using current pen location
* as the first control point. * as the first control point.
**/ **/
void cogl_path_curve_to (CoglFixed x1, void cogl_path_curve_to (float x1,
CoglFixed y1, float y1,
CoglFixed x2, float x2,
CoglFixed y2, float y2,
CoglFixed x3, float x3,
CoglFixed y3); float y3);
/** /**
* cogl_path_rel_curve_to: * cogl_path_rel_curve_to:
@ -232,12 +218,12 @@ void cogl_path_curve_to (CoglFixed x1,
* as the first control point. The given coordinates are relative to the * as the first control point. The given coordinates are relative to the
* current pen location. * current pen location.
*/ */
void cogl_path_rel_curve_to (CoglFixed x1, void cogl_path_rel_curve_to (float x1,
CoglFixed y1, float y1,
CoglFixed x2, float x2,
CoglFixed y2, float y2,
CoglFixed x3, float x3,
CoglFixed y3); float y3);
/** /**
* cogl_path_close: * cogl_path_close:
@ -258,10 +244,10 @@ void cogl_path_close (void);
* coordinates. If there is an existing path this will start a new * coordinates. If there is an existing path this will start a new
* disjoint sub-path. * disjoint sub-path.
**/ **/
void cogl_path_line (CoglFixed x1, void cogl_path_line (float x1,
CoglFixed y1, float y1,
CoglFixed x2, float x2,
CoglFixed y2); float y2);
/** /**
* cogl_path_polyline: * cogl_path_polyline:
@ -281,7 +267,7 @@ void cogl_path_line (CoglFixed x1,
* fashion for the rest of the vertices. (num_points - 1) segments will * fashion for the rest of the vertices. (num_points - 1) segments will
* be constructed. * be constructed.
**/ **/
void cogl_path_polyline (CoglFixed *coords, void cogl_path_polyline (float *coords,
gint num_points); gint num_points);
@ -299,7 +285,7 @@ void cogl_path_polyline (CoglFixed *coords,
* represents the Y coordinate of the first vertex, continuing in the same * represents the Y coordinate of the first vertex, continuing in the same
* fashion for the rest of the vertices. * fashion for the rest of the vertices.
**/ **/
void cogl_path_polygon (CoglFixed *coords, void cogl_path_polygon (float *coords,
gint num_points); gint num_points);
@ -313,10 +299,10 @@ void cogl_path_polygon (CoglFixed *coords,
* Constructs a rectangular shape at the given coordinates. If there * Constructs a rectangular shape at the given coordinates. If there
* is an existing path this will start a new disjoint sub-path. * is an existing path this will start a new disjoint sub-path.
**/ **/
void cogl_path_rectangle (CoglFixed x, void cogl_path_rectangle (float x,
CoglFixed y, float y,
CoglFixed width, float width,
CoglFixed height); float height);
/** /**
* cogl_path_ellipse: * cogl_path_ellipse:
@ -328,10 +314,10 @@ void cogl_path_rectangle (CoglFixed x,
* Constructs an ellipse shape. If there is an existing path this will * Constructs an ellipse shape. If there is an existing path this will
* start a new disjoint sub-path. * start a new disjoint sub-path.
**/ **/
void cogl_path_ellipse (CoglFixed center_x, void cogl_path_ellipse (float center_x,
CoglFixed center_y, float center_y,
CoglFixed radius_x, float radius_x,
CoglFixed radius_y); float radius_y);
/** /**
* cogl_path_round_rectangle: * cogl_path_round_rectangle:
@ -346,12 +332,12 @@ void cogl_path_ellipse (CoglFixed center_x,
* Constructs a rectangular shape with rounded corners. If there is an * Constructs a rectangular shape with rounded corners. If there is an
* existing path this will start a new disjoint sub-path. * existing path this will start a new disjoint sub-path.
**/ **/
void cogl_path_round_rectangle (CoglFixed x, void cogl_path_round_rectangle (float x,
CoglFixed y, float y,
CoglFixed width, float width,
CoglFixed height, float height,
CoglFixed radius, float radius,
CoglAngle arc_step); float arc_step);
G_END_DECLS G_END_DECLS

20
clutter/cogl/cogl-texture.h
View File

@ -368,14 +368,14 @@ void cogl_texture_unref (CoglHandle handle);
* texture pass in @tx1=0.0 @ty1=0.0 @tx2=1.0 @ty2=1.0. * texture pass in @tx1=0.0 @ty1=0.0 @tx2=1.0 @ty2=1.0.
*/ */
void cogl_texture_rectangle (CoglHandle handle, void cogl_texture_rectangle (CoglHandle handle,
CoglFixed x1, float x1,
CoglFixed y1, float y1,
CoglFixed x2, float x2,
CoglFixed y2, float y2,
CoglFixed tx1, float tx1,
CoglFixed ty1, float ty1,
CoglFixed tx2, float tx2,
CoglFixed ty2); float ty2);
/** /**
* cogl_texture_polygon: * cogl_texture_polygon:
@ -455,7 +455,7 @@ void cogl_bitmap_free (CoglBitmap *bmp);
* significant performance boost to use this function rather than * significant performance boost to use this function rather than
* calling cogl_texture_rectangle() separately for each rectangle. * calling cogl_texture_rectangle() separately for each rectangle.
* *
* @verts should point to an array of #CoglFixed<!-- -->s with * @verts should point to an array of #float<!-- -->s with
* @n_rects * 8 elements. Each group of 8 values corresponds to the * @n_rects * 8 elements. Each group of 8 values corresponds to the
* parameters x1, y1, x2, y2, tx1, ty1, tx2 and ty2 and have the same * parameters x1, y1, x2, y2, tx1, ty1, tx2 and ty2 and have the same
* meaning as in cogl_texture_rectangle(). * meaning as in cogl_texture_rectangle().
@ -464,7 +464,7 @@ void cogl_bitmap_free (CoglBitmap *bmp);
*/ */
void cogl_texture_multiple_rectangles void cogl_texture_multiple_rectangles
(CoglHandle handle, (CoglHandle handle,
const CoglFixed *verts, const float *verts,
guint n_rects); guint n_rects);
G_END_DECLS G_END_DECLS

4
clutter/cogl/cogl-types.h
View File

@ -264,8 +264,8 @@ struct _CoglColor
*/ */
struct _CoglTextureVertex struct _CoglTextureVertex
{ {
CoglFixed x, y, z; float x, y, z;
CoglFixed tx, ty; float tx, ty;
CoglColor color; CoglColor color;
}; };

110
clutter/cogl/cogl.h.in
View File

@ -143,10 +143,10 @@ void cogl_get_bitmasks (gint *red,
* Replaces the current projection matrix with a perspective matrix * Replaces the current projection matrix with a perspective matrix
* based on the provided values. * based on the provided values.
*/ */
void cogl_perspective (CoglFixed fovy, void cogl_perspective (float fovy,
CoglFixed aspect, float aspect,
CoglFixed z_near, float z_near,
CoglFixed z_far); float z_far);
/** /**
* cogl_frustum: * cogl_frustum:
@ -162,12 +162,12 @@ void cogl_perspective (CoglFixed fovy,
* *
* Since: 0.8.2 * Since: 0.8.2
*/ */
void cogl_frustum (CoglFixed left, void cogl_frustum (float left,
CoglFixed right, float right,
CoglFixed bottom, float bottom,
CoglFixed top, float top,
CoglFixed z_near, float z_near,
CoglFixed z_far); float z_far);
/** /**
* cogl_setup_viewport: * cogl_setup_viewport:
@ -187,10 +187,10 @@ void cogl_frustum (CoglFixed left,
*/ */
void cogl_setup_viewport (guint width, void cogl_setup_viewport (guint width,
guint height, guint height,
CoglFixed fovy, float fovy,
CoglFixed aspect, float aspect,
CoglFixed z_near, float z_near,
CoglFixed z_far); float z_far);
/** /**
* cogl_viewport: * cogl_viewport:
@ -227,21 +227,8 @@ void cogl_pop_matrix (void);
* Multiplies the current model-view matrix by one that scales the x * Multiplies the current model-view matrix by one that scales the x
* and y axes by the given values. * and y axes by the given values.
*/ */
void cogl_scale (CoglFixed x, void cogl_scale (float x,
CoglFixed y); float y);
/**
* cogl_translatex:
* @x: Distance to translate along the x-axis
* @y: Distance to translate along the y-axis
* @z: Distance to translate along the z-axis
*
* Multiplies the current model-view matrix by one that translates the
* model along all three axes according to the given values.
*/
void cogl_translatex (CoglFixed x,
CoglFixed y,
CoglFixed z);
/** /**
* cogl_translate: * cogl_translate:
@ -249,16 +236,15 @@ void cogl_translatex (CoglFixed x,
* @y: Distance to translate along the y-axis * @y: Distance to translate along the y-axis
* @z: Distance to translate along the z-axis * @z: Distance to translate along the z-axis
* *
* Integer version of cogl_translatex(). Multiplies the current * Multiplies the current model-view matrix by one that translates the
* model-view matrix by one that translates the model along all three * model along all three axes according to the given values.
* axes according to the given values.
*/ */
void cogl_translate (gint x, void cogl_translate (float x,
gint y, float y,
gint z); float z);
/** /**
* cogl_rotatex: * cogl_rotate:
* @angle: Angle in degrees to rotate. * @angle: Angle in degrees to rotate.
* @x: X-component of vertex to rotate around. * @x: X-component of vertex to rotate around.
* @y: Y-component of vertex to rotate around. * @y: Y-component of vertex to rotate around.
@ -270,55 +256,39 @@ void cogl_translate (gint x,
* degrees about the vertex (0, 0, 1) causes a small counter-clockwise * degrees about the vertex (0, 0, 1) causes a small counter-clockwise
* rotation. * rotation.
*/ */
void cogl_rotatex (CoglFixed angle, void cogl_rotate (float angle,
gint x, float x,
gint y, float y,
gint z); float z);
/**
* cogl_rotate:
* @angle: Angle in degrees to rotate.
* @x: X-component of vertex to rotate around.
* @y: Y-component of vertex to rotate around.
* @z: Z-component of vertex to rotate around.
*
* Integer version of cogl_rotatex(). Multiplies the current
* model-view matrix by one that rotates the model around the vertex
* specified by @x, @y and @z.
*/
void cogl_rotate (gint angle,
gint x,
gint y,
gint z);
/** /**
* cogl_get_modelview_matrix: * cogl_get_modelview_matrix:
* @m: pointer to a 4x4 array of #CoglFixed<!-- -->s to receive the matrix * @m: pointer to a 4x4 array of #float<!-- -->s to receive the matrix
* *
* Stores the current model-view matrix in @m. The matrix is in * Stores the current model-view matrix in @m. The matrix is in
* column-major order. * column-major order.
*/ */
void cogl_get_modelview_matrix (CoglFixed m[16]); void cogl_get_modelview_matrix (float m[16]);
/** /**
* cogl_get_projection_matrix: * cogl_get_projection_matrix:
* @m: pointer to a 4x4 array of #CoglFixed<!-- -->s to receive the matrix * @m: pointer to a 4x4 array of #float<!-- -->s to receive the matrix
* *
* Stores the current projection matrix in @m. The matrix is in * Stores the current projection matrix in @m. The matrix is in
* column-major order. * column-major order.
*/ */
void cogl_get_projection_matrix (CoglFixed m[16]); void cogl_get_projection_matrix (float m[16]);
/** /**
* cogl_get_viewport: * cogl_get_viewport:
* @v: pointer to a 4 element array of #CoglFixed<!-- -->s to * @v: pointer to a 4 element array of #float<!-- -->s to
* receive the viewport dimensions. * receive the viewport dimensions.
* *
* Stores the current viewport in @v. @v[0] and @v[1] get the x and y * 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 * position of the viewport and @v[2] and @v[3] get the width and
* height. * height.
*/ */
void cogl_get_viewport (CoglFixed v[4]); void cogl_get_viewport (float v[4]);
/** /**
* cogl_clip_set: * cogl_clip_set:
@ -336,10 +306,10 @@ void cogl_get_viewport (CoglFixed v[4]);
* The rectangle is intersected with the current clip region. To undo * The rectangle is intersected with the current clip region. To undo
* the effect of this function, call cogl_clip_unset(). * the effect of this function, call cogl_clip_unset().
*/ */
void cogl_clip_set (CoglFixed x_offset, void cogl_clip_set (float x_offset,
CoglFixed y_offset, float y_offset,
CoglFixed width, float width,
CoglFixed height); float height);
/** /**
* cogl_clip_set_from_path: * cogl_clip_set_from_path:
@ -443,7 +413,7 @@ void cogl_enable_backface_culling (gboolean setting);
* initial reference value is 1.0. * initial reference value is 1.0.
*/ */
void cogl_alpha_func (COGLenum func, void cogl_alpha_func (COGLenum func,
CoglFixed ref); float ref);
/** /**
* cogl_fog_set: * cogl_fog_set:
@ -460,9 +430,9 @@ void cogl_alpha_func (COGLenum func,
* cogl_paint_init(). * cogl_paint_init().
*/ */
void cogl_fog_set (const CoglColor *fog_color, void cogl_fog_set (const CoglColor *fog_color,
CoglFixed density, float density,
CoglFixed z_near, float z_near,
CoglFixed z_far); float z_far);
/** /**
* cogl_paint_init: * cogl_paint_init:

46
clutter/cogl/common/cogl-clip-stack.c
View File

@ -35,24 +35,24 @@
/* These are defined in the particular backend (float in GL vs fixed /* These are defined in the particular backend (float in GL vs fixed
in GL ES) */ in GL ES) */
void _cogl_set_clip_planes (CoglFixed x, void _cogl_set_clip_planes (float x,
CoglFixed y, float y,
CoglFixed width, float width,
CoglFixed height); float height);
void _cogl_add_stencil_clip (CoglFixed x, void _cogl_add_stencil_clip (float x,
CoglFixed y, float y,
CoglFixed width, float width,
CoglFixed height, float height,
gboolean first); gboolean first);
void _cogl_add_path_to_stencil_buffer (CoglFixedVec2 nodes_min, void _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
CoglFixedVec2 nodes_max, floatVec2 nodes_max,
guint path_size, guint path_size,
CoglPathNode *path, CoglPathNode *path,
gboolean merge); gboolean merge);
void _cogl_enable_clip_planes (void); void _cogl_enable_clip_planes (void);
void _cogl_disable_clip_planes (void); void _cogl_disable_clip_planes (void);
void _cogl_disable_stencil_buffer (void); void _cogl_disable_stencil_buffer (void);
void _cogl_set_matrix (const CoglFixed *matrix); void _cogl_set_matrix (const float *matrix);
typedef struct _CoglClipStack CoglClipStack; typedef struct _CoglClipStack CoglClipStack;
@ -75,13 +75,13 @@ struct _CoglClipStackEntryRect
CoglClipStackEntryType type; CoglClipStackEntryType type;
/* The rectangle for this clip */ /* The rectangle for this clip */
CoglFixed x_offset; float x_offset;
CoglFixed y_offset; float y_offset;
CoglFixed width; float width;
CoglFixed height; float height;
/* The matrix that was current when the clip was set */ /* The matrix that was current when the clip was set */
CoglFixed matrix[16]; float matrix[16];
}; };
struct _CoglClipStackEntryPath struct _CoglClipStackEntryPath
@ -89,20 +89,20 @@ struct _CoglClipStackEntryPath
CoglClipStackEntryType type; CoglClipStackEntryType type;
/* The matrix that was current when the clip was set */ /* The matrix that was current when the clip was set */
CoglFixed matrix[16]; float matrix[16];
CoglFixedVec2 path_nodes_min; floatVec2 path_nodes_min;
CoglFixedVec2 path_nodes_max; floatVec2 path_nodes_max;
guint path_size; guint path_size;
CoglPathNode path[1]; CoglPathNode path[1];
}; };
void void
cogl_clip_set (CoglFixed x_offset, cogl_clip_set (float x_offset,
CoglFixed y_offset, float y_offset,
CoglFixed width, float width,
CoglFixed height) float height)
{ {
CoglClipStackEntryRect *entry; CoglClipStackEntryRect *entry;
CoglClipStack *stack; CoglClipStack *stack;

44
clutter/cogl/common/cogl-color.c
View File

@ -58,18 +58,18 @@ cogl_color_set_from_4d (CoglColor *dest,
} }
void void
cogl_color_set_from_4x (CoglColor *dest, cogl_color_set_from_4f (CoglColor *dest,
CoglFixed red, float red,
CoglFixed green, float green,
CoglFixed blue, float blue,
CoglFixed alpha) float alpha)
{ {
g_return_if_fail (dest != NULL); g_return_if_fail (dest != NULL);
dest->red = COGL_FIXED_TO_INT (red * 255); dest->red = (red * 255);
dest->green = COGL_FIXED_TO_INT (green * 255); dest->green = (green * 255);
dest->blue = COGL_FIXED_TO_INT (blue * 255); dest->blue = (blue * 255);
dest->alpha = COGL_FIXED_TO_INT (alpha * 255); dest->alpha = (alpha * 255);
} }
unsigned char unsigned char
@ -84,10 +84,10 @@ cogl_color_get_red_float (const CoglColor *color)
return (float) color->red / 255.0; return (float) color->red / 255.0;
} }
CoglFixed float
cogl_color_get_red (const CoglColor *color) cogl_color_get_red (const CoglColor *color)
{ {
return COGL_FIXED_FROM_FLOAT ((float) color->red / 255.0); return ((float) color->red / 255.0);
} }
unsigned char unsigned char
@ -102,10 +102,10 @@ cogl_color_get_green_float (const CoglColor *color)
return (float) color->green / 255.0; return (float) color->green / 255.0;
} }
CoglFixed float
cogl_color_get_green (const CoglColor *color) cogl_color_get_green (const CoglColor *color)
{ {
return COGL_FIXED_FROM_FLOAT ((float) color->green / 255.0); return ((float) color->green / 255.0);
} }
unsigned char unsigned char
@ -120,10 +120,10 @@ cogl_color_get_blue_float (const CoglColor *color)
return (float) color->blue / 255.0; return (float) color->blue / 255.0;
} }
CoglFixed float
cogl_color_get_blue (const CoglColor *color) cogl_color_get_blue (const CoglColor *color)
{ {
return COGL_FIXED_FROM_FLOAT ((float) color->blue / 255.0); return ((float) color->blue / 255.0);
} }
unsigned char unsigned char
@ -138,10 +138,10 @@ cogl_color_get_alpha_float (const CoglColor *color)
return (float) color->alpha / 255.0; return (float) color->alpha / 255.0;
} }
CoglFixed float
cogl_color_get_alpha (const CoglColor *color) cogl_color_get_alpha (const CoglColor *color)
{ {
return COGL_FIXED_FROM_FLOAT ((float) color->alpha / 255.0); return ((float) color->alpha / 255.0);
} }
void void
@ -157,13 +157,13 @@ cogl_set_source_color4ub (guint8 red,
} }
void void
cogl_set_source_color4x (CoglFixed red, cogl_set_source_color4f (float red,
CoglFixed green, float green,
CoglFixed blue, float blue,
CoglFixed alpha) float alpha)
{ {
CoglColor c = { 0, }; CoglColor c = { 0, };
cogl_color_set_from_4x (&c, red, green, blue, alpha); cogl_color_set_from_4f (&c, red, green, blue, alpha);
cogl_set_source_color (&c); cogl_set_source_color (&c);
} }

6
clutter/cogl/common/cogl-fixed.c
View File

@ -481,6 +481,12 @@ cogl_angle_sin (CoglAngle angle)
return result; return result;
} }
CoglFixed
cogl_fixed_tan (CoglFixed angle)
{
return cogl_angle_tan (COGL_ANGLE_FROM_DEGX (angle));
}
CoglFixed CoglFixed
cogl_angle_tan (CoglAngle angle) cogl_angle_tan (CoglAngle angle)
{ {

309
clutter/cogl/common/cogl-primitives.c
View File

@ -33,46 +33,31 @@
#include <string.h> #include <string.h>
#include <gmodule.h> #include <gmodule.h>
#include <math.h>
#define _COGL_MAX_BEZ_RECURSE_DEPTH 16 #define _COGL_MAX_BEZ_RECURSE_DEPTH 16
/* these are defined in the particular backend(float in gl vs fixed in gles)*/ /* these are defined in the particular backend(float in gl vs fixed in gles)*/
void _cogl_path_add_node (gboolean new_sub_path, void _cogl_path_add_node (gboolean new_sub_path,
CoglFixed x, float x,
CoglFixed y); float y);
void _cogl_path_fill_nodes (); void _cogl_path_fill_nodes ();
void _cogl_path_stroke_nodes (); void _cogl_path_stroke_nodes ();
void _cogl_rectangle (gint x, void _cogl_rectangle (float x,
gint y, float y,
guint width, float width,
guint height); float height);
void _cogl_rectanglex (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height);
void void
cogl_rectangle (gint x, cogl_rectangle (float x,
gint y, float y,
guint width, float width,
guint height) float height)
{ {
cogl_clip_ensure (); cogl_clip_ensure ();
_cogl_rectangle (x, y, width, height); _cogl_rectangle (x, y, width, height);
} }
void
cogl_rectanglex (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height)
{
cogl_clip_ensure ();
_cogl_rectanglex (x, y, width, height);
}
void void
cogl_path_fill (void) cogl_path_fill (void)
{ {
@ -116,8 +101,8 @@ cogl_path_stroke_preserve (void)
} }
void void
cogl_path_move_to (CoglFixed x, cogl_path_move_to (float x,
CoglFixed y) float y)
{ {
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -132,8 +117,8 @@ cogl_path_move_to (CoglFixed x,
} }
void void
cogl_path_rel_move_to (CoglFixed x, cogl_path_rel_move_to (float x,
CoglFixed y) float y)
{ {
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -142,8 +127,8 @@ cogl_path_rel_move_to (CoglFixed x,
} }
void void
cogl_path_line_to (CoglFixed x, cogl_path_line_to (float x,
CoglFixed y) float y)
{ {
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -154,8 +139,8 @@ cogl_path_line_to (CoglFixed x,
} }
void void
cogl_path_rel_line_to (CoglFixed x, cogl_path_rel_line_to (float x,
CoglFixed y) float y)
{ {
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -181,17 +166,17 @@ cogl_path_new (void)
} }
void void
cogl_path_line (CoglFixed x1, cogl_path_line (float x1,
CoglFixed y1, float y1,
CoglFixed x2, float x2,
CoglFixed y2) float y2)
{ {
cogl_path_move_to (x1, y1); cogl_path_move_to (x1, y1);
cogl_path_line_to (x2, y2); cogl_path_line_to (x2, y2);
} }
void void
cogl_path_polyline (CoglFixed *coords, cogl_path_polyline (float *coords,
gint num_points) gint num_points)
{ {
gint c = 0; gint c = 0;
@ -203,7 +188,7 @@ cogl_path_polyline (CoglFixed *coords,
} }
void void
cogl_path_polygon (CoglFixed *coords, cogl_path_polygon (float *coords,
gint num_points) gint num_points)
{ {
cogl_path_polyline (coords, num_points); cogl_path_polyline (coords, num_points);
@ -211,10 +196,10 @@ cogl_path_polygon (CoglFixed *coords,
} }
void void
cogl_path_rectangle (CoglFixed x, cogl_path_rectangle (float x,
CoglFixed y, float y,
CoglFixed width, float width,
CoglFixed height) float height)
{ {
cogl_path_move_to (x, y); cogl_path_move_to (x, y);
cogl_path_line_to (x + width, y); cogl_path_line_to (x + width, y);
@ -224,20 +209,20 @@ cogl_path_rectangle (CoglFixed x,
} }
static void static void
_cogl_path_arc (CoglFixed center_x, _cogl_path_arc (float center_x,
CoglFixed center_y, float center_y,
CoglFixed radius_x, float radius_x,
CoglFixed radius_y, float radius_y,
CoglAngle angle_1, float angle_1,
CoglAngle angle_2, float angle_2,
CoglAngle angle_step, float angle_step,
guint move_first) guint move_first)
{ {
CoglAngle a = 0x0; float a = 0x0;
CoglFixed cosa = 0x0; float cosa = 0x0;
CoglFixed sina = 0x0; float sina = 0x0;
CoglFixed px = 0x0; float px = 0x0;
CoglFixed py = 0x0; float py = 0x0;
/* Fix invalid angles */ /* Fix invalid angles */
@ -252,11 +237,11 @@ _cogl_path_arc (CoglFixed center_x,
a = angle_1; a = angle_1;
while (a != angle_2) while (a != angle_2)
{ {
cosa = cogl_angle_cos (a); cosa = cosf (a * (G_PI/180.0));
sina = cogl_angle_sin (a); sina = sinf (a * (G_PI/180.0));
px = center_x + COGL_FIXED_MUL (cosa, radius_x); px = center_x + (cosa * radius_x);
py = center_y + COGL_FIXED_MUL (sina, radius_y); py = center_y + (sina * radius_y);
if (a == angle_1 && move_first) if (a == angle_1 && move_first)
cogl_path_move_to (px, py); cogl_path_move_to (px, py);
@ -279,24 +264,24 @@ _cogl_path_arc (CoglFixed center_x,
/* Make sure the final point is drawn */ /* Make sure the final point is drawn */
cosa = cogl_angle_cos (angle_2); cosa = cosf (angle_2 * (G_PI/180.0));
sina = cogl_angle_sin (angle_2); sina = sinf (angle_2 * (G_PI/180.0));
px = center_x + COGL_FIXED_MUL (cosa, radius_x); px = center_x + (cosa * radius_x);
py = center_y + COGL_FIXED_MUL (sina, radius_y); py = center_y + (sina * radius_y);
cogl_path_line_to (px, py); cogl_path_line_to (px, py);
} }
void void
cogl_path_arc (CoglFixed center_x, cogl_path_arc (float center_x,
CoglFixed center_y, float center_y,
CoglFixed radius_x, float radius_x,
CoglFixed radius_y, float radius_y,
CoglAngle angle_1, float angle_1,
CoglAngle angle_2) float angle_2)
{ {
CoglAngle angle_step = 10; float angle_step = 10;
/* it is documented that a move to is needed to create a freestanding /* it is documented that a move to is needed to create a freestanding
* arc * arc
*/ */
@ -308,13 +293,13 @@ cogl_path_arc (CoglFixed center_x,
void void
cogl_path_arc_rel (CoglFixed center_x, cogl_path_arc_rel (float center_x,
CoglFixed center_y, float center_y,
CoglFixed radius_x, float radius_x,
CoglFixed radius_y, float radius_y,
CoglAngle angle_1, float angle_1,
CoglAngle angle_2, float angle_2,
CoglAngle angle_step) float angle_step)
{ {
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -326,50 +311,50 @@ cogl_path_arc_rel (CoglFixed center_x,
} }
void void
cogl_path_ellipse (CoglFixed center_x, cogl_path_ellipse (float center_x,
CoglFixed center_y, float center_y,
CoglFixed radius_x, float radius_x,
CoglFixed radius_y) float radius_y)
{ {
CoglAngle angle_step = 10; float angle_step = 10;
/* FIXME: if shows to be slow might be optimized /* FIXME: if shows to be slow might be optimized
* by mirroring just a quarter of it */ * by mirroring just a quarter of it */
_cogl_path_arc (center_x, center_y, _cogl_path_arc (center_x, center_y,
radius_x, radius_y, radius_x, radius_y,
0, COGL_ANGLE_FROM_DEG (360), 0, 360,
angle_step, 1 /* move first */); angle_step, 1 /* move first */);
cogl_path_close(); cogl_path_close();
} }
void void
cogl_path_round_rectangle (CoglFixed x, cogl_path_round_rectangle (float x,
CoglFixed y, float y,
CoglFixed width, float width,
CoglFixed height, float height,
CoglFixed radius, float radius,
CoglAngle arc_step) float arc_step)
{ {
CoglFixed inner_width = width - (radius << 1); float inner_width = width - (radius * 2);
CoglFixed inner_height = height - (radius << 1); float inner_height = height - (radius * 2);
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
cogl_path_move_to (x, y + radius); cogl_path_move_to (x, y + radius);
cogl_path_arc_rel (radius, 0, cogl_path_arc_rel (radius, 0,
radius, radius, radius, radius,
COGL_ANGLE_FROM_DEG (180), 180,
COGL_ANGLE_FROM_DEG (270), 270,
arc_step); arc_step);
cogl_path_line_to (ctx->path_pen.x + inner_width, cogl_path_line_to (ctx->path_pen.x + inner_width,
ctx->path_pen.y); ctx->path_pen.y);
cogl_path_arc_rel (0, radius, cogl_path_arc_rel (0, radius,
radius, radius, radius, radius,
COGL_ANGLE_FROM_DEG (-90), -90,
COGL_ANGLE_FROM_DEG (0), 0,
arc_step); arc_step);
cogl_path_line_to (ctx->path_pen.x, cogl_path_line_to (ctx->path_pen.x,
@ -377,16 +362,16 @@ cogl_path_round_rectangle (CoglFixed x,
cogl_path_arc_rel (-radius, 0, cogl_path_arc_rel (-radius, 0,
radius, radius, radius, radius,
COGL_ANGLE_FROM_DEG (0), 0,
COGL_ANGLE_FROM_DEG (90), 90,
arc_step); arc_step);
cogl_path_line_to (ctx->path_pen.x - inner_width, cogl_path_line_to (ctx->path_pen.x - inner_width,
ctx->path_pen.y); ctx->path_pen.y);
cogl_path_arc_rel (0, -radius, cogl_path_arc_rel (0, -radius,
radius, radius, radius, radius,
COGL_ANGLE_FROM_DEG (90), 90,
COGL_ANGLE_FROM_DEG (180), 180,
arc_step); arc_step);
cogl_path_close (); cogl_path_close ();
@ -400,14 +385,14 @@ _cogl_path_bezier3_sub (CoglBezCubic *cubic)
CoglBezCubic *cleft; CoglBezCubic *cleft;
CoglBezCubic *cright; CoglBezCubic *cright;
CoglBezCubic *c; CoglBezCubic *c;
CoglFixedVec2 dif1; floatVec2 dif1;
CoglFixedVec2 dif2; floatVec2 dif2;
CoglFixedVec2 mm; floatVec2 mm;
CoglFixedVec2 c1; floatVec2 c1;
CoglFixedVec2 c2; floatVec2 c2;
CoglFixedVec2 c3; floatVec2 c3;
CoglFixedVec2 c4; floatVec2 c4;
CoglFixedVec2 c5; floatVec2 c5;
gint cindex; gint cindex;
/* Put first curve on stack */ /* Put first curve on stack */
@ -418,16 +403,13 @@ _cogl_path_bezier3_sub (CoglBezCubic *cubic)
{ {
c = &cubics[cindex]; c = &cubics[cindex];
#define CFX_MUL2(x) ((x) << 1)
#define CFX_MUL3(x) (((x) << 1) + (x))
#define CFX_SQ(x) COGL_FIXED_MUL (x, x)
/* Calculate distance of control points from their /* Calculate distance of control points from their
* counterparts on the line between end points */ * counterparts on the line between end points */
dif1.x = CFX_MUL3 (c->p2.x) - CFX_MUL2 (c->p1.x) - c->p4.x; dif1.x = (c->p2.x * 3) - (c->p1.x * 2) - c->p4.x;
dif1.y = CFX_MUL3 (c->p2.y) - CFX_MUL2 (c->p1.y) - c->p4.y; dif1.y = (c->p2.y * 3) - (c->p1.y * 2) - c->p4.y;
dif2.x = CFX_MUL3 (c->p3.x) - CFX_MUL2 (c->p4.x) - c->p1.x; dif2.x = (c->p3.x * 3) - (c->p4.x * 2) - c->p1.x;
dif2.y = CFX_MUL3 (c->p3.y) - CFX_MUL2 (c->p4.y) - c->p1.y; dif2.y = (c->p3.y * 3) - (c->p4.y * 2) - c->p1.y;
if (dif1.x < 0) if (dif1.x < 0)
dif1.x = -dif1.x; dif1.x = -dif1.x;
@ -438,16 +420,13 @@ _cogl_path_bezier3_sub (CoglBezCubic *cubic)
if (dif2.y < 0) if (dif2.y < 0)
dif2.y = -dif2.y; dif2.y = -dif2.y;
#undef CFX_MUL2
#undef CFX_MUL3
#undef CFX_SQ
/* Pick the greatest of two distances */ /* Pick the greatest of two distances */
if (dif1.x < dif2.x) dif1.x = dif2.x; if (dif1.x < dif2.x) dif1.x = dif2.x;
if (dif1.y < dif2.y) dif1.y = dif2.y; if (dif1.y < dif2.y) dif1.y = dif2.y;
/* Cancel if the curve is flat enough */ /* Cancel if the curve is flat enough */
if (dif1.x + dif1.y <= COGL_FIXED_1 || if (dif1.x + dif1.y <= 1.0 ||
cindex == _COGL_MAX_BEZ_RECURSE_DEPTH-1) cindex == _COGL_MAX_BEZ_RECURSE_DEPTH-1)
{ {
/* Add subdivision point (skip last) */ /* Add subdivision point (skip last) */
@ -465,20 +444,20 @@ _cogl_path_bezier3_sub (CoglBezCubic *cubic)
cright = c; cleft = &cubics[++cindex]; cright = c; cleft = &cubics[++cindex];
/* Subdivide into 2 sub-curves */ /* Subdivide into 2 sub-curves */
c1.x = ((c->p1.x + c->p2.x) >> 1); c1.x = ((c->p1.x + c->p2.x) / 2);
c1.y = ((c->p1.y + c->p2.y) >> 1); c1.y = ((c->p1.y + c->p2.y) / 2);
mm.x = ((c->p2.x + c->p3.x) >> 1); mm.x = ((c->p2.x + c->p3.x) / 2);
mm.y = ((c->p2.y + c->p3.y) >> 1); mm.y = ((c->p2.y + c->p3.y) / 2);
c5.x = ((c->p3.x + c->p4.x) >> 1); c5.x = ((c->p3.x + c->p4.x) / 2);
c5.y = ((c->p3.y + c->p4.y) >> 1); c5.y = ((c->p3.y + c->p4.y) / 2);
c2.x = ((c1.x + mm.x) >> 1); c2.x = ((c1.x + mm.x) / 2);
c2.y = ((c1.y + mm.y) >> 1); c2.y = ((c1.y + mm.y) / 2);
c4.x = ((mm.x + c5.x) >> 1); c4.x = ((mm.x + c5.x) / 2);
c4.y = ((mm.y + c5.y) >> 1); c4.y = ((mm.y + c5.y) / 2);
c3.x = ((c2.x + c4.x) >> 1); c3.x = ((c2.x + c4.x) / 2);
c3.y = ((c2.y + c4.y) >> 1); c3.y = ((c2.y + c4.y) / 2);
/* Add left recursion to stack */ /* Add left recursion to stack */
cleft->p1 = c->p1; cleft->p1 = c->p1;
@ -495,12 +474,12 @@ _cogl_path_bezier3_sub (CoglBezCubic *cubic)
} }
void void
cogl_path_curve_to (CoglFixed x1, cogl_path_curve_to (float x1,
CoglFixed y1, float y1,
CoglFixed x2, float x2,
CoglFixed y2, float y2,
CoglFixed x3, float x3,
CoglFixed y3) float y3)
{ {
CoglBezCubic cubic; CoglBezCubic cubic;
@ -524,12 +503,12 @@ cogl_path_curve_to (CoglFixed x1,
} }
void void
cogl_path_rel_curve_to (CoglFixed x1, cogl_path_rel_curve_to (float x1,
CoglFixed y1, float y1,
CoglFixed x2, float x2,
CoglFixed y2, float y2,
CoglFixed x3, float x3,
CoglFixed y3) float y3)
{ {
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -554,11 +533,11 @@ _cogl_path_bezier2_sub (CoglBezQuad *quad)
CoglBezQuad *qleft; CoglBezQuad *qleft;
CoglBezQuad *qright; CoglBezQuad *qright;
CoglBezQuad *q; CoglBezQuad *q;
CoglFixedVec2 mid; floatVec2 mid;
CoglFixedVec2 dif; floatVec2 dif;
CoglFixedVec2 c1; floatVec2 c1;
CoglFixedVec2 c2; floatVec2 c2;
CoglFixedVec2 c3; floatVec2 c3;
gint qindex; gint qindex;
/* Put first curve on stack */ /* Put first curve on stack */
@ -573,15 +552,15 @@ _cogl_path_bezier2_sub (CoglBezQuad *quad)
/* Calculate distance of control point from its /* Calculate distance of control point from its
* counterpart on the line between end points */ * counterpart on the line between end points */
mid.x = ((q->p1.x + q->p3.x) >> 1); mid.x = ((q->p1.x + q->p3.x) / 2);
mid.y = ((q->p1.y + q->p3.y) >> 1); mid.y = ((q->p1.y + q->p3.y) / 2);
dif.x = (q->p2.x - mid.x); dif.x = (q->p2.x - mid.x);
dif.y = (q->p2.y - mid.y); dif.y = (q->p2.y - mid.y);
if (dif.x < 0) dif.x = -dif.x; if (dif.x < 0) dif.x = -dif.x;
if (dif.y < 0) dif.y = -dif.y; if (dif.y < 0) dif.y = -dif.y;
/* Cancel if the curve is flat enough */ /* Cancel if the curve is flat enough */
if (dif.x + dif.y <= COGL_FIXED_1 || if (dif.x + dif.y <= 1.0 ||
qindex == _COGL_MAX_BEZ_RECURSE_DEPTH - 1) qindex == _COGL_MAX_BEZ_RECURSE_DEPTH - 1)
{ {
/* Add subdivision point (skip last) */ /* Add subdivision point (skip last) */
@ -594,12 +573,12 @@ _cogl_path_bezier2_sub (CoglBezQuad *quad)
qright = q; qleft = &quads[++qindex]; qright = q; qleft = &quads[++qindex];
/* Subdivide into 2 sub-curves */ /* Subdivide into 2 sub-curves */
c1.x = ((q->p1.x + q->p2.x) >> 1); c1.x = ((q->p1.x + q->p2.x) / 2);
c1.y = ((q->p1.y + q->p2.y) >> 1); c1.y = ((q->p1.y + q->p2.y) / 2);
c3.x = ((q->p2.x + q->p3.x) >> 1); c3.x = ((q->p2.x + q->p3.x) / 2);
c3.y = ((q->p2.y + q->p3.y) >> 1); c3.y = ((q->p2.y + q->p3.y) / 2);
c2.x = ((c1.x + c3.x) >> 1); c2.x = ((c1.x + c3.x) / 2);
c2.y = ((c1.y + c3.y) >> 1); c2.y = ((c1.y + c3.y) / 2);
/* Add left recursion onto stack */ /* Add left recursion onto stack */
qleft->p1 = q->p1; qleft->p1 = q->p1;
@ -614,10 +593,10 @@ _cogl_path_bezier2_sub (CoglBezQuad *quad)
} }
void void
cogl_path_curve2_to (CoglFixed x1, cogl_path_curve2_to (float x1,
CoglFixed y1, float y1,
CoglFixed x2, float x2,
CoglFixed y2) float y2)
{ {
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -639,10 +618,10 @@ cogl_path_curve2_to (CoglFixed x1,
} }
void void
cogl_rel_curve2_to (CoglFixed x1, cogl_rel_curve2_to (float x1,
CoglFixed y1, float y1,
CoglFixed x2, float x2,
CoglFixed y2) float y2)
{ {
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);

22
clutter/cogl/common/cogl-primitives.h
View File

@ -26,15 +26,15 @@
#ifndef __COGL_PRIMITIVES_H #ifndef __COGL_PRIMITIVES_H
#define __COGL_PRIMITIVES_H #define __COGL_PRIMITIVES_H
typedef struct _CoglFixedVec2 CoglFixedVec2; typedef struct _floatVec2 floatVec2;
typedef struct _CoglBezQuad CoglBezQuad; typedef struct _CoglBezQuad CoglBezQuad;
typedef struct _CoglBezCubic CoglBezCubic; typedef struct _CoglBezCubic CoglBezCubic;
typedef struct _CoglPathNode CoglPathNode; typedef struct _CoglPathNode CoglPathNode;
struct _CoglFixedVec2 struct _floatVec2
{ {
CoglFixed x; float x;
CoglFixed y; float y;
}; };
#ifdef CLUTTER_COGL_HAS_GL #ifdef CLUTTER_COGL_HAS_GL
@ -67,17 +67,17 @@ struct _CoglPathNode
struct _CoglBezQuad struct _CoglBezQuad
{ {
CoglFixedVec2 p1; floatVec2 p1;
CoglFixedVec2 p2; floatVec2 p2;
CoglFixedVec2 p3; floatVec2 p3;
}; };
struct _CoglBezCubic struct _CoglBezCubic
{ {
CoglFixedVec2 p1; floatVec2 p1;
CoglFixedVec2 p2; floatVec2 p2;
CoglFixedVec2 p3; floatVec2 p3;
CoglFixedVec2 p4; floatVec2 p4;
}; };
#endif /* __COGL_PRIMITIVES_H */ #endif /* __COGL_PRIMITIVES_H */

8
clutter/cogl/gl/cogl-context.h
View File

@ -51,12 +51,12 @@ typedef struct
gboolean enable_backface_culling; gboolean enable_backface_culling;
/* Primitives */ /* Primitives */
CoglFixedVec2 path_start; floatVec2 path_start;
CoglFixedVec2 path_pen; floatVec2 path_pen;
GArray *path_nodes; GArray *path_nodes;
guint last_path; guint last_path;
CoglFixedVec2 path_nodes_min; floatVec2 path_nodes_min;
CoglFixedVec2 path_nodes_max; floatVec2 path_nodes_max;
/* Cache of inverse projection matrix */ /* Cache of inverse projection matrix */
GLfloat inverse_projection[16]; GLfloat inverse_projection[16];

79
clutter/cogl/gl/cogl-primitives.c
View File

@ -34,52 +34,35 @@
#include <string.h> #include <string.h>
#include <gmodule.h> #include <gmodule.h>
#include <math.h>
#define _COGL_MAX_BEZ_RECURSE_DEPTH 16 #define _COGL_MAX_BEZ_RECURSE_DEPTH 16
void void
_cogl_rectangle (gint x, _cogl_rectangle (float x,
gint y, float y,
guint width, float width,
guint height) float height)
{ {
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
cogl_enable (ctx->color_alpha < 255 cogl_enable (ctx->color_alpha < 255
? COGL_ENABLE_BLEND : 0); ? COGL_ENABLE_BLEND : 0);
GE( glRecti (x, y, x + width, y + height) ); GE( glRectf (x, y, x + width, y + height) );
}
void
_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 (COGL_FIXED_TO_FLOAT (x),
COGL_FIXED_TO_FLOAT (y),
COGL_FIXED_TO_FLOAT (x + width),
COGL_FIXED_TO_FLOAT (y + height)) );
} }
void void
_cogl_path_add_node (gboolean new_sub_path, _cogl_path_add_node (gboolean new_sub_path,
CoglFixed x, float x,
CoglFixed y) float y)
{ {
CoglPathNode new_node; CoglPathNode new_node;
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
new_node.x = COGL_FIXED_TO_FLOAT (x); new_node.x = (x);
new_node.y = COGL_FIXED_TO_FLOAT (y); new_node.y = (y);
new_node.path_size = 0; new_node.path_size = 0;
if (new_sub_path || ctx->path_nodes->len == 0) if (new_sub_path || ctx->path_nodes->len == 0)
@ -129,34 +112,32 @@ _cogl_path_stroke_nodes ()
} }
static void static void
_cogl_path_get_bounds (CoglFixedVec2 nodes_min, _cogl_path_get_bounds (floatVec2 nodes_min,
CoglFixedVec2 nodes_max, floatVec2 nodes_max,
gint *bounds_x, float *bounds_x,
gint *bounds_y, float *bounds_y,
guint *bounds_w, float *bounds_w,
guint *bounds_h) float *bounds_h)
{ {
*bounds_x = COGL_FIXED_FLOOR (nodes_min.x); *bounds_x = nodes_min.x;
*bounds_y = COGL_FIXED_FLOOR (nodes_min.y); *bounds_y = nodes_min.y;
*bounds_w = COGL_FIXED_CEIL (nodes_max.x *bounds_w = nodes_max.x - *bounds_x;
- COGL_FIXED_FROM_INT (*bounds_x)); *bounds_h = nodes_max.y - *bounds_y;
*bounds_h = COGL_FIXED_CEIL (nodes_max.y
- COGL_FIXED_FROM_INT (*bounds_y));
} }
void void
_cogl_add_path_to_stencil_buffer (CoglFixedVec2 nodes_min, _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
CoglFixedVec2 nodes_max, floatVec2 nodes_max,
guint path_size, guint path_size,
CoglPathNode *path, CoglPathNode *path,
gboolean merge) gboolean merge)
{ {
guint path_start = 0; guint path_start = 0;
guint sub_path_num = 0; guint sub_path_num = 0;
gint bounds_x; float bounds_x;
gint bounds_y; float bounds_y;
guint bounds_w; float bounds_w;
guint bounds_h; float bounds_h;
_cogl_path_get_bounds (nodes_min, nodes_max, _cogl_path_get_bounds (nodes_min, nodes_max,
&bounds_x, &bounds_y, &bounds_w, &bounds_h); &bounds_x, &bounds_y, &bounds_w, &bounds_h);
@ -238,10 +219,10 @@ _cogl_add_path_to_stencil_buffer (CoglFixedVec2 nodes_min,
void void
_cogl_path_fill_nodes () _cogl_path_fill_nodes ()
{ {
gint bounds_x; float bounds_x;
gint bounds_y; float bounds_y;
guint bounds_w; float bounds_w;
guint bounds_h; float bounds_h;
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);

227
clutter/cogl/gl/cogl-texture.c
View File

@ -37,6 +37,7 @@
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h>
/* /*
#define COGL_DEBUG 1 #define COGL_DEBUG 1
@ -54,15 +55,15 @@ struct _CoglSpanIter
gint index; gint index;
GArray *array; GArray *array;
CoglTexSliceSpan *span; CoglTexSliceSpan *span;
CoglFixed pos; float pos;
CoglFixed next_pos; float next_pos;
CoglFixed origin; float origin;
CoglFixed cover_start; float cover_start;
CoglFixed cover_end; float cover_end;
CoglFixed intersect_start; float intersect_start;
CoglFixed intersect_end; float intersect_end;
CoglFixed intersect_start_local; float intersect_start_local;
CoglFixed intersect_end_local; float intersect_end_local;
gboolean intersects; gboolean intersects;
}; };
@ -102,7 +103,7 @@ _cogl_span_iter_update (CoglSpanIter *iter)
/* Offset next position by span size */ /* Offset next position by span size */
iter->next_pos = iter->pos + iter->next_pos = iter->pos +
COGL_FIXED_FROM_INT (iter->span->size - iter->span->waste); (float)(iter->span->size - iter->span->waste);
/* Check if span intersects the area to cover */ /* Check if span intersects the area to cover */
if (iter->next_pos <= iter->cover_start || if (iter->next_pos <= iter->cover_start ||
@ -131,9 +132,9 @@ _cogl_span_iter_update (CoglSpanIter *iter)
static void static void
_cogl_span_iter_begin (CoglSpanIter *iter, _cogl_span_iter_begin (CoglSpanIter *iter,
GArray *array, GArray *array,
CoglFixed origin, float origin,
CoglFixed cover_start, float cover_start,
CoglFixed cover_end) float cover_end)
{ {
/* Copy info */ /* Copy info */
iter->index = 0; iter->index = 0;
@ -471,8 +472,8 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
/* Iterate vertical spans */ /* Iterate vertical spans */
for (source_y = src_y, for (source_y = src_y,
_cogl_span_iter_begin (&y_iter, tex->slice_y_spans, _cogl_span_iter_begin (&y_iter, tex->slice_y_spans,
0, COGL_FIXED_FROM_INT (dst_y), 0, (float)(dst_y),
COGL_FIXED_FROM_INT (dst_y + height)); (float)(dst_y + height));
!_cogl_span_iter_end (&y_iter); !_cogl_span_iter_end (&y_iter);
@ -492,8 +493,8 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
/* Iterate horizontal spans */ /* Iterate horizontal spans */
for (source_x = src_x, for (source_x = src_x,
_cogl_span_iter_begin (&x_iter, tex->slice_x_spans, _cogl_span_iter_begin (&x_iter, tex->slice_x_spans,
0, COGL_FIXED_FROM_INT (dst_x), 0, (float)(dst_x),
COGL_FIXED_FROM_INT (dst_x + width)); (float)(dst_x + width));
!_cogl_span_iter_end (&x_iter); !_cogl_span_iter_end (&x_iter);
@ -511,15 +512,15 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
x_iter.index); x_iter.index);
/* Pick intersection width and height */ /* Pick intersection width and height */
inter_w = COGL_FIXED_TO_INT (x_iter.intersect_end - inter_w = (x_iter.intersect_end -
x_iter.intersect_start); x_iter.intersect_start);
inter_h = COGL_FIXED_TO_INT (y_iter.intersect_end - inter_h = (y_iter.intersect_end -
y_iter.intersect_start); y_iter.intersect_start);
/* Localize intersection top-left corner to slice*/ /* Localize intersection top-left corner to slice*/
local_x = COGL_FIXED_TO_INT (x_iter.intersect_start - local_x = (x_iter.intersect_start -
x_iter.pos); x_iter.pos);
local_y = COGL_FIXED_TO_INT (y_iter.intersect_start - local_y = (y_iter.intersect_start -
y_iter.pos); y_iter.pos);
/* Pick slice GL handle */ /* Pick slice GL handle */
@ -555,7 +556,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
guint wx, wy; guint wx, wy;
src = source_bmp->data src = source_bmp->data
+ (src_y + COGL_FIXED_TO_INT (y_iter.intersect_start) + (src_y + ((int)y_iter.intersect_start)
- dst_y) - dst_y)
* source_bmp->rowstride * source_bmp->rowstride
+ (src_x + x_span->start + x_span->size - x_span->waste + (src_x + x_span->start + x_span->size - x_span->waste
@ -600,7 +601,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
guint copy_width; guint copy_width;
src = source_bmp->data src = source_bmp->data
+ (src_x + COGL_FIXED_TO_INT (x_iter.intersect_start) + (src_x + ((int)x_iter.intersect_start)
- dst_x) - dst_x)
* bpp * bpp
+ (src_y + y_span->start + y_span->size - y_span->waste + (src_y + y_span->start + y_span->size - y_span->waste
@ -2010,24 +2011,24 @@ _cogl_texture_add_quad_vertices (GLfloat x1, GLfloat y1,
static void static void
_cogl_texture_quad_sw (CoglTexture *tex, _cogl_texture_quad_sw (CoglTexture *tex,
CoglFixed x1, float x1,
CoglFixed y1, float y1,
CoglFixed x2, float x2,
CoglFixed y2, float y2,
CoglFixed tx1, float tx1,
CoglFixed ty1, float ty1,
CoglFixed tx2, float tx2,
CoglFixed ty2) float ty2)
{ {
CoglSpanIter iter_x , iter_y; CoglSpanIter iter_x , iter_y;
CoglFixed tw , th; float tw , th;
CoglFixed tqx , tqy; float tqx , tqy;
CoglFixed first_tx , first_ty; float first_tx , first_ty;
CoglFixed first_qx , first_qy; float first_qx , first_qy;
CoglFixed slice_tx1 , slice_ty1; float slice_tx1 , slice_ty1;
CoglFixed slice_tx2 , slice_ty2; float slice_tx2 , slice_ty2;
CoglFixed slice_qx1 , slice_qy1; float slice_qx1 , slice_qy1;
CoglFixed slice_qx2 , slice_qy2; float slice_qx2 , slice_qy2;
GLuint gl_handle; GLuint gl_handle;
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -2050,7 +2051,7 @@ _cogl_texture_quad_sw (CoglTexture *tex,
slices */ slices */
if (tx2 < tx1) if (tx2 < tx1)
{ {
CoglFixed temp = x1; float temp = x1;
x1 = x2; x1 = x2;
x2 = temp; x2 = temp;
temp = tx1; temp = tx1;
@ -2059,7 +2060,7 @@ _cogl_texture_quad_sw (CoglTexture *tex,
} }
if (ty2 < ty1) if (ty2 < ty1)
{ {
CoglFixed temp = y1; float temp = y1;
y1 = y2; y1 = y2;
y2 = temp; y2 = temp;
temp = ty1; temp = ty1;
@ -2068,27 +2069,27 @@ _cogl_texture_quad_sw (CoglTexture *tex,
} }
/* Scale ratio from texture to quad widths */ /* Scale ratio from texture to quad widths */
tw = COGL_FIXED_FROM_INT (tex->bitmap.width); tw = (float)(tex->bitmap.width);
th = COGL_FIXED_FROM_INT (tex->bitmap.height); th = (float)(tex->bitmap.height);
tqx = COGL_FIXED_DIV (x2 - x1, COGL_FIXED_MUL (tw, (tx2 - tx1))); tqx = (x2 - x1 / (tw * (tx2 - tx1)));
tqy = COGL_FIXED_DIV (y2 - y1, COGL_FIXED_MUL (th, (ty2 - ty1))); tqy = (y2 - y1 / (th * (ty2 - ty1)));
/* Integral texture coordinate for first tile */ /* Integral texture coordinate for first tile */
first_tx = COGL_FIXED_FROM_INT (COGL_FIXED_FLOOR (tx1)); first_tx = (float)(floorf (tx1));
first_ty = COGL_FIXED_FROM_INT (COGL_FIXED_FLOOR (ty1)); first_ty = (float)(floorf (ty1));
/* Denormalize texture coordinates */ /* Denormalize texture coordinates */
first_tx = COGL_FIXED_MUL (first_tx, tw); first_tx = (first_tx * tw);
first_ty = COGL_FIXED_MUL (first_ty, th); first_ty = (first_ty * th);
tx1 = COGL_FIXED_MUL (tx1, tw); tx1 = (tx1 * tw);
ty1 = COGL_FIXED_MUL (ty1, th); ty1 = (ty1 * th);
tx2 = COGL_FIXED_MUL (tx2, tw); tx2 = (tx2 * tw);
ty2 = COGL_FIXED_MUL (ty2, th); ty2 = (ty2 * th);
/* Quad coordinate of the first tile */ /* Quad coordinate of the first tile */
first_qx = x1 - COGL_FIXED_MUL (tx1 - first_tx, tqx); first_qx = x1 - (tx1 - first_tx * tqx);
first_qy = y1 - COGL_FIXED_MUL (ty1 - first_ty, tqy); first_qy = y1 - (ty1 - first_ty * tqy);
/* Iterate until whole quad height covered */ /* Iterate until whole quad height covered */
@ -2102,10 +2103,10 @@ _cogl_texture_quad_sw (CoglTexture *tex,
/* Span-quad intersection in quad coordinates */ /* Span-quad intersection in quad coordinates */
slice_qy1 = first_qy + slice_qy1 = first_qy +
COGL_FIXED_MUL (iter_y.intersect_start - first_ty, tqy); (iter_y.intersect_start - first_ty * tqy);
slice_qy2 = first_qy + slice_qy2 = first_qy +
COGL_FIXED_MUL (iter_y.intersect_end - first_ty, tqy); (iter_y.intersect_end - first_ty * tqy);
/* Localize slice texture coordinates */ /* Localize slice texture coordinates */
slice_ty1 = iter_y.intersect_start - iter_y.pos; slice_ty1 = iter_y.intersect_start - iter_y.pos;
@ -2130,10 +2131,10 @@ _cogl_texture_quad_sw (CoglTexture *tex,
/* Span-quad intersection in quad coordinates */ /* Span-quad intersection in quad coordinates */
slice_qx1 = first_qx + slice_qx1 = first_qx +
COGL_FIXED_MUL (iter_x.intersect_start - first_tx, tqx); (iter_x.intersect_start - first_tx * tqx);
slice_qx2 = first_qx + slice_qx2 = first_qx +
COGL_FIXED_MUL (iter_x.intersect_end - first_tx, tqx); (iter_x.intersect_end - first_tx * tqx);
/* Localize slice texture coordinates */ /* Localize slice texture coordinates */
slice_tx1 = iter_x.intersect_start - iter_x.pos; slice_tx1 = iter_x.intersect_start - iter_x.pos;
@ -2149,14 +2150,14 @@ _cogl_texture_quad_sw (CoglTexture *tex,
#if COGL_DEBUG #if COGL_DEBUG
printf("~~~~~ slice (%d,%d)\n", iter_x.index, iter_y.index); printf("~~~~~ slice (%d,%d)\n", iter_x.index, iter_y.index);
printf("qx1: %f\n", COGL_FIXED_TO_FLOAT (slice_qx1)); printf("qx1: %f\n", (slice_qx1));
printf("qy1: %f\n", COGL_FIXED_TO_FLOAT (slice_qy1)); printf("qy1: %f\n", (slice_qy1));
printf("qx2: %f\n", COGL_FIXED_TO_FLOAT (slice_qx2)); printf("qx2: %f\n", (slice_qx2));
printf("qy2: %f\n", COGL_FIXED_TO_FLOAT (slice_qy2)); printf("qy2: %f\n", (slice_qy2));
printf("tx1: %f\n", COGL_FIXED_TO_FLOAT (slice_tx1)); printf("tx1: %f\n", (slice_tx1));
printf("ty1: %f\n", COGL_FIXED_TO_FLOAT (slice_ty1)); printf("ty1: %f\n", (slice_ty1));
printf("tx2: %f\n", COGL_FIXED_TO_FLOAT (slice_tx2)); printf("tx2: %f\n", (slice_tx2));
printf("ty2: %f\n", COGL_FIXED_TO_FLOAT (slice_ty2)); printf("ty2: %f\n", (slice_ty2));
#endif #endif
/* Pick and bind opengl texture object */ /* Pick and bind opengl texture object */
@ -2172,28 +2173,28 @@ _cogl_texture_quad_sw (CoglTexture *tex,
ctx->texture_target = tex->gl_target; ctx->texture_target = tex->gl_target;
ctx->texture_current = gl_handle; ctx->texture_current = gl_handle;
_cogl_texture_add_quad_vertices (COGL_FIXED_TO_FLOAT (slice_qx1), _cogl_texture_add_quad_vertices ( (slice_qx1),
COGL_FIXED_TO_FLOAT (slice_qy1), (slice_qy1),
COGL_FIXED_TO_FLOAT (slice_qx2), (slice_qx2),
COGL_FIXED_TO_FLOAT (slice_qy2), (slice_qy2),
COGL_FIXED_TO_FLOAT (slice_tx1), (slice_tx1),
COGL_FIXED_TO_FLOAT (slice_ty1), (slice_ty1),
COGL_FIXED_TO_FLOAT (slice_tx2), (slice_tx2),
COGL_FIXED_TO_FLOAT (slice_ty2)); (slice_ty2));
} }
} }
} }
static void static void
_cogl_texture_quad_hw (CoglTexture *tex, _cogl_texture_quad_hw (CoglTexture *tex,
CoglFixed x1, float x1,
CoglFixed y1, float y1,
CoglFixed x2, float x2,
CoglFixed y2, float y2,
CoglFixed tx1, float tx1,
CoglFixed ty1, float ty1,
CoglFixed tx2, float tx2,
CoglFixed ty2) float ty2)
{ {
GLuint gl_handle; GLuint gl_handle;
CoglTexSliceSpan *x_span; CoglTexSliceSpan *x_span;
@ -2209,10 +2210,10 @@ _cogl_texture_quad_hw (CoglTexture *tex,
/* If the texture coords are all in the range [0,1] then we want to /* If the texture coords are all in the range [0,1] then we want to
clamp the coords to the edge otherwise it can pull in edge pixels clamp the coords to the edge otherwise it can pull in edge pixels
from the wrong side when scaled */ from the wrong side when scaled */
if (tx1 >= 0 && tx1 <= COGL_FIXED_1 if (tx1 >= 0 && tx1 <= 1.0
&& tx2 >= 0 && tx2 <= COGL_FIXED_1 && tx2 >= 0 && tx2 <= 1.0
&& ty1 >= 0 && ty1 <= COGL_FIXED_1 && ty1 >= 0 && ty1 <= 1.0
&& ty2 >= 0 && ty2 <= COGL_FIXED_1) && ty2 >= 0 && ty2 <= 1.0)
wrap_mode = GL_CLAMP_TO_EDGE; wrap_mode = GL_CLAMP_TO_EDGE;
else else
wrap_mode = GL_REPEAT; wrap_mode = GL_REPEAT;
@ -2251,19 +2252,19 @@ _cogl_texture_quad_hw (CoglTexture *tex,
ty2 *= y_span->size; ty2 *= y_span->size;
} }
_cogl_texture_add_quad_vertices (COGL_FIXED_TO_FLOAT (x1), _cogl_texture_add_quad_vertices ( (x1),
COGL_FIXED_TO_FLOAT (y1), (y1),
COGL_FIXED_TO_FLOAT (x2), (x2),
COGL_FIXED_TO_FLOAT (y2), (y2),
COGL_FIXED_TO_FLOAT (tx1), (tx1),
COGL_FIXED_TO_FLOAT (ty1), (ty1),
COGL_FIXED_TO_FLOAT (tx2), (tx2),
COGL_FIXED_TO_FLOAT (ty2)); (ty2));
} }
void void
cogl_texture_multiple_rectangles (CoglHandle handle, cogl_texture_multiple_rectangles (CoglHandle handle,
const CoglFixed *verts, const float *verts,
guint n_rects) guint n_rects)
{ {
CoglTexture *tex; CoglTexture *tex;
@ -2314,10 +2315,10 @@ cogl_texture_multiple_rectangles (CoglHandle handle,
if (tex->slice_gl_handles->len == 1 if (tex->slice_gl_handles->len == 1
&& ((cogl_features_available (COGL_FEATURE_TEXTURE_NPOT) && ((cogl_features_available (COGL_FEATURE_TEXTURE_NPOT)
&& tex->gl_target == GL_TEXTURE_2D) && tex->gl_target == GL_TEXTURE_2D)
|| (verts[4] >= 0 && verts[4] <= COGL_FIXED_1 || (verts[4] >= 0 && verts[4] <= 1.0
&& verts[6] >= 0 && verts[6] <= COGL_FIXED_1 && verts[6] >= 0 && verts[6] <= 1.0
&& verts[5] >= 0 && verts[5] <= COGL_FIXED_1 && verts[5] >= 0 && verts[5] <= 1.0
&& verts[7] >= 0 && verts[7] <= COGL_FIXED_1))) && verts[7] >= 0 && verts[7] <= 1.0)))
_cogl_texture_quad_hw (tex, verts[0],verts[1], verts[2],verts[3], _cogl_texture_quad_hw (tex, verts[0],verts[1], verts[2],verts[3],
verts[4],verts[5], verts[6],verts[7]); verts[4],verts[5], verts[6],verts[7]);
else else
@ -2333,16 +2334,16 @@ cogl_texture_multiple_rectangles (CoglHandle handle,
void void
cogl_texture_rectangle (CoglHandle handle, cogl_texture_rectangle (CoglHandle handle,
CoglFixed x1, float x1,
CoglFixed y1, float y1,
CoglFixed x2, float x2,
CoglFixed y2, float y2,
CoglFixed tx1, float tx1,
CoglFixed ty1, float ty1,
CoglFixed tx2, float tx2,
CoglFixed ty2) float ty2)
{ {
CoglFixed verts[8]; float verts[8];
verts[0] = x1; verts[0] = x1;
verts[1] = y1; verts[1] = y1;
@ -2455,16 +2456,16 @@ cogl_texture_polygon (CoglHandle handle,
OpenGL */ OpenGL */
for (i = 0; i < n_vertices; i++, p++) for (i = 0; i < n_vertices; i++, p++)
{ {
CoglFixed tx, ty; float tx, ty;
#define CFX_F COGL_FIXED_TO_FLOAT #define CFX_F
tx = ((vertices[i].tx tx = ((vertices[i].tx
- (COGL_FIXED_FROM_INT (x_span->start) - ((float)(x_span->start)
/ tex->bitmap.width)) / tex->bitmap.width))
* tex->bitmap.width / x_span->size); * tex->bitmap.width / x_span->size);
ty = ((vertices[i].ty ty = ((vertices[i].ty
- (COGL_FIXED_FROM_INT (y_span->start) - ((float)(y_span->start)
/ tex->bitmap.height)) / tex->bitmap.height))
* tex->bitmap.height / y_span->size); * tex->bitmap.height / y_span->size);

275
clutter/cogl/gl/cogl.c
View File

@ -209,40 +209,23 @@ cogl_pop_matrix (void)
} }
void void
cogl_scale (CoglFixed x, CoglFixed y) cogl_scale (float x, float y)
{ {
glScaled (COGL_FIXED_TO_DOUBLE (x), glScalef ((float)(x),
COGL_FIXED_TO_DOUBLE (y), (float)(y),
1.0); 1.0);
} }
void void
cogl_translatex (CoglFixed x, CoglFixed y, CoglFixed z) cogl_translate (float x, float y, float z)
{ {
glTranslated (COGL_FIXED_TO_DOUBLE (x), glTranslatef (x, y, z);
COGL_FIXED_TO_DOUBLE (y),
COGL_FIXED_TO_DOUBLE (z));
} }
void void
cogl_translate (gint x, gint y, gint z) cogl_rotate (float angle, float x, float y, float z)
{ {
glTranslatef ((float)x, (float)y, (float)z); glRotatef (angle, x, y, z);
}
void
cogl_rotatex (CoglFixed angle, gint x, gint y, gint z)
{
glRotated (COGL_FIXED_TO_DOUBLE (angle),
COGL_FIXED_TO_DOUBLE (x),
COGL_FIXED_TO_DOUBLE (y),
COGL_FIXED_TO_DOUBLE (z));
}
void
cogl_rotate (gint angle, gint x, gint y, gint z)
{
glRotatef ((float)angle, (float)x, (float)y, (float)z);
} }
static inline gboolean static inline gboolean
@ -466,24 +449,24 @@ set_clip_plane (GLint plane_num,
} }
void void
_cogl_set_clip_planes (CoglFixed x_offset, _cogl_set_clip_planes (float x_offset,
CoglFixed y_offset, float y_offset,
CoglFixed width, float width,
CoglFixed height) float height)
{ {
GLfloat modelview[16], projection[16]; GLfloat modelview[16], projection[16];
GLfloat vertex_tl[4] = { COGL_FIXED_TO_FLOAT (x_offset), GLfloat vertex_tl[4] = { (x_offset),
COGL_FIXED_TO_FLOAT (y_offset), (y_offset),
0.0f, 1.0f }; 0.0f, 1.0f };
GLfloat vertex_tr[4] = { COGL_FIXED_TO_FLOAT (x_offset + width), GLfloat vertex_tr[4] = { (x_offset + width),
COGL_FIXED_TO_FLOAT (y_offset), (y_offset),
0.0f, 1.0f }; 0.0f, 1.0f };
GLfloat vertex_bl[4] = { COGL_FIXED_TO_FLOAT (x_offset), GLfloat vertex_bl[4] = { (x_offset),
COGL_FIXED_TO_FLOAT (y_offset + height), (y_offset + height),
0.0f, 1.0f }; 0.0f, 1.0f };
GLfloat vertex_br[4] = { COGL_FIXED_TO_FLOAT (x_offset + width), GLfloat vertex_br[4] = { (x_offset + width),
COGL_FIXED_TO_FLOAT (y_offset + height), (y_offset + height),
0.0f, 1.0f }; 0.0f, 1.0f };
GE( glGetFloatv (GL_MODELVIEW_MATRIX, modelview) ); GE( glGetFloatv (GL_MODELVIEW_MATRIX, modelview) );
@ -518,10 +501,10 @@ _cogl_set_clip_planes (CoglFixed x_offset,
} }
void void
_cogl_add_stencil_clip (CoglFixed x_offset, _cogl_add_stencil_clip (float x_offset,
CoglFixed y_offset, float y_offset,
CoglFixed width, float width,
CoglFixed height, float height,
gboolean first) gboolean first)
{ {
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -537,10 +520,10 @@ _cogl_add_stencil_clip (CoglFixed x_offset,
/* Punch out a hole to allow the rectangle */ /* Punch out a hole to allow the rectangle */
GE( glStencilFunc (GL_NEVER, 0x1, 0x1) ); GE( glStencilFunc (GL_NEVER, 0x1, 0x1) );
GE( glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE) ); GE( glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE) );
GE( glRectf (COGL_FIXED_TO_FLOAT (x_offset), GE( glRectf ( (x_offset),
COGL_FIXED_TO_FLOAT (y_offset), (y_offset),
COGL_FIXED_TO_FLOAT (x_offset + width), (x_offset + width),
COGL_FIXED_TO_FLOAT (y_offset + height)) ); (y_offset + height)) );
} }
else else
{ {
@ -548,10 +531,10 @@ _cogl_add_stencil_clip (CoglFixed x_offset,
rectangle */ rectangle */
GE( glStencilFunc (GL_NEVER, 0x1, 0x3) ); GE( glStencilFunc (GL_NEVER, 0x1, 0x3) );
GE( glStencilOp (GL_INCR, GL_INCR, GL_INCR) ); GE( glStencilOp (GL_INCR, GL_INCR, GL_INCR) );
GE( glRectf (COGL_FIXED_TO_FLOAT (x_offset), GE( glRectf ( (x_offset),
COGL_FIXED_TO_FLOAT (y_offset), (y_offset),
COGL_FIXED_TO_FLOAT (x_offset + width), (x_offset + width),
COGL_FIXED_TO_FLOAT (y_offset + height)) ); (y_offset + height)) );
/* Subtract one from all pixels in the stencil buffer so that /* Subtract one from all pixels in the stencil buffer so that
only pixels where both the original stencil buffer and the only pixels where both the original stencil buffer and the
@ -574,13 +557,13 @@ _cogl_add_stencil_clip (CoglFixed x_offset,
} }
void void
_cogl_set_matrix (const CoglFixed *matrix) _cogl_set_matrix (const float *matrix)
{ {
float float_matrix[16]; float float_matrix[16];
int i; int i;
for (i = 0; i < 16; i++) for (i = 0; i < 16; i++)
float_matrix[i] = COGL_FIXED_TO_FLOAT (matrix[i]); float_matrix[i] = (matrix[i]);
GE( glLoadIdentity () ); GE( glLoadIdentity () );
GE( glMultMatrixf (float_matrix) ); GE( glMultMatrixf (float_matrix) );
@ -612,20 +595,20 @@ _cogl_disable_clip_planes (void)
void void
cogl_alpha_func (COGLenum func, cogl_alpha_func (COGLenum func,
CoglFixed ref) float ref)
{ {
GE( glAlphaFunc (func, COGL_FIXED_TO_FLOAT(ref)) ); GE( glAlphaFunc (func, (ref)) );
} }
void void
cogl_perspective (CoglFixed fovy, cogl_perspective (float fovy,
CoglFixed aspect, float aspect,
CoglFixed zNear, float zNear,
CoglFixed zFar) float zFar)
{ {
CoglFixed xmax, ymax; float xmax, ymax;
CoglFixed x, y, c, d; float x, y, c, d;
CoglFixed fovy_rad_half = COGL_FIXED_MUL (fovy, COGL_FIXED_PI) / 360; float fovy_rad_half = (fovy * G_PI) / 360;
GLfloat m[16]; GLfloat m[16];
@ -645,23 +628,19 @@ cogl_perspective (CoglFixed fovy,
* 2) When working with small numbers, we are loosing significant * 2) When working with small numbers, we are loosing significant
* precision * precision
*/ */
ymax = ymax = (zNear * (sinf (fovy_rad_half) / cosf (fovy_rad_half)));
COGL_FIXED_MUL (zNear, xmax = (ymax * aspect);
COGL_FIXED_FAST_DIV (cogl_fixed_sin (fovy_rad_half),
cogl_fixed_cos (fovy_rad_half)));
xmax = COGL_FIXED_MUL (ymax, aspect); x = (zNear / xmax);
y = (zNear / ymax);
x = COGL_FIXED_FAST_DIV (zNear, xmax); c = (-(zFar + zNear) / ( zFar - zNear));
y = COGL_FIXED_FAST_DIV (zNear, ymax); d = (-(2 * zFar) * zNear) / (zFar - zNear);
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] #define M(row,col) m[col*4+row]
M(0,0) = COGL_FIXED_TO_FLOAT (x); M(0,0) = (x);
M(1,1) = COGL_FIXED_TO_FLOAT (y); M(1,1) = (y);
M(2,2) = COGL_FIXED_TO_FLOAT (c); M(2,2) = (c);
M(2,3) = COGL_FIXED_TO_FLOAT (d); M(2,3) = (d);
M(3,2) = -1.0F; M(3,2) = -1.0F;
GE( glMultMatrixf (m) ); GE( glMultMatrixf (m) );
@ -672,22 +651,22 @@ cogl_perspective (CoglFixed fovy,
memset (ctx->inverse_projection, 0, sizeof (GLfloat) * 16); memset (ctx->inverse_projection, 0, sizeof (GLfloat) * 16);
#define m ctx->inverse_projection #define m ctx->inverse_projection
M(0, 0) = 1.0f / COGL_FIXED_TO_FLOAT (x); M(0, 0) = 1.0f / (x);
M(1, 1) = 1.0f / COGL_FIXED_TO_FLOAT (y); M(1, 1) = 1.0f / (y);
M(2, 3) = -1.0f; M(2, 3) = -1.0f;
M(3, 2) = 1.0f / COGL_FIXED_TO_FLOAT (d); M(3, 2) = 1.0f / (d);
M(3, 3) = COGL_FIXED_TO_FLOAT (c) / COGL_FIXED_TO_FLOAT (d); M(3, 3) = (c) / (d);
#undef m #undef m
#undef M #undef M
} }
void void
cogl_frustum (CoglFixed left, cogl_frustum (float left,
CoglFixed right, float right,
CoglFixed bottom, float bottom,
CoglFixed top, float top,
CoglFixed z_near, float z_near,
CoglFixed z_far) float z_far)
{ {
GLfloat c, d; GLfloat c, d;
@ -696,32 +675,32 @@ cogl_frustum (CoglFixed left,
GE( glMatrixMode (GL_PROJECTION) ); GE( glMatrixMode (GL_PROJECTION) );
GE( glLoadIdentity () ); GE( glLoadIdentity () );
GE( glFrustum (COGL_FIXED_TO_DOUBLE (left), GE( glFrustum ((GLdouble)(left),
COGL_FIXED_TO_DOUBLE (right), (GLdouble)(right),
COGL_FIXED_TO_DOUBLE (bottom), (GLdouble)(bottom),
COGL_FIXED_TO_DOUBLE (top), (GLdouble)(top),
COGL_FIXED_TO_DOUBLE (z_near), (GLdouble)(z_near),
COGL_FIXED_TO_DOUBLE (z_far)) ); (GLdouble)(z_far)) );
GE( glMatrixMode (GL_MODELVIEW) ); GE( glMatrixMode (GL_MODELVIEW) );
/* Calculate and store the inverse of the matrix */ /* Calculate and store the inverse of the matrix */
memset (ctx->inverse_projection, 0, sizeof (GLfloat) * 16); memset (ctx->inverse_projection, 0, sizeof (GLfloat) * 16);
c = -COGL_FIXED_TO_FLOAT (z_far + z_near) c = - (z_far + z_near)
/ COGL_FIXED_TO_FLOAT (z_far - z_near); / (z_far - z_near);
d = -COGL_FIXED_TO_FLOAT (2 * COGL_FIXED_MUL (z_far, z_near)) d = - (2 * (z_far * z_near))
/ COGL_FIXED_TO_FLOAT (z_far - z_near); / (z_far - z_near);
#define M(row,col) ctx->inverse_projection[col*4+row] #define M(row,col) ctx->inverse_projection[col*4+row]
M(0,0) = COGL_FIXED_TO_FLOAT (right - left) M(0,0) = (right - left)
/ COGL_FIXED_TO_FLOAT (2 * z_near); / (2 * z_near);
M(0,3) = COGL_FIXED_TO_FLOAT (right + left) M(0,3) = (right + left)
/ COGL_FIXED_TO_FLOAT (2 * z_near); / (2 * z_near);
M(1,1) = COGL_FIXED_TO_FLOAT (top - bottom) M(1,1) = (top - bottom)
/ COGL_FIXED_TO_FLOAT (2 * z_near); / (2 * z_near);
M(1,3) = COGL_FIXED_TO_FLOAT (top + bottom) M(1,3) = (top + bottom)
/ COGL_FIXED_TO_FLOAT (2 * z_near); / (2 * z_near);
M(2,3) = -1.0f; M(2,3) = -1.0f;
M(3,2) = 1.0f / d; M(3,2) = 1.0f / d;
M(3,3) = c / d; M(3,3) = c / d;
@ -738,10 +717,10 @@ cogl_viewport (guint width,
void void
cogl_setup_viewport (guint width, cogl_setup_viewport (guint width,
guint height, guint height,
CoglFixed fovy, float fovy,
CoglFixed aspect, float aspect,
CoglFixed z_near, float z_near,
CoglFixed z_far) float z_far)
{ {
GLfloat z_camera; GLfloat z_camera;
@ -769,13 +748,11 @@ cogl_setup_viewport (guint width,
z_camera = DEFAULT_Z_CAMERA; z_camera = DEFAULT_Z_CAMERA;
if (fovy != COGL_FIXED_60) if (fovy != 60.0)
{ {
CoglFixed fovy_rad = COGL_FIXED_MUL (fovy, COGL_FIXED_PI) / 180; float fovy_rad = (fovy * G_PI) / 180;
z_camera = z_camera = ((sinf (fovy_rad) / cosf (fovy_rad)) / 2);
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) ); GE( glTranslatef (-0.5f, -0.5f, -z_camera) );
@ -1164,75 +1141,21 @@ cogl_features_available (CoglFeatureFlags features)
} }
void void
cogl_get_modelview_matrix (CoglFixed m[16]) cogl_get_modelview_matrix (float m[16])
{ {
GLdouble md[16]; glGetFloatv (GL_MODELVIEW_MATRIX, m);
glGetDoublev(GL_MODELVIEW_MATRIX, &md[0]);
#define M(m,row,col) m[col*4+row]
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) = 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) = 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) = 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 void
cogl_get_projection_matrix (CoglFixed m[16]) cogl_get_projection_matrix (float m[16])
{ {
GLdouble md[16]; glGetFloatv (GL_PROJECTION_MATRIX, m);
glGetDoublev(GL_PROJECTION_MATRIX, &md[0]);
#define M(m,row,col) m[col*4+row]
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) = 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) = 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) = 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 void
cogl_get_viewport (CoglFixed v[4]) cogl_get_viewport (float v[4])
{ {
GLdouble vd[4]; glGetFloatv (GL_VIEWPORT, v);
glGetDoublev(GL_VIEWPORT, &vd[0]);
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 void
@ -1263,9 +1186,9 @@ cogl_get_bitmasks (gint *red, gint *green, gint *blue, gint *alpha)
void void
cogl_fog_set (const CoglColor *fog_color, cogl_fog_set (const CoglColor *fog_color,
CoglFixed density, float density,
CoglFixed start, float start,
CoglFixed stop) float stop)
{ {
GLfloat fogColor[4]; GLfloat fogColor[4];
@ -1281,8 +1204,8 @@ cogl_fog_set (const CoglColor *fog_color,
glFogi (GL_FOG_MODE, GL_LINEAR); glFogi (GL_FOG_MODE, GL_LINEAR);
glHint (GL_FOG_HINT, GL_NICEST); glHint (GL_FOG_HINT, GL_NICEST);
glFogf (GL_FOG_DENSITY, COGL_FIXED_TO_FLOAT (density)); glFogf (GL_FOG_DENSITY, (density));
glFogf (GL_FOG_START, COGL_FIXED_TO_FLOAT (start)); glFogf (GL_FOG_START, (start));
glFogf (GL_FOG_END, COGL_FIXED_TO_FLOAT (stop)); glFogf (GL_FOG_END, (stop));
} }

2
clutter/cogl/gles/cogl-context.c
View File

@ -80,7 +80,7 @@ cogl_create_context ()
#endif #endif
/* Init OpenGL state */ /* Init OpenGL state */
GE( cogl_wrap_glTexEnvx (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) ); GE( cogl_wrap_glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) );
GE( glColorMask (TRUE, TRUE, TRUE, FALSE) ); GE( glColorMask (TRUE, TRUE, TRUE, FALSE) );
GE( glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) ); GE( glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) );
cogl_enable (0); cogl_enable (0);

10
clutter/cogl/gles/cogl-context.h
View File

@ -53,15 +53,15 @@ typedef struct
gboolean enable_backface_culling; gboolean enable_backface_culling;
/* Primitives */ /* Primitives */
CoglFixedVec2 path_start; floatVec2 path_start;
CoglFixedVec2 path_pen; floatVec2 path_pen;
GArray *path_nodes; GArray *path_nodes;
guint last_path; guint last_path;
CoglFixedVec2 path_nodes_min; floatVec2 path_nodes_min;
CoglFixedVec2 path_nodes_max; floatVec2 path_nodes_max;
/* Cache of inverse projection matrix */ /* Cache of inverse projection matrix */
CoglFixed inverse_projection[16]; float inverse_projection[16];
/* Textures */ /* Textures */
GArray *texture_handles; GArray *texture_handles;

12
clutter/cogl/gles/cogl-fbo.c
View File

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

147
clutter/cogl/gles/cogl-gles2-wrapper.c
View File

@ -104,7 +104,7 @@ cogl_gles2_wrapper_create_shader (GLenum type, const char *source)
void void
cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper) cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper)
{ {
GLfixed default_fog_color[4] = { 0, 0, 0, 0 }; GLfloat default_fog_color[4] = { 0, 0, 0, 0 };
memset (wrapper, 0, sizeof (CoglGles2Wrapper)); memset (wrapper, 0, sizeof (CoglGles2Wrapper));
@ -118,11 +118,11 @@ cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper)
/* Initialize the fogging options */ /* Initialize the fogging options */
cogl_wrap_glDisable (GL_FOG); cogl_wrap_glDisable (GL_FOG);
cogl_wrap_glFogx (GL_FOG_MODE, GL_LINEAR); cogl_wrap_glFogf (GL_FOG_MODE, GL_LINEAR);
cogl_wrap_glFogx (GL_FOG_DENSITY, COGL_FIXED_1); cogl_wrap_glFogf (GL_FOG_DENSITY, 1.0);
cogl_wrap_glFogx (GL_FOG_START, 0); cogl_wrap_glFogf (GL_FOG_START, 0);
cogl_wrap_glFogx (GL_FOG_END, 1); cogl_wrap_glFogf (GL_FOG_END, 1);
cogl_wrap_glFogxv (GL_FOG_COLOR, default_fog_color); cogl_wrap_glFogfv (GL_FOG_COLOR, default_fog_color);
/* Initialize alpha testing */ /* Initialize alpha testing */
cogl_wrap_glDisable (GL_ALPHA_TEST); cogl_wrap_glDisable (GL_ALPHA_TEST);
@ -514,15 +514,6 @@ cogl_gles2_wrapper_update_matrix (CoglGles2Wrapper *wrapper, GLenum matrix_num)
} }
} }
void
cogl_wrap_glClearColorx (GLclampx r, GLclampx g, GLclampx b, GLclampx a)
{
glClearColor (COGL_FIXED_TO_FLOAT (r),
COGL_FIXED_TO_FLOAT (g),
COGL_FIXED_TO_FLOAT (b),
COGL_FIXED_TO_FLOAT (a));
}
void void
cogl_wrap_glPushMatrix () cogl_wrap_glPushMatrix ()
{ {
@ -666,58 +657,58 @@ cogl_wrap_glMultMatrix (const float *m)
} }
void void
cogl_wrap_glMultMatrixx (const GLfixed *m) cogl_wrap_glMultMatrixf (const GLfloat *m)
{ {
float new_matrix[16]; float new_matrix[16];
int i; int i;
for (i = 0; i < 16; i++) for (i = 0; i < 16; i++)
new_matrix[i] = COGL_FIXED_TO_FLOAT (m[i]); new_matrix[i] = (m[i]);
cogl_wrap_glMultMatrix (new_matrix); cogl_wrap_glMultMatrix (new_matrix);
} }
void void
cogl_wrap_glFrustumx (GLfixed left, GLfixed right, cogl_wrap_glFrustumf (GLfloat left, GLfloat right,
GLfixed bottom, GLfixed top, GLfloat bottom, GLfloat top,
GLfixed z_near, GLfixed z_far) GLfloat z_near, GLfloat z_far)
{ {
float matrix[16]; float matrix[16];
float two_near = COGL_FIXED_TO_FLOAT (2 * z_near); float two_near = (2 * z_near);
memset (matrix, 0, sizeof (matrix)); memset (matrix, 0, sizeof (matrix));
matrix[0] = two_near / COGL_FIXED_TO_FLOAT (right - left); matrix[0] = two_near / (right - left);
matrix[5] = two_near / COGL_FIXED_TO_FLOAT (top - bottom); matrix[5] = two_near / (top - bottom);
matrix[8] = COGL_FIXED_TO_FLOAT (right + left) matrix[8] = (right + left)
/ COGL_FIXED_TO_FLOAT (right - left); / (right - left);
matrix[9] = COGL_FIXED_TO_FLOAT (top + bottom) matrix[9] = (top + bottom)
/ COGL_FIXED_TO_FLOAT (top - bottom); / (top - bottom);
matrix[10] = -COGL_FIXED_TO_FLOAT (z_far + z_near) matrix[10] = - (z_far + z_near)
/ COGL_FIXED_TO_FLOAT (z_far - z_near); / (z_far - z_near);
matrix[11] = -1.0f; matrix[11] = -1.0f;
matrix[14] = -two_near * COGL_FIXED_TO_FLOAT (z_far) matrix[14] = -two_near * (z_far)
/ COGL_FIXED_TO_FLOAT (z_far - z_near); / (z_far - z_near);
cogl_wrap_glMultMatrix (matrix); cogl_wrap_glMultMatrix (matrix);
} }
void void
cogl_wrap_glScalex (GLfixed x, GLfixed y, GLfixed z) cogl_wrap_glScalef (GLfloat x, GLfloat y, GLfloat z)
{ {
float matrix[16]; float matrix[16];
memset (matrix, 0, sizeof (matrix)); memset (matrix, 0, sizeof (matrix));
matrix[0] = COGL_FIXED_TO_FLOAT (x); matrix[0] = (x);
matrix[5] = COGL_FIXED_TO_FLOAT (y); matrix[5] = (y);
matrix[10] = COGL_FIXED_TO_FLOAT (z); matrix[10] = (z);
matrix[15] = 1.0f; matrix[15] = 1.0f;
cogl_wrap_glMultMatrix (matrix); cogl_wrap_glMultMatrix (matrix);
} }
void void
cogl_wrap_glTranslatex (GLfixed x, GLfixed y, GLfixed z) cogl_wrap_glTranslatef (GLfloat x, GLfloat y, GLfloat z)
{ {
float matrix[16]; float matrix[16];
@ -725,22 +716,22 @@ cogl_wrap_glTranslatex (GLfixed x, GLfixed y, GLfixed z)
matrix[0] = 1.0f; matrix[0] = 1.0f;
matrix[5] = 1.0f; matrix[5] = 1.0f;
matrix[10] = 1.0f; matrix[10] = 1.0f;
matrix[12] = COGL_FIXED_TO_FLOAT (x); matrix[12] = (x);
matrix[13] = COGL_FIXED_TO_FLOAT (y); matrix[13] = (y);
matrix[14] = COGL_FIXED_TO_FLOAT (z); matrix[14] = (z);
matrix[15] = 1.0f; matrix[15] = 1.0f;
cogl_wrap_glMultMatrix (matrix); cogl_wrap_glMultMatrix (matrix);
} }
void void
cogl_wrap_glRotatex (GLfixed angle, GLfixed x, GLfixed y, GLfixed z) cogl_wrap_glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{ {
float matrix[16]; float matrix[16];
float xf = COGL_FIXED_TO_FLOAT (x); float xf = (x);
float yf = COGL_FIXED_TO_FLOAT (y); float yf = (y);
float zf = COGL_FIXED_TO_FLOAT (z); float zf = (z);
float anglef = COGL_FIXED_TO_FLOAT (angle) * G_PI / 180.0f; float anglef = (angle) * G_PI / 180.0f;
float c = cosf (anglef); float c = cosf (anglef);
float s = sinf (anglef); float s = sinf (anglef);
@ -768,21 +759,21 @@ cogl_wrap_glRotatex (GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
} }
void void
cogl_wrap_glOrthox (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, cogl_wrap_glOrthof (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
GLfixed near, GLfixed far) GLfloat near, GLfloat far)
{ {
float matrix[16]; float matrix[16];
float xrange = COGL_FIXED_TO_FLOAT (right - left); float xrange = (right - left);
float yrange = COGL_FIXED_TO_FLOAT (top - bottom); float yrange = (top - bottom);
float zrange = COGL_FIXED_TO_FLOAT (far - near); float zrange = (far - near);
memset (matrix, 0, sizeof (matrix)); memset (matrix, 0, sizeof (matrix));
matrix[0] = 2.0f / xrange; matrix[0] = 2.0f / xrange;
matrix[5] = 2.0f / yrange; matrix[5] = 2.0f / yrange;
matrix[10] = 2.0f / zrange; matrix[10] = 2.0f / zrange;
matrix[12] = COGL_FIXED_TO_FLOAT (right + left) / xrange; matrix[12] = (right + left) / xrange;
matrix[13] = COGL_FIXED_TO_FLOAT (top + bottom) / yrange; matrix[13] = (top + bottom) / yrange;
matrix[14] = COGL_FIXED_TO_FLOAT (far + near) / zrange; matrix[14] = (far + near) / zrange;
matrix[15] = 1.0f; matrix[15] = 1.0f;
cogl_wrap_glMultMatrix (matrix); cogl_wrap_glMultMatrix (matrix);
@ -1033,7 +1024,7 @@ cogl_gles2_wrapper_bind_texture (GLenum target, GLuint texture,
} }
void void
cogl_wrap_glTexEnvx (GLenum target, GLenum pname, GLfixed param) cogl_wrap_glTexEnvf (GLenum target, GLenum pname, GLfloat param)
{ {
/* This function is only used to set the texture mode once to /* This function is only used to set the texture mode once to
GL_MODULATE. The shader is hard-coded to modulate the texture so GL_MODULATE. The shader is hard-coded to modulate the texture so
@ -1143,30 +1134,17 @@ cogl_wrap_glAlphaFunc (GLenum func, GLclampf ref)
} }
void void
cogl_wrap_glColor4x (GLclampx r, GLclampx g, GLclampx b, GLclampx a) cogl_wrap_glColor4f (GLclampf r, GLclampf g, GLclampf b, GLclampf a)
{ {
glVertexAttrib4f (COGL_GLES2_WRAPPER_COLOR_ATTRIB, glVertexAttrib4f (COGL_GLES2_WRAPPER_COLOR_ATTRIB, r, g, b, a);
COGL_FIXED_TO_FLOAT (r),
COGL_FIXED_TO_FLOAT (g),
COGL_FIXED_TO_FLOAT (b),
COGL_FIXED_TO_FLOAT (a));
} }
void void
cogl_wrap_glClipPlanex (GLenum plane, GLfixed *equation) cogl_wrap_glClipPlanef (GLenum plane, GLfloat *equation)
{ {
/* FIXME */ /* FIXME */
} }
static void
cogl_gles2_float_array_to_fixed (int size,
const GLfloat *floats,
GLfixed *fixeds)
{
while (size-- > 0)
*(fixeds++) = COGL_FIXED_FROM_FLOAT (*(floats++));
}
void void
cogl_wrap_glGetIntegerv (GLenum pname, GLint *params) cogl_wrap_glGetIntegerv (GLenum pname, GLint *params)
{ {
@ -1185,37 +1163,30 @@ cogl_wrap_glGetIntegerv (GLenum pname, GLint *params)
} }
void void
cogl_wrap_glGetFixedv (GLenum pname, GLfixed *params) cogl_wrap_glGetFloatv (GLenum pname, GLfloat *params)
{ {
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL); _COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
switch (pname) switch (pname)
{ {
case GL_MODELVIEW_MATRIX: case GL_MODELVIEW_MATRIX:
cogl_gles2_float_array_to_fixed (16, w->modelview_stack memcpy (params, w->modelview_stack + w->modelview_stack_pos * 16,
+ w->modelview_stack_pos * 16, sizeof (GLfloat) * 16);
params);
break; break;
case GL_PROJECTION_MATRIX: case GL_PROJECTION_MATRIX:
cogl_gles2_float_array_to_fixed (16, w->projection_stack memcpy (params, w->projection_stack + w->projection_stack_pos * 16,
+ w->projection_stack_pos * 16, sizeof (GLfloat) * 16);
params);
break; break;
case GL_VIEWPORT: case GL_VIEWPORT:
{ glGetFloatv (GL_VIEWPORT, params);
GLfloat v[4];
glGetFloatv (GL_VIEWPORT, v);
cogl_gles2_float_array_to_fixed (4, v, params);
}
break; break;
} }
} }
void void
cogl_wrap_glFogx (GLenum pname, GLfixed param) cogl_wrap_glFogf (GLenum pname, GLfloat param)
{ {
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL); _COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
@ -1227,23 +1198,23 @@ cogl_wrap_glFogx (GLenum pname, GLfixed param)
case GL_FOG_DENSITY: case GL_FOG_DENSITY:
_COGL_GLES2_CHANGE_UNIFORM (w, FOG_DENSITY, fog_density, _COGL_GLES2_CHANGE_UNIFORM (w, FOG_DENSITY, fog_density,
COGL_FIXED_TO_FLOAT (param)); (param));
break; break;
case GL_FOG_START: case GL_FOG_START:
_COGL_GLES2_CHANGE_UNIFORM (w, FOG_START, fog_start, _COGL_GLES2_CHANGE_UNIFORM (w, FOG_START, fog_start,
COGL_FIXED_TO_FLOAT (param)); (param));
break; break;
case GL_FOG_END: case GL_FOG_END:
_COGL_GLES2_CHANGE_UNIFORM (w, FOG_END, fog_end, _COGL_GLES2_CHANGE_UNIFORM (w, FOG_END, fog_end,
COGL_FIXED_TO_FLOAT (param)); (param));
break; break;
} }
} }
void void
cogl_wrap_glFogxv (GLenum pname, const GLfixed *params) cogl_wrap_glFogfv (GLenum pname, const GLfloat *params)
{ {
int i; int i;
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL); _COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
@ -1251,7 +1222,7 @@ cogl_wrap_glFogxv (GLenum pname, const GLfixed *params)
if (pname == GL_FOG_COLOR) if (pname == GL_FOG_COLOR)
{ {
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++)
w->fog_color[i] = COGL_FIXED_TO_FLOAT (params[i]); w->fog_color[i] = (params[i]);
w->dirty_uniforms |= COGL_GLES2_DIRTY_FOG_COLOR; w->dirty_uniforms |= COGL_GLES2_DIRTY_FOG_COLOR;
} }

59
clutter/cogl/gles/cogl-gles2-wrapper.h
View File

@ -203,22 +203,20 @@ struct _CoglGles2WrapperShader
void cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper); void cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper);
void cogl_gles2_wrapper_deinit (CoglGles2Wrapper *wrapper); void cogl_gles2_wrapper_deinit (CoglGles2Wrapper *wrapper);
void cogl_wrap_glClearColorx (GLclampx r, GLclampx g, GLclampx b, GLclampx a);
void cogl_wrap_glPushMatrix (); void cogl_wrap_glPushMatrix ();
void cogl_wrap_glPopMatrix (); void cogl_wrap_glPopMatrix ();
void cogl_wrap_glMatrixMode (GLenum mode); void cogl_wrap_glMatrixMode (GLenum mode);
void cogl_wrap_glLoadIdentity (); void cogl_wrap_glLoadIdentity ();
void cogl_wrap_glMultMatrixx (const GLfixed *m); void cogl_wrap_glMultMatrixf (const GLfloat *m);
void cogl_wrap_glFrustumx (GLfixed left, GLfixed right, void cogl_wrap_glFrustumf (GLfloat left, GLfloat right,
GLfixed bottom, GLfixed top, GLfloat bottom, GLfloat top,
GLfixed z_near, GLfixed z_far); GLfloat z_near, GLfloat z_far);
void cogl_wrap_glScalex (GLfixed x, GLfixed y, GLfixed z); void cogl_wrap_glScalef (GLfloat x, GLfloat y, GLfloat z);
void cogl_wrap_glTranslatex (GLfixed x, GLfixed y, GLfixed z); void cogl_wrap_glTranslatef (GLfloat x, GLfloat y, GLfloat z);
void cogl_wrap_glRotatex (GLfixed angle, GLfixed x, GLfixed y, GLfixed z); void cogl_wrap_glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
void cogl_wrap_glOrthox (GLfixed left, GLfixed right, void cogl_wrap_glOrthof (GLfloat left, GLfloat right,
GLfixed bottom, GLfixed top, GLfloat bottom, GLfloat top,
GLfixed near, GLfixed far); GLfloat near, GLfloat far);
void cogl_wrap_glEnable (GLenum cap); void cogl_wrap_glEnable (GLenum cap);
void cogl_wrap_glDisable (GLenum cap); void cogl_wrap_glDisable (GLenum cap);
@ -232,22 +230,22 @@ void cogl_wrap_glColorPointer (GLint size, GLenum type, GLsizei stride,
void cogl_wrap_glNormalPointer (GLenum type, GLsizei stride, void cogl_wrap_glNormalPointer (GLenum type, GLsizei stride,
const GLvoid *pointer); const GLvoid *pointer);
void cogl_wrap_glTexEnvx (GLenum target, GLenum pname, GLfixed param); void cogl_wrap_glTexEnvf (GLenum target, GLenum pname, GLfloat param);
void cogl_wrap_glEnableClientState (GLenum array); void cogl_wrap_glEnableClientState (GLenum array);
void cogl_wrap_glDisableClientState (GLenum array); void cogl_wrap_glDisableClientState (GLenum array);
void cogl_wrap_glAlphaFunc (GLenum func, GLclampf ref); void cogl_wrap_glAlphaFunc (GLenum func, GLclampf ref);
void cogl_wrap_glColor4x (GLclampx r, GLclampx g, GLclampx b, GLclampx a); void cogl_wrap_glColor4f (GLclampf r, GLclampf g, GLclampf b, GLclampf a);
void cogl_wrap_glClipPlanex (GLenum plane, GLfixed *equation); void cogl_wrap_glClipPlanef (GLenum plane, GLfloat *equation);
void cogl_wrap_glGetIntegerv (GLenum pname, GLint *params); void cogl_wrap_glGetIntegerv (GLenum pname, GLint *params);
void cogl_wrap_glGetFixedv (GLenum pname, GLfixed *params); void cogl_wrap_glGetFloatv (GLenum pname, GLfloat *params);
void cogl_wrap_glFogx (GLenum pname, GLfixed param); void cogl_wrap_glFogf (GLenum pname, GLfloat param);
void cogl_wrap_glFogxv (GLenum pname, const GLfixed *params); void cogl_wrap_glFogfv (GLenum pname, const GLfloat *params);
void cogl_wrap_glDrawArrays (GLenum mode, GLint first, GLsizei count); void cogl_wrap_glDrawArrays (GLenum mode, GLint first, GLsizei count);
void cogl_wrap_glDrawElements (GLenum mode, GLsizei count, GLenum type, void cogl_wrap_glDrawElements (GLenum mode, GLsizei count, GLenum type,
@ -273,35 +271,34 @@ void _cogl_gles2_clear_cache_for_program (CoglHandle program);
/* If we're not using GL ES 2 then just use the GL functions /* If we're not using GL ES 2 then just use the GL functions
directly */ directly */
#define cogl_wrap_glClearColorx glClearColorx
#define cogl_wrap_glDrawArrays glDrawArrays #define cogl_wrap_glDrawArrays glDrawArrays
#define cogl_wrap_glDrawElements glDrawElements #define cogl_wrap_glDrawElements glDrawElements
#define cogl_wrap_glPushMatrix glPushMatrix #define cogl_wrap_glPushMatrix glPushMatrix
#define cogl_wrap_glPopMatrix glPopMatrix #define cogl_wrap_glPopMatrix glPopMatrix
#define cogl_wrap_glMatrixMode glMatrixMode #define cogl_wrap_glMatrixMode glMatrixMode
#define cogl_wrap_glLoadIdentity glLoadIdentity #define cogl_wrap_glLoadIdentity glLoadIdentity
#define cogl_wrap_glMultMatrixx glMultMatrixx #define cogl_wrap_glMultMatrixf glMultMatrixf
#define cogl_wrap_glFrustumx glFrustumx #define cogl_wrap_glFrustumf glFrustumf
#define cogl_wrap_glScalex glScalex #define cogl_wrap_glScalef glScalef
#define cogl_wrap_glTranslatex glTranslatex #define cogl_wrap_glTranslatef glTranslatef
#define cogl_wrap_glRotatex glRotatex #define cogl_wrap_glRotatef glRotatef
#define cogl_wrap_glOrthox glOrthox #define cogl_wrap_glOrthof glOrthof
#define cogl_wrap_glEnable glEnable #define cogl_wrap_glEnable glEnable
#define cogl_wrap_glDisable glDisable #define cogl_wrap_glDisable glDisable
#define cogl_wrap_glTexCoordPointer glTexCoordPointer #define cogl_wrap_glTexCoordPointer glTexCoordPointer
#define cogl_wrap_glVertexPointer glVertexPointer #define cogl_wrap_glVertexPointer glVertexPointer
#define cogl_wrap_glColorPointer glColorPointer #define cogl_wrap_glColorPointer glColorPointer
#define cogl_wrap_glNormalPointer glNormalPointer #define cogl_wrap_glNormalPointer glNormalPointer
#define cogl_wrap_glTexEnvx glTexEnvx #define cogl_wrap_glTexEnvf glTexEnvf
#define cogl_wrap_glEnableClientState glEnableClientState #define cogl_wrap_glEnableClientState glEnableClientState
#define cogl_wrap_glDisableClientState glDisableClientState #define cogl_wrap_glDisableClientState glDisableClientState
#define cogl_wrap_glAlphaFunc glAlphaFunc #define cogl_wrap_glAlphaFunc glAlphaFunc
#define cogl_wrap_glColor4x glColor4x #define cogl_wrap_glColor4f glColor4f
#define cogl_wrap_glClipPlanex glClipPlanex #define cogl_wrap_glClipPlanef glClipPlanef
#define cogl_wrap_glGetIntegerv glGetIntegerv #define cogl_wrap_glGetIntegerv glGetIntegerv
#define cogl_wrap_glGetFixedv glGetFixedv #define cogl_wrap_glGetFloatv glGetFloatv
#define cogl_wrap_glFogx glFogx #define cogl_wrap_glFogf glFogf
#define cogl_wrap_glFogxv glFogxv #define cogl_wrap_glFogfv glFogfv
#define cogl_wrap_glTexParameteri glTexParameteri #define cogl_wrap_glTexParameteri glTexParameteri
/* The extra third parameter of the bind texture wrapper isn't needed /* The extra third parameter of the bind texture wrapper isn't needed

128
clutter/cogl/gles/cogl-primitives.c
View File

@ -34,63 +34,35 @@
#include <string.h> #include <string.h>
#include <gmodule.h> #include <gmodule.h>
#include <math.h>
#define _COGL_MAX_BEZ_RECURSE_DEPTH 16 #define _COGL_MAX_BEZ_RECURSE_DEPTH 16
void void
_cogl_rectangle (gint x, _cogl_rectangle (float x,
gint y, float y,
guint width, float width,
guint height) float height)
{ {
/* 32-bit integers are not supported as coord types GLfloat rect_verts[8] = {
in GLES . Fixed type has got 16 bits left of the (GLfloat) x, (GLfloat) y,
point which is equal to short anyway. */ (GLfloat) (x + width), (GLfloat) y,
(GLfloat) x, (GLfloat) (y + height),
GLshort rect_verts[8] = { (GLfloat) (x + width), (GLfloat) (y + height)
(GLshort) x, (GLshort) y,
(GLshort) (x + width), (GLshort) y,
(GLshort) x, (GLshort) (y + height),
(GLshort) (x + width), (GLshort) (y + height)
}; };
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
cogl_enable (COGL_ENABLE_VERTEX_ARRAY cogl_enable (COGL_ENABLE_VERTEX_ARRAY
| (ctx->color_alpha < 255 ? COGL_ENABLE_BLEND : 0)); | (ctx->color_alpha < 255 ? COGL_ENABLE_BLEND : 0));
GE ( cogl_wrap_glVertexPointer (2, GL_SHORT, 0, rect_verts ) ); GE ( cogl_wrap_glVertexPointer (2, GL_FLOAT, 0, rect_verts ) );
GE ( cogl_wrap_glDrawArrays (GL_TRIANGLE_STRIP, 0, 4) ); GE ( cogl_wrap_glDrawArrays (GL_TRIANGLE_STRIP, 0, 4) );
} }
void
_cogl_rectanglex (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height)
{
GLfixed rect_verts[8] = {
x, y,
x + width, y,
x, y + height,
x + width, y + height
};
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
cogl_enable (COGL_ENABLE_VERTEX_ARRAY
| (ctx->color_alpha < 255
? COGL_ENABLE_BLEND : 0));
GE( cogl_wrap_glVertexPointer (2, GL_FIXED, 0, rect_verts) );
GE( cogl_wrap_glDrawArrays (GL_TRIANGLE_STRIP, 0, 4) );
}
void void
_cogl_path_add_node (gboolean new_sub_path, _cogl_path_add_node (gboolean new_sub_path,
CoglFixed x, float x,
CoglFixed y) float y)
{ {
CoglPathNode new_node; CoglPathNode new_node;
@ -147,19 +119,17 @@ _cogl_path_stroke_nodes ()
} }
static void static void
_cogl_path_get_bounds (CoglFixedVec2 nodes_min, _cogl_path_get_bounds (floatVec2 nodes_min,
CoglFixedVec2 nodes_max, floatVec2 nodes_max,
gint *bounds_x, float *bounds_x,
gint *bounds_y, float *bounds_y,
guint *bounds_w, float *bounds_w,
guint *bounds_h) float *bounds_h)
{ {
*bounds_x = COGL_FIXED_FLOOR (nodes_min.x); *bounds_x = nodes_min.x;
*bounds_y = COGL_FIXED_FLOOR (nodes_min.y); *bounds_y = nodes_min.y;
*bounds_w = COGL_FIXED_CEIL (nodes_max.x *bounds_w = nodes_max.x - *bounds_x;
- COGL_FIXED_FROM_INT (*bounds_x)); *bounds_h = nodes_max.y - *bounds_y;
*bounds_h = COGL_FIXED_CEIL (nodes_max.y
- COGL_FIXED_FROM_INT (*bounds_y));
} }
static gint compare_ints (gconstpointer a, static gint compare_ints (gconstpointer a,
@ -169,18 +139,18 @@ static gint compare_ints (gconstpointer a,
} }
void void
_cogl_add_path_to_stencil_buffer (CoglFixedVec2 nodes_min, _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
CoglFixedVec2 nodes_max, floatVec2 nodes_max,
guint path_size, guint path_size,
CoglPathNode *path, CoglPathNode *path,
gboolean merge) gboolean merge)
{ {
guint path_start = 0; guint path_start = 0;
guint sub_path_num = 0; guint sub_path_num = 0;
gint bounds_x; float bounds_x;
gint bounds_y; float bounds_y;
guint bounds_w; float bounds_w;
guint bounds_h; float bounds_h;
_cogl_path_get_bounds (nodes_min, nodes_max, _cogl_path_get_bounds (nodes_min, nodes_max,
&bounds_x, &bounds_y, &bounds_w, &bounds_h); &bounds_x, &bounds_y, &bounds_w, &bounds_h);
@ -244,12 +214,8 @@ _cogl_add_path_to_stencil_buffer (CoglFixedVec2 nodes_min,
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) ); GE( cogl_wrap_glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glPushMatrix () ); GE( cogl_wrap_glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () ); GE( cogl_wrap_glLoadIdentity () );
cogl_rectanglex (-COGL_FIXED_1, -COGL_FIXED_1, cogl_rectangle (-1.0, -1.0, 2, 2);
COGL_FIXED_FROM_INT (2), cogl_rectangle (-1.0, -1.0, 2, 2);
COGL_FIXED_FROM_INT (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_glPopMatrix () );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) ); GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPopMatrix () ); GE( cogl_wrap_glPopMatrix () );
@ -292,14 +258,14 @@ _cogl_path_fill_nodes_scanlines (CoglPathNode *path,
for (i=0; i < bounds_h; i++) for (i=0; i < bounds_h; i++)
scanlines[i]=NULL; scanlines[i]=NULL;
first_x = prev_x = COGL_FIXED_TO_INT (path->x); first_x = prev_x = (path->x);
first_y = prev_y = COGL_FIXED_TO_INT (path->y); first_y = prev_y = (path->y);
/* create scanline intersection list */ /* create scanline intersection list */
for (i=1; i < path_size; i++) for (i=1; i < path_size; i++)
{ {
gint dest_x = COGL_FIXED_TO_INT (path[i].x); gint dest_x = (path[i].x);
gint dest_y = COGL_FIXED_TO_INT (path[i].y); gint dest_y = (path[i].y);
gint ydir; gint ydir;
gint dx; gint dx;
gint dy; gint dy;
@ -362,7 +328,7 @@ _cogl_path_fill_nodes_scanlines (CoglPathNode *path,
{ {
gint spans = 0; gint spans = 0;
gint span_no; gint span_no;
GLfixed *coords; GLfloat *coords;
/* count number of spans */ /* count number of spans */
for (i=0; i < bounds_h; i++) for (i=0; i < bounds_h; i++)
@ -380,7 +346,7 @@ _cogl_path_fill_nodes_scanlines (CoglPathNode *path,
iter = next->next; iter = next->next;
} }
} }
coords = g_malloc0 (spans * sizeof (GLfixed) * 3 * 2 * 2); coords = g_malloc0 (spans * sizeof (GLfloat) * 3 * 2 * 2);
span_no = 0; span_no = 0;
/* build list of triangles */ /* build list of triangles */
@ -390,15 +356,15 @@ _cogl_path_fill_nodes_scanlines (CoglPathNode *path,
while (iter) while (iter)
{ {
GSList *next = iter->next; GSList *next = iter->next;
GLfixed x0, x1; GLfloat x0, x1;
GLfixed y0, y1; GLfloat y0, y1;
if (!next) if (!next)
break; break;
x0 = COGL_FIXED_FROM_INT (GPOINTER_TO_INT (iter->data)); x0 = (float)(GPOINTER_TO_INT (iter->data));
x1 = COGL_FIXED_FROM_INT (GPOINTER_TO_INT (next->data)); x1 = (float)(GPOINTER_TO_INT (next->data));
y0 = COGL_FIXED_FROM_INT (bounds_y + i); y0 = (float)(bounds_y + i);
y1 = COGL_FIXED_FROM_INT (bounds_y + i + 1) + 2048; y1 = (float)(bounds_y + i + 1) + 2048;
/* render scanlines 1.0625 high to avoid gaps when /* render scanlines 1.0625 high to avoid gaps when
transformed */ transformed */
@ -435,10 +401,10 @@ _cogl_path_fill_nodes_scanlines (CoglPathNode *path,
void void
_cogl_path_fill_nodes () _cogl_path_fill_nodes ()
{ {
gint bounds_x; float bounds_x;
gint bounds_y; float bounds_y;
guint bounds_w; float bounds_w;
guint bounds_h; float bounds_h;
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);

241
clutter/cogl/gles/cogl-texture.c
View File

@ -39,6 +39,7 @@
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h>
#define glVertexPointer cogl_wrap_glVertexPointer #define glVertexPointer cogl_wrap_glVertexPointer
#define glTexCoordPointer cogl_wrap_glTexCoordPointer #define glTexCoordPointer cogl_wrap_glTexCoordPointer
@ -63,15 +64,15 @@ struct _CoglSpanIter
gint index; gint index;
GArray *array; GArray *array;
CoglTexSliceSpan *span; CoglTexSliceSpan *span;
CoglFixed pos; float pos;
CoglFixed next_pos; float next_pos;
CoglFixed origin; float origin;
CoglFixed cover_start; float cover_start;
CoglFixed cover_end; float cover_end;
CoglFixed intersect_start; float intersect_start;
CoglFixed intersect_end; float intersect_end;
CoglFixed intersect_start_local; float intersect_start_local;
CoglFixed intersect_end_local; float intersect_end_local;
gboolean intersects; gboolean intersects;
}; };
@ -116,7 +117,7 @@ _cogl_span_iter_update (CoglSpanIter *iter)
/* Offset next position by span size */ /* Offset next position by span size */
iter->next_pos = iter->pos + iter->next_pos = iter->pos +
COGL_FIXED_FROM_INT (iter->span->size - iter->span->waste); (float)(iter->span->size - iter->span->waste);
/* Check if span intersects the area to cover */ /* Check if span intersects the area to cover */
if (iter->next_pos <= iter->cover_start || if (iter->next_pos <= iter->cover_start ||
@ -145,9 +146,9 @@ _cogl_span_iter_update (CoglSpanIter *iter)
static void static void
_cogl_span_iter_begin (CoglSpanIter *iter, _cogl_span_iter_begin (CoglSpanIter *iter,
GArray *array, GArray *array,
CoglFixed origin, float origin,
CoglFixed cover_start, float cover_start,
CoglFixed cover_end) float cover_end)
{ {
/* Copy info */ /* Copy info */
iter->index = 0; iter->index = 0;
@ -398,10 +399,10 @@ _cogl_texture_draw_and_read (CoglTexture *tex,
GLint *viewport) GLint *viewport)
{ {
gint bpp; gint bpp;
CoglFixed rx1, ry1; float rx1, ry1;
CoglFixed rx2, ry2; float rx2, ry2;
CoglFixed tx1, ty1; float tx1, ty1;
CoglFixed tx2, ty2; float tx2, ty2;
int bw, bh; int bw, bh;
CoglBitmap rect_bmp; CoglBitmap rect_bmp;
CoglHandle handle; CoglHandle handle;
@ -422,9 +423,9 @@ _cogl_texture_draw_and_read (CoglTexture *tex,
/* Draw the texture image */ /* Draw the texture image */
cogl_texture_rectangle (handle, cogl_texture_rectangle (handle,
0, 0, 0, 0,
COGL_FIXED_FROM_INT (tex->bitmap.width), (float)(tex->bitmap.width),
COGL_FIXED_FROM_INT (tex->bitmap.height), (float)(tex->bitmap.height),
0, 0, COGL_FIXED_1, COGL_FIXED_1); 0, 0, 1.0, 1.0);
/* Read into target bitmap */ /* Read into target bitmap */
prep_for_gl_pixels_download (tex->bitmap.rowstride); prep_for_gl_pixels_download (tex->bitmap.rowstride);
@ -439,7 +440,7 @@ _cogl_texture_draw_and_read (CoglTexture *tex,
ry1 = 0; ry2 = 0; ry1 = 0; ry2 = 0;
ty1 = 0; ty2 = 0; ty1 = 0; ty2 = 0;
#define CFIX COGL_FIXED_FROM_INT #define CFIX (float)
/* Walk Y axis until whole bitmap height consumed */ /* Walk Y axis until whole bitmap height consumed */
for (bh = tex->bitmap.height; bh > 0; bh -= viewport[3]) for (bh = tex->bitmap.height; bh > 0; bh -= viewport[3])
@ -450,7 +451,7 @@ _cogl_texture_draw_and_read (CoglTexture *tex,
/* Normalized texture Y coords */ /* Normalized texture Y coords */
ty1 = ty2; ty1 = ty2;
ty2 = COGL_FIXED_DIV (CFIX (ry2), CFIX (tex->bitmap.height)); ty2 = (CFIX (ry2) / CFIX (tex->bitmap.height));
rx1 = 0; rx2 = 0; rx1 = 0; rx2 = 0;
tx1 = 0; tx2 = 0; tx1 = 0; tx2 = 0;
@ -464,7 +465,7 @@ _cogl_texture_draw_and_read (CoglTexture *tex,
/* Normalized texture X coords */ /* Normalized texture X coords */
tx1 = tx2; tx1 = tx2;
tx2 = COGL_FIXED_DIV (CFIX (rx2), CFIX (tex->bitmap.width)); tx2 = (CFIX (rx2) / CFIX (tex->bitmap.width));
/* Clear buffer with transparent black, draw with white /* Clear buffer with transparent black, draw with white
for direct copy to framebuffer */ for direct copy to framebuffer */
@ -544,10 +545,10 @@ _cogl_texture_download_from_gl (CoglTexture *tex,
GE( cogl_wrap_glPushMatrix () ); GE( cogl_wrap_glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () ); GE( cogl_wrap_glLoadIdentity () );
GE( cogl_wrap_glOrthox (0, COGL_FIXED_FROM_INT (viewport[2]), GE( cogl_wrap_glOrthof (0, (float)(viewport[2]),
0, COGL_FIXED_FROM_INT (viewport[3]), 0, (float)(viewport[3]),
COGL_FIXED_FROM_INT (0), (float)(0),
COGL_FIXED_FROM_INT (100)) ); (float)(100)) );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) ); GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPushMatrix () ); GE( cogl_wrap_glPushMatrix () );
@ -662,8 +663,8 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
/* Iterate vertical spans */ /* Iterate vertical spans */
for (source_y = src_y, for (source_y = src_y,
_cogl_span_iter_begin (&y_iter, tex->slice_y_spans, _cogl_span_iter_begin (&y_iter, tex->slice_y_spans,
0, COGL_FIXED_FROM_INT (dst_y), 0, (float)(dst_y),
COGL_FIXED_FROM_INT (dst_y + height)); (float)(dst_y + height));
!_cogl_span_iter_end (&y_iter); !_cogl_span_iter_end (&y_iter);
@ -683,8 +684,8 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
/* Iterate horizontal spans */ /* Iterate horizontal spans */
for (source_x = src_x, for (source_x = src_x,
_cogl_span_iter_begin (&x_iter, tex->slice_x_spans, _cogl_span_iter_begin (&x_iter, tex->slice_x_spans,
0, COGL_FIXED_FROM_INT (dst_x), 0, (float)(dst_x),
COGL_FIXED_FROM_INT (dst_x + width)); (float)(dst_x + width));
!_cogl_span_iter_end (&x_iter); !_cogl_span_iter_end (&x_iter);
@ -702,15 +703,15 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
x_iter.index); x_iter.index);
/* Pick intersection width and height */ /* Pick intersection width and height */
inter_w = COGL_FIXED_TO_INT (x_iter.intersect_end - inter_w = (x_iter.intersect_end -
x_iter.intersect_start); x_iter.intersect_start);
inter_h = COGL_FIXED_TO_INT (y_iter.intersect_end - inter_h = (y_iter.intersect_end -
y_iter.intersect_start); y_iter.intersect_start);
/* Localize intersection top-left corner to slice*/ /* Localize intersection top-left corner to slice*/
local_x = COGL_FIXED_TO_INT (x_iter.intersect_start - local_x = (x_iter.intersect_start -
x_iter.pos); x_iter.pos);
local_y = COGL_FIXED_TO_INT (y_iter.intersect_start - local_y = (y_iter.intersect_start -
y_iter.pos); y_iter.pos);
/* Pick slice GL handle */ /* Pick slice GL handle */
@ -768,7 +769,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
guint wx, wy; guint wx, wy;
src = source_bmp->data src = source_bmp->data
+ (src_y + COGL_FIXED_TO_INT (y_iter.intersect_start) + (src_y + ((int)y_iter.intersect_start)
- dst_y) - dst_y)
* source_bmp->rowstride * source_bmp->rowstride
+ (src_x + x_span->start + x_span->size - x_span->waste + (src_x + x_span->start + x_span->size - x_span->waste
@ -813,7 +814,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
guint copy_width; guint copy_width;
src = source_bmp->data src = source_bmp->data
+ (src_x + COGL_FIXED_TO_INT (x_iter.intersect_start) + (src_x + ((int)x_iter.intersect_start)
- dst_x) - dst_x)
* bpp * bpp
+ (src_y + y_span->start + y_span->size - y_span->waste + (src_y + y_span->start + y_span->size - y_span->waste
@ -2148,24 +2149,24 @@ _cogl_texture_add_quad_vertices (GLfloat x1, GLfloat y1,
static void static void
_cogl_texture_quad_sw (CoglTexture *tex, _cogl_texture_quad_sw (CoglTexture *tex,
CoglFixed x1, float x1,
CoglFixed y1, float y1,
CoglFixed x2, float x2,
CoglFixed y2, float y2,
CoglFixed tx1, float tx1,
CoglFixed ty1, float ty1,
CoglFixed tx2, float tx2,
CoglFixed ty2) float ty2)
{ {
CoglSpanIter iter_x , iter_y; CoglSpanIter iter_x , iter_y;
CoglFixed tw , th; float tw , th;
CoglFixed tqx , tqy; float tqx , tqy;
CoglFixed first_tx , first_ty; float first_tx , first_ty;
CoglFixed first_qx , first_qy; float first_qx , first_qy;
CoglFixed slice_tx1 , slice_ty1; float slice_tx1 , slice_ty1;
CoglFixed slice_tx2 , slice_ty2; float slice_tx2 , slice_ty2;
CoglFixed slice_qx1 , slice_qy1; float slice_qx1 , slice_qy1;
CoglFixed slice_qx2 , slice_qy2; float slice_qx2 , slice_qy2;
GLuint gl_handle; GLuint gl_handle;
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -2180,7 +2181,7 @@ _cogl_texture_quad_sw (CoglTexture *tex,
slices */ slices */
if (tx2 < tx1) if (tx2 < tx1)
{ {
CoglFixed temp = x1; float temp = x1;
x1 = x2; x1 = x2;
x2 = temp; x2 = temp;
temp = tx1; temp = tx1;
@ -2189,7 +2190,7 @@ _cogl_texture_quad_sw (CoglTexture *tex,
} }
if (ty2 < ty1) if (ty2 < ty1)
{ {
CoglFixed temp = y1; float temp = y1;
y1 = y2; y1 = y2;
y2 = temp; y2 = temp;
temp = ty1; temp = ty1;
@ -2198,27 +2199,27 @@ _cogl_texture_quad_sw (CoglTexture *tex,
} }
/* Scale ratio from texture to quad widths */ /* Scale ratio from texture to quad widths */
tw = COGL_FIXED_FROM_INT (tex->bitmap.width); tw = (float)(tex->bitmap.width);
th = COGL_FIXED_FROM_INT (tex->bitmap.height); th = (float)(tex->bitmap.height);
tqx = COGL_FIXED_DIV (x2 - x1, COGL_FIXED_MUL (tw, (tx2 - tx1))); tqx = (x2 - x1 / (tw * (tx2 - tx1)));
tqy = COGL_FIXED_DIV (y2 - y1, COGL_FIXED_MUL (th, (ty2 - ty1))); tqy = (y2 - y1 / (th * (ty2 - ty1)));
/* Integral texture coordinate for first tile */ /* Integral texture coordinate for first tile */
first_tx = COGL_FIXED_FROM_INT (COGL_FIXED_FLOOR (tx1)); first_tx = (float)(floorf (tx1));
first_ty = COGL_FIXED_FROM_INT (COGL_FIXED_FLOOR (ty1)); first_ty = (float)(floorf (ty1));
/* Denormalize texture coordinates */ /* Denormalize texture coordinates */
first_tx = COGL_FIXED_MUL (first_tx, tw); first_tx = (first_tx * tw);
first_ty = COGL_FIXED_MUL (first_ty, th); first_ty = (first_ty * th);
tx1 = COGL_FIXED_MUL (tx1, tw); tx1 = (tx1 * tw);
ty1 = COGL_FIXED_MUL (ty1, th); ty1 = (ty1 * th);
tx2 = COGL_FIXED_MUL (tx2, tw); tx2 = (tx2 * tw);
ty2 = COGL_FIXED_MUL (ty2, th); ty2 = (ty2 * th);
/* Quad coordinate of the first tile */ /* Quad coordinate of the first tile */
first_qx = x1 - COGL_FIXED_MUL (tx1 - first_tx, tqx); first_qx = x1 - (tx1 - first_tx * tqx);
first_qy = y1 - COGL_FIXED_MUL (ty1 - first_ty, tqy); first_qy = y1 - (ty1 - first_ty * tqy);
/* Iterate until whole quad height covered */ /* Iterate until whole quad height covered */
@ -2232,10 +2233,10 @@ _cogl_texture_quad_sw (CoglTexture *tex,
/* Span-quad intersection in quad coordinates */ /* Span-quad intersection in quad coordinates */
slice_qy1 = first_qy + slice_qy1 = first_qy +
COGL_FIXED_MUL (iter_y.intersect_start - first_ty, tqy); (iter_y.intersect_start - first_ty * tqy);
slice_qy2 = first_qy + slice_qy2 = first_qy +
COGL_FIXED_MUL (iter_y.intersect_end - first_ty, tqy); (iter_y.intersect_end - first_ty * tqy);
/* Localize slice texture coordinates */ /* Localize slice texture coordinates */
slice_ty1 = iter_y.intersect_start - iter_y.pos; slice_ty1 = iter_y.intersect_start - iter_y.pos;
@ -2257,10 +2258,10 @@ _cogl_texture_quad_sw (CoglTexture *tex,
/* Span-quad intersection in quad coordinates */ /* Span-quad intersection in quad coordinates */
slice_qx1 = first_qx + slice_qx1 = first_qx +
COGL_FIXED_MUL (iter_x.intersect_start - first_tx, tqx); (iter_x.intersect_start - first_tx * tqx);
slice_qx2 = first_qx + slice_qx2 = first_qx +
COGL_FIXED_MUL (iter_x.intersect_end - first_tx, tqx); (iter_x.intersect_end - first_tx * tqx);
/* Localize slice texture coordinates */ /* Localize slice texture coordinates */
slice_tx1 = iter_x.intersect_start - iter_x.pos; slice_tx1 = iter_x.intersect_start - iter_x.pos;
@ -2273,14 +2274,14 @@ _cogl_texture_quad_sw (CoglTexture *tex,
#if COGL_DEBUG #if COGL_DEBUG
printf("~~~~~ slice (%d,%d)\n", iter_x.index, iter_y.index); printf("~~~~~ slice (%d,%d)\n", iter_x.index, iter_y.index);
printf("qx1: %f\n", COGL_FIXED_TO_FLOAT (slice_qx1)); printf("qx1: %f\n", (slice_qx1));
printf("qy1: %f\n", COGL_FIXED_TO_FLOAT (slice_qy1)); printf("qy1: %f\n", (slice_qy1));
printf("qx2: %f\n", COGL_FIXED_TO_FLOAT (slice_qx2)); printf("qx2: %f\n", (slice_qx2));
printf("qy2: %f\n", COGL_FIXED_TO_FLOAT (slice_qy2)); printf("qy2: %f\n", (slice_qy2));
printf("tx1: %f\n", COGL_FIXED_TO_FLOAT (slice_tx1)); printf("tx1: %f\n", (slice_tx1));
printf("ty1: %f\n", COGL_FIXED_TO_FLOAT (slice_ty1)); printf("ty1: %f\n", (slice_ty1));
printf("tx2: %f\n", COGL_FIXED_TO_FLOAT (slice_tx2)); printf("tx2: %f\n", (slice_tx2));
printf("ty2: %f\n", COGL_FIXED_TO_FLOAT (slice_ty2)); printf("ty2: %f\n", (slice_ty2));
#endif #endif
/* Pick and bind opengl texture object */ /* Pick and bind opengl texture object */
@ -2297,28 +2298,28 @@ _cogl_texture_quad_sw (CoglTexture *tex,
ctx->texture_current = gl_handle; ctx->texture_current = gl_handle;
ctx->texture_format = tex->gl_intformat; ctx->texture_format = tex->gl_intformat;
_cogl_texture_add_quad_vertices (COGL_FIXED_TO_FLOAT (slice_qx1), _cogl_texture_add_quad_vertices ( (slice_qx1),
COGL_FIXED_TO_FLOAT (slice_qy1), (slice_qy1),
COGL_FIXED_TO_FLOAT (slice_qx2), (slice_qx2),
COGL_FIXED_TO_FLOAT (slice_qy2), (slice_qy2),
COGL_FIXED_TO_FLOAT (slice_tx1), (slice_tx1),
COGL_FIXED_TO_FLOAT (slice_ty1), (slice_ty1),
COGL_FIXED_TO_FLOAT (slice_tx2), (slice_tx2),
COGL_FIXED_TO_FLOAT (slice_ty2)); (slice_ty2));
} }
} }
} }
static void static void
_cogl_texture_quad_hw (CoglTexture *tex, _cogl_texture_quad_hw (CoglTexture *tex,
CoglFixed x1, float x1,
CoglFixed y1, float y1,
CoglFixed x2, float x2,
CoglFixed y2, float y2,
CoglFixed tx1, float tx1,
CoglFixed ty1, float ty1,
CoglFixed tx2, float tx2,
CoglFixed ty2) float ty2)
{ {
GLuint gl_handle; GLuint gl_handle;
CoglTexSliceSpan *x_span; CoglTexSliceSpan *x_span;
@ -2352,19 +2353,19 @@ _cogl_texture_quad_hw (CoglTexture *tex,
ty1 = ty1 * (y_span->size - y_span->waste) / y_span->size; ty1 = ty1 * (y_span->size - y_span->waste) / y_span->size;
ty2 = ty2 * (y_span->size - y_span->waste) / y_span->size; ty2 = ty2 * (y_span->size - y_span->waste) / y_span->size;
_cogl_texture_add_quad_vertices (COGL_FIXED_TO_FLOAT (x1), _cogl_texture_add_quad_vertices ( (x1),
COGL_FIXED_TO_FLOAT (y1), (y1),
COGL_FIXED_TO_FLOAT (x2), (x2),
COGL_FIXED_TO_FLOAT (y2), (y2),
COGL_FIXED_TO_FLOAT (tx1), (tx1),
COGL_FIXED_TO_FLOAT (ty1), (ty1),
COGL_FIXED_TO_FLOAT (tx2), (tx2),
COGL_FIXED_TO_FLOAT (ty2)); (ty2));
} }
void void
cogl_texture_multiple_rectangles (CoglHandle handle, cogl_texture_multiple_rectangles (CoglHandle handle,
const CoglFixed *verts, const float *verts,
guint n_rects) guint n_rects)
{ {
CoglTexture *tex; CoglTexture *tex;
@ -2411,10 +2412,10 @@ cogl_texture_multiple_rectangles (CoglHandle handle,
if (tex->slice_gl_handles->len == 1 if (tex->slice_gl_handles->len == 1
&& ((cogl_features_available (COGL_FEATURE_TEXTURE_NPOT) && ((cogl_features_available (COGL_FEATURE_TEXTURE_NPOT)
&& tex->gl_target == GL_TEXTURE_2D) && tex->gl_target == GL_TEXTURE_2D)
|| (verts[4] >= 0 && verts[4] <= COGL_FIXED_1 || (verts[4] >= 0 && verts[4] <= 1.0
&& verts[6] >= 0 && verts[6] <= COGL_FIXED_1 && verts[6] >= 0 && verts[6] <= 1.0
&& verts[5] >= 0 && verts[5] <= COGL_FIXED_1 && verts[5] >= 0 && verts[5] <= 1.0
&& verts[7] >= 0 && verts[7] <= COGL_FIXED_1))) && verts[7] >= 0 && verts[7] <= 1.0)))
_cogl_texture_quad_hw (tex, verts[0],verts[1], verts[2],verts[3], _cogl_texture_quad_hw (tex, verts[0],verts[1], verts[2],verts[3],
verts[4],verts[5], verts[6],verts[7]); verts[4],verts[5], verts[6],verts[7]);
else else
@ -2430,16 +2431,16 @@ cogl_texture_multiple_rectangles (CoglHandle handle,
void void
cogl_texture_rectangle (CoglHandle handle, cogl_texture_rectangle (CoglHandle handle,
CoglFixed x1, float x1,
CoglFixed y1, float y1,
CoglFixed x2, float x2,
CoglFixed y2, float y2,
CoglFixed tx1, float tx1,
CoglFixed ty1, float ty1,
CoglFixed tx2, float tx2,
CoglFixed ty2) float ty2)
{ {
CoglFixed verts[8]; float verts[8];
verts[0] = x1; verts[0] = x1;
verts[1] = y1; verts[1] = y1;
@ -2541,7 +2542,7 @@ cogl_texture_polygon (CoglHandle handle,
OpenGL */ OpenGL */
for (i = 0; i < n_vertices; i++, p++) for (i = 0; i < n_vertices; i++, p++)
{ {
#define CFX_F COGL_FIXED_TO_FLOAT #define CFX_F
p->v[0] = CFX_F(vertices[i].x); p->v[0] = CFX_F(vertices[i].x);
p->v[1] = CFX_F(vertices[i].y); p->v[1] = CFX_F(vertices[i].y);

276
clutter/cogl/gles/cogl.c
View File

@ -37,6 +37,7 @@
#include "cogl-context.h" #include "cogl-context.h"
#include "cogl-gles2-wrapper.h" #include "cogl-gles2-wrapper.h"
#include <math.h>
/* GL error to string conversion */ /* GL error to string conversion */
#if COGL_DEBUG #if COGL_DEBUG
@ -92,10 +93,10 @@ cogl_paint_init (const CoglColor *color)
fprintf(stderr, "\n ============== Paint Start ================ \n"); fprintf(stderr, "\n ============== Paint Start ================ \n");
#endif #endif
cogl_wrap_glClearColorx (cogl_color_get_red (color), glClearColor (cogl_color_get_red (color),
cogl_color_get_green (color), cogl_color_get_green (color),
cogl_color_get_blue (color), cogl_color_get_blue (color),
0); 0);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
cogl_wrap_glDisable (GL_LIGHTING); cogl_wrap_glDisable (GL_LIGHTING);
@ -116,41 +117,21 @@ cogl_pop_matrix (void)
} }
void void
cogl_scale (CoglFixed x, CoglFixed y) cogl_scale (float x, float y)
{ {
GE( cogl_wrap_glScalex (x, y, COGL_FIXED_1) ); GE( cogl_wrap_glScalef (x, y, 1.0) );
} }
void void
cogl_translatex (CoglFixed x, CoglFixed y, CoglFixed z) cogl_translate (float x, float y, float z)
{ {
GE( cogl_wrap_glTranslatex (x, y, z) ); GE( cogl_wrap_glTranslatef (x, y, z) );
} }
void void
cogl_translate (gint x, gint y, gint z) cogl_rotate (float angle, float x, float y, float z)
{ {
GE( cogl_wrap_glTranslatex (COGL_FIXED_FROM_INT(x), GE( cogl_wrap_glRotatef (angle, x, y, z) );
COGL_FIXED_FROM_INT(y),
COGL_FIXED_FROM_INT(z)) );
}
void
cogl_rotatex (CoglFixed angle,
CoglFixed x,
CoglFixed y,
CoglFixed z)
{
GE( cogl_wrap_glRotatex (angle,x,y,z) );
}
void
cogl_rotate (gint angle, gint x, gint y, gint 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 static inline gboolean
@ -315,7 +296,7 @@ cogl_set_source_color (const CoglColor *color)
#else #else
/* conversion can cause issues with picking on some gles implementations */ /* conversion can cause issues with picking on some gles implementations */
GE( cogl_wrap_glColor4x (cogl_color_get_red (color), GE( cogl_wrap_glColor4f (cogl_color_get_red (color),
cogl_color_get_green (color), cogl_color_get_green (color),
cogl_color_get_blue (color), cogl_color_get_blue (color),
cogl_color_get_alpha (color)) ); cogl_color_get_alpha (color)) );
@ -326,22 +307,22 @@ cogl_set_source_color (const CoglColor *color)
} }
static void static void
apply_matrix (const CoglFixed *matrix, CoglFixed *vertex) apply_matrix (const float *matrix, float *vertex)
{ {
int x, y; int x, y;
CoglFixed vertex_out[4] = { 0 }; float vertex_out[4] = { 0 };
for (y = 0; y < 4; y++) for (y = 0; y < 4; y++)
for (x = 0; x < 4; x++) for (x = 0; x < 4; x++)
vertex_out[y] += cogl_fixed_mul (vertex[x], matrix[y + x * 4]); vertex_out[y] += (vertex[x] * matrix[y + x * 4]);
memcpy (vertex, vertex_out, sizeof (vertex_out)); memcpy (vertex, vertex_out, sizeof (vertex_out));
} }
static void static void
project_vertex (CoglFixed *modelview, project_vertex (float *modelview,
CoglFixed *project, float *project,
CoglFixed *vertex) float *vertex)
{ {
int i; int i;
@ -351,62 +332,61 @@ project_vertex (CoglFixed *modelview,
apply_matrix (project, vertex); apply_matrix (project, vertex);
/* Convert from homogenized coordinates */ /* Convert from homogenized coordinates */
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++)
vertex[i] = cogl_fixed_div (vertex[i], vertex[3]); vertex[i] = (vertex[i] / vertex[3]);
} }
static void static void
set_clip_plane (GLint plane_num, set_clip_plane (GLint plane_num,
const CoglFixed *vertex_a, const float *vertex_a,
const CoglFixed *vertex_b) const float *vertex_b)
{ {
GLfixed plane[4]; GLfloat plane[4];
GLfixed angle; GLfloat angle;
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
/* Calculate the angle between the axes and the line crossing the /* Calculate the angle between the axes and the line crossing the
two points */ two points */
angle = cogl_fixed_mul (cogl_fixed_atan2 (vertex_b[1] - vertex_a[1], angle = atan2f (vertex_b[1] - vertex_a[1],
vertex_b[0] - vertex_a[0]), vertex_b[0] - vertex_a[0]) * (180.0/G_PI);
COGL_RADIANS_TO_DEGREES);
GE( cogl_wrap_glPushMatrix () ); GE( cogl_wrap_glPushMatrix () );
/* Load the identity matrix and multiply by the reverse of the /* Load the identity matrix and multiply by the reverse of the
projection matrix so we can specify the plane in screen projection matrix so we can specify the plane in screen
coordinates */ coordinates */
GE( cogl_wrap_glLoadIdentity () ); GE( cogl_wrap_glLoadIdentity () );
GE( cogl_wrap_glMultMatrixx ((GLfixed *) ctx->inverse_projection) ); GE( cogl_wrap_glMultMatrixf ((GLfloat *) ctx->inverse_projection) );
/* Rotate about point a */ /* Rotate about point a */
GE( cogl_wrap_glTranslatex (vertex_a[0], vertex_a[1], vertex_a[2]) ); GE( cogl_wrap_glTranslatef (vertex_a[0], vertex_a[1], vertex_a[2]) );
/* Rotate the plane by the calculated angle so that it will connect /* Rotate the plane by the calculated angle so that it will connect
the two points */ the two points */
GE( cogl_wrap_glRotatex (angle, 0.0f, 0.0f, 1.0f) ); GE( cogl_wrap_glRotatef (angle, 0.0f, 0.0f, 1.0f) );
GE( cogl_wrap_glTranslatex (-vertex_a[0], -vertex_a[1], -vertex_a[2]) ); GE( cogl_wrap_glTranslatef (-vertex_a[0], -vertex_a[1], -vertex_a[2]) );
plane[0] = 0; plane[0] = 0;
plane[1] = -COGL_FIXED_1; plane[1] = -1.0;
plane[2] = 0; plane[2] = 0;
plane[3] = vertex_a[1]; plane[3] = vertex_a[1];
GE( cogl_wrap_glClipPlanex (plane_num, plane) ); GE( cogl_wrap_glClipPlanef (plane_num, plane) );
GE( cogl_wrap_glPopMatrix () ); GE( cogl_wrap_glPopMatrix () );
} }
void void
_cogl_set_clip_planes (CoglFixed x_offset, _cogl_set_clip_planes (float x_offset,
CoglFixed y_offset, float y_offset,
CoglFixed width, float width,
CoglFixed height) float height)
{ {
GLfixed modelview[16], projection[16]; GLfloat modelview[16], projection[16];
CoglFixed vertex_tl[4] = { x_offset, y_offset, 0, COGL_FIXED_1 }; float vertex_tl[4] = { x_offset, y_offset, 0, 1.0 };
CoglFixed vertex_tr[4] = { x_offset + width, y_offset, 0, COGL_FIXED_1 }; float vertex_tr[4] = { x_offset + width, y_offset, 0, 1.0 };
CoglFixed vertex_bl[4] = { x_offset, y_offset + height, 0, COGL_FIXED_1 }; float vertex_bl[4] = { x_offset, y_offset + height, 0, 1.0 };
CoglFixed vertex_br[4] = { x_offset + width, y_offset + height, float vertex_br[4] = { x_offset + width, y_offset + height,
0, COGL_FIXED_1 }; 0, 1.0 };
GE( cogl_wrap_glGetFixedv (GL_MODELVIEW_MATRIX, modelview) ); GE( cogl_wrap_glGetFloatv (GL_MODELVIEW_MATRIX, modelview) );
GE( cogl_wrap_glGetFixedv (GL_PROJECTION_MATRIX, projection) ); GE( cogl_wrap_glGetFloatv (GL_PROJECTION_MATRIX, projection) );
project_vertex (modelview, projection, vertex_tl); project_vertex (modelview, projection, vertex_tl);
project_vertex (modelview, projection, vertex_tr); project_vertex (modelview, projection, vertex_tr);
@ -421,7 +401,7 @@ _cogl_set_clip_planes (CoglFixed x_offset,
if ((vertex_tl[0] < vertex_tr[0] ? 1 : 0) if ((vertex_tl[0] < vertex_tr[0] ? 1 : 0)
!= (vertex_bl[1] < vertex_tl[1] ? 1 : 0)) != (vertex_bl[1] < vertex_tl[1] ? 1 : 0))
{ {
CoglFixed temp[4]; float temp[4];
memcpy (temp, vertex_tl, sizeof (temp)); memcpy (temp, vertex_tl, sizeof (temp));
memcpy (vertex_tl, vertex_tr, sizeof (temp)); memcpy (vertex_tl, vertex_tr, sizeof (temp));
memcpy (vertex_tr, temp, sizeof (temp)); memcpy (vertex_tr, temp, sizeof (temp));
@ -437,10 +417,10 @@ _cogl_set_clip_planes (CoglFixed x_offset,
} }
void void
_cogl_add_stencil_clip (CoglFixed x_offset, _cogl_add_stencil_clip (float x_offset,
CoglFixed y_offset, float y_offset,
CoglFixed width, float width,
CoglFixed height, float height,
gboolean first) gboolean first)
{ {
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -457,7 +437,7 @@ _cogl_add_stencil_clip (CoglFixed x_offset,
GE( glStencilFunc (GL_NEVER, 0x1, 0x1) ); GE( glStencilFunc (GL_NEVER, 0x1, 0x1) );
GE( glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE) ); GE( glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE) );
cogl_rectanglex (x_offset, y_offset, width, height); cogl_rectangle (x_offset, y_offset, width, height);
} }
else else
{ {
@ -465,7 +445,7 @@ _cogl_add_stencil_clip (CoglFixed x_offset,
rectangle */ rectangle */
GE( glStencilFunc (GL_NEVER, 0x1, 0x3) ); GE( glStencilFunc (GL_NEVER, 0x1, 0x3) );
GE( glStencilOp (GL_INCR, GL_INCR, GL_INCR) ); GE( glStencilOp (GL_INCR, GL_INCR, GL_INCR) );
cogl_rectanglex (x_offset, y_offset, width, height); cogl_rectangle (x_offset, y_offset, width, height);
/* Subtract one from all pixels in the stencil buffer so that /* Subtract one from all pixels in the stencil buffer so that
only pixels where both the original stencil buffer and the only pixels where both the original stencil buffer and the
@ -476,9 +456,7 @@ _cogl_add_stencil_clip (CoglFixed x_offset,
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) ); GE( cogl_wrap_glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glPushMatrix () ); GE( cogl_wrap_glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () ); GE( cogl_wrap_glLoadIdentity () );
cogl_rectanglex (-COGL_FIXED_1, -COGL_FIXED_1, cogl_rectangle (-1.0, -1.0, 2, 2);
COGL_FIXED_FROM_INT (2),
COGL_FIXED_FROM_INT (2));
GE( cogl_wrap_glPopMatrix () ); GE( cogl_wrap_glPopMatrix () );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) ); GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPopMatrix () ); GE( cogl_wrap_glPopMatrix () );
@ -490,10 +468,10 @@ _cogl_add_stencil_clip (CoglFixed x_offset,
} }
void void
_cogl_set_matrix (const CoglFixed *matrix) _cogl_set_matrix (const float *matrix)
{ {
GE( cogl_wrap_glLoadIdentity () ); GE( cogl_wrap_glLoadIdentity () );
GE( cogl_wrap_glMultMatrixx (matrix) ); GE( cogl_wrap_glMultMatrixf (matrix) );
} }
void void
@ -522,25 +500,25 @@ _cogl_disable_clip_planes (void)
void void
cogl_alpha_func (COGLenum func, cogl_alpha_func (COGLenum func,
CoglFixed ref) float ref)
{ {
GE( cogl_wrap_glAlphaFunc (func, COGL_FIXED_TO_FLOAT(ref)) ); GE( cogl_wrap_glAlphaFunc (func, (ref)) );
} }
/* /*
* Fixed point implementation of the perspective function * Fixed point implementation of the perspective function
*/ */
void void
cogl_perspective (CoglFixed fovy, cogl_perspective (float fovy,
CoglFixed aspect, float aspect,
CoglFixed zNear, float zNear,
CoglFixed zFar) float zFar)
{ {
CoglFixed xmax, ymax; float xmax, ymax;
CoglFixed x, y, c, d; float x, y, c, d;
CoglFixed fovy_rad_half = cogl_fixed_mul (fovy, COGL_FIXED_PI) / 360; float fovy_rad_half = (fovy * G_PI) / 360;
GLfixed m[16]; GLfloat m[16];
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -558,76 +536,74 @@ cogl_perspective (CoglFixed fovy,
* 2) When working with small numbers, we can are loosing significant * 2) When working with small numbers, we can are loosing significant
* precision * precision
*/ */
ymax = cogl_fixed_mul (zNear, ymax = (zNear * (sinf (fovy_rad_half) / cosf (fovy_rad_half)));
cogl_fixed_div (cogl_fixed_sin (fovy_rad_half), xmax = (ymax * aspect);
cogl_fixed_cos (fovy_rad_half)));
xmax = cogl_fixed_mul (ymax, aspect);
x = cogl_fixed_div (zNear, xmax); x = (zNear / xmax);
y = cogl_fixed_div (zNear, ymax); y = (zNear / ymax);
c = cogl_fixed_div (-(zFar + zNear), ( zFar - zNear)); c = (-(zFar + zNear) / ( zFar - zNear));
d = cogl_fixed_div (-(cogl_fixed_mul (2 * zFar, zNear)), (zFar - zNear)); d = (-(2 * zFar) * zNear) / (zFar - zNear);
#define M(row,col) m[col*4+row] #define M(row,col) m[col*4+row]
M(0,0) = x; M(0,0) = x;
M(1,1) = y; M(1,1) = y;
M(2,2) = c; M(2,2) = c;
M(2,3) = d; M(2,3) = d;
M(3,2) = -COGL_FIXED_1; M(3,2) = -1.0;
GE( cogl_wrap_glMultMatrixx (m) ); GE( cogl_wrap_glMultMatrixf (m) );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) ); GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
/* Calculate and store the inverse of the matrix */ /* Calculate and store the inverse of the matrix */
memset (ctx->inverse_projection, 0, sizeof (CoglFixed) * 16); memset (ctx->inverse_projection, 0, sizeof (float) * 16);
#define m ctx->inverse_projection #define m ctx->inverse_projection
M(0, 0) = cogl_fixed_div (COGL_FIXED_1, x); M(0, 0) = (1.0 / x);
M(1, 1) = cogl_fixed_div (COGL_FIXED_1, y); M(1, 1) = (1.0 / y);
M(2, 3) = -COGL_FIXED_1; M(2, 3) = -1.0;
M(3, 2) = cogl_fixed_div (COGL_FIXED_1, d); M(3, 2) = (1.0 / d);
M(3, 3) = cogl_fixed_div (c, d); M(3, 3) = (c / d);
#undef m #undef m
#undef M #undef M
} }
void void
cogl_frustum (CoglFixed left, cogl_frustum (float left,
CoglFixed right, float right,
CoglFixed bottom, float bottom,
CoglFixed top, float top,
CoglFixed z_near, float z_near,
CoglFixed z_far) float z_far)
{ {
CoglFixed c, d; float c, d;
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) ); GE( cogl_wrap_glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glLoadIdentity () ); GE( cogl_wrap_glLoadIdentity () );
GE( cogl_wrap_glFrustumx (left, right, GE( cogl_wrap_glFrustumf (left, right,
bottom, top, bottom, top,
z_near, z_far) ); z_near, z_far) );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) ); GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
/* Calculate and store the inverse of the matrix */ /* Calculate and store the inverse of the matrix */
memset (ctx->inverse_projection, 0, sizeof (CoglFixed) * 16); memset (ctx->inverse_projection, 0, sizeof (float) * 16);
c = -cogl_fixed_div (z_far + z_near, z_far - z_near); c = -(z_far + z_near / z_far - z_near);
d = -cogl_fixed_div (2 * cogl_fixed_mul (z_far, z_near), z_far - z_near); d = -(2 * (z_far * z_near) / z_far - z_near);
#define M(row,col) ctx->inverse_projection[col*4+row] #define M(row,col) ctx->inverse_projection[col*4+row]
M(0,0) = cogl_fixed_div (right - left, 2 * z_near); M(0,0) = (right - left / 2 * z_near);
M(0,3) = cogl_fixed_div (right + left, 2 * z_near); M(0,3) = (right + left / 2 * z_near);
M(1,1) = cogl_fixed_div (top - bottom, 2 * z_near); M(1,1) = (top - bottom / 2 * z_near);
M(1,3) = cogl_fixed_div (top + bottom, 2 * z_near); M(1,3) = (top + bottom / 2 * z_near);
M(2,3) = -COGL_FIXED_1; M(2,3) = -1.0;
M(3,2) = cogl_fixed_div (COGL_FIXED_1, d); M(3,2) = (1.0 / d);
M(3,3) = cogl_fixed_div (c, d); M(3,3) = (c / d);
#undef M #undef M
} }
@ -641,19 +617,19 @@ cogl_viewport (guint width,
void void
cogl_setup_viewport (guint w, cogl_setup_viewport (guint w,
guint h, guint h,
CoglFixed fovy, float fovy,
CoglFixed aspect, float aspect,
CoglFixed z_near, float z_near,
CoglFixed z_far) float z_far)
{ {
gint width = (gint) w; gint width = (gint) w;
gint height = (gint) h; gint height = (gint) h;
CoglFixed z_camera; float z_camera;
GE( glViewport (0, 0, width, height) ); GE( glViewport (0, 0, width, height) );
/* For Ortho projection. /* For Ortho projection.
* cogl_wrap_glOrthox (0, width << 16, 0, height << 16, -1 << 16, 1 << 16); * cogl_wrap_glOrthof (0, width << 16, 0, height << 16, -1 << 16, 1 << 16);
*/ */
cogl_perspective (fovy, aspect, z_near, z_far); cogl_perspective (fovy, aspect, z_near, z_far);
@ -666,24 +642,24 @@ cogl_setup_viewport (guint w,
* See comments in ../gl/cogl.c * See comments in ../gl/cogl.c
*/ */
#define DEFAULT_Z_CAMERA 0.869f #define DEFAULT_Z_CAMERA 0.869f
z_camera = COGL_FIXED_FROM_FLOAT (DEFAULT_Z_CAMERA); z_camera = (DEFAULT_Z_CAMERA);
if (fovy != COGL_FIXED_60) if (fovy != 60.0)
{ {
CoglFixed fovy_rad = cogl_fixed_mul (fovy, COGL_FIXED_PI) / 180; float fovy_rad = (fovy * G_PI) / 180;
z_camera = cogl_fixed_div (cogl_fixed_sin (fovy_rad), z_camera = (sinf (fovy_rad) / cosf (fovy_rad)) / 2;
cogl_fixed_cos (fovy_rad)) >> 1;
} }
GE( cogl_wrap_glTranslatex (-1 << 15, -1 << 15, -z_camera) );
GE( cogl_wrap_glScalex ( COGL_FIXED_1 / width, GE( cogl_wrap_glTranslatef (-0.5f, -0.5f, -z_camera) );
-COGL_FIXED_1 / height,
COGL_FIXED_1 / width) );
GE( cogl_wrap_glTranslatex (0, -COGL_FIXED_1 * height, 0) ); GE( cogl_wrap_glScalef ( 1.0 / width,
-1.0 / height,
1.0 / width) );
GE( cogl_wrap_glTranslatef (0, -1.0 * height, 0) );
} }
static void static void
@ -735,19 +711,19 @@ cogl_features_available (CoglFeatureFlags features)
} }
void void
cogl_get_modelview_matrix (CoglFixed m[16]) cogl_get_modelview_matrix (float m[16])
{ {
cogl_wrap_glGetFixedv(GL_MODELVIEW_MATRIX, &m[0]); cogl_wrap_glGetFloatv (GL_MODELVIEW_MATRIX, m);
} }
void void
cogl_get_projection_matrix (CoglFixed m[16]) cogl_get_projection_matrix (float m[16])
{ {
cogl_wrap_glGetFixedv(GL_PROJECTION_MATRIX, &m[0]); cogl_wrap_glGetFloatv (GL_PROJECTION_MATRIX, m);
} }
void void
cogl_get_viewport (CoglFixed v[4]) cogl_get_viewport (float v[4])
{ {
GLint viewport[4]; GLint viewport[4];
int i; int i;
@ -755,7 +731,7 @@ cogl_get_viewport (CoglFixed v[4])
cogl_wrap_glGetIntegerv (GL_VIEWPORT, viewport); cogl_wrap_glGetIntegerv (GL_VIEWPORT, viewport);
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++)
v[i] = COGL_FIXED_FROM_INT (viewport[i]); v[i] = (float)(viewport[i]);
} }
void void
@ -773,11 +749,11 @@ cogl_get_bitmasks (gint *red, gint *green, gint *blue, gint *alpha)
void void
cogl_fog_set (const CoglColor *fog_color, cogl_fog_set (const CoglColor *fog_color,
CoglFixed density, float density,
CoglFixed z_near, float z_near,
CoglFixed z_far) float z_far)
{ {
GLfixed fogColor[4]; GLfloat fogColor[4];
fogColor[0] = cogl_color_get_red (fog_color); fogColor[0] = cogl_color_get_red (fog_color);
fogColor[1] = cogl_color_get_green (fog_color); fogColor[1] = cogl_color_get_green (fog_color);
@ -786,12 +762,12 @@ cogl_fog_set (const CoglColor *fog_color,
cogl_wrap_glEnable (GL_FOG); cogl_wrap_glEnable (GL_FOG);
cogl_wrap_glFogxv (GL_FOG_COLOR, fogColor); cogl_wrap_glFogfv (GL_FOG_COLOR, fogColor);
cogl_wrap_glFogx (GL_FOG_MODE, GL_LINEAR); cogl_wrap_glFogf (GL_FOG_MODE, GL_LINEAR);
glHint (GL_FOG_HINT, GL_NICEST); glHint (GL_FOG_HINT, GL_NICEST);
cogl_wrap_glFogx (GL_FOG_DENSITY, (GLfixed) density); cogl_wrap_glFogf (GL_FOG_DENSITY, (GLfloat) density);
cogl_wrap_glFogx (GL_FOG_START, (GLfixed) z_near); cogl_wrap_glFogf (GL_FOG_START, (GLfloat) z_near);
cogl_wrap_glFogx (GL_FOG_END, (GLfixed) z_far); cogl_wrap_glFogf (GL_FOG_END, (GLfloat) z_far);
} }

8
clutter/pango/cogl-pango-glyph-cache.c
View File

@ -342,13 +342,13 @@ cogl_pango_glyph_cache_set (CoglPangoGlyphCache *cache,
value = g_slice_new (CoglPangoGlyphCacheValue); value = g_slice_new (CoglPangoGlyphCacheValue);
value->texture = cogl_texture_ref (band->texture); value->texture = cogl_texture_ref (band->texture);
value->tx1 = COGL_FIXED_FROM_INT (band->space_remaining) value->tx1 = (float)(band->space_remaining)
/ band->texture_size; / band->texture_size;
value->tx2 = COGL_FIXED_FROM_INT (band->space_remaining + width) value->tx2 = (float)(band->space_remaining + width)
/ band->texture_size; / band->texture_size;
value->ty1 = COGL_FIXED_FROM_INT (band->top) value->ty1 = (float)(band->top)
/ band->texture_size; / band->texture_size;
value->ty2 = COGL_FIXED_FROM_INT (band->top + height) value->ty2 = (float)(band->top + height)
/ band->texture_size; / band->texture_size;
value->draw_x = draw_x; value->draw_x = draw_x;
value->draw_y = draw_y; value->draw_y = draw_y;

8
clutter/pango/cogl-pango-glyph-cache.h
View File

@ -37,10 +37,10 @@ struct _CoglPangoGlyphCacheValue
{ {
CoglHandle texture; CoglHandle texture;
CoglFixed tx1; float tx1;
CoglFixed ty1; float ty1;
CoglFixed tx2; float tx2;
CoglFixed ty2; float ty2;
int draw_x; int draw_x;
int draw_y; int draw_y;

78
clutter/pango/cogl-pango-render.c
View File

@ -67,7 +67,7 @@ cogl_pango_renderer_glyphs_end (CoglPangoRenderer *priv)
{ {
if (priv->glyph_rectangles->len > 0) if (priv->glyph_rectangles->len > 0)
{ {
CoglFixed *rectangles = (CoglFixed *) priv->glyph_rectangles->data; float *rectangles = (float *) priv->glyph_rectangles->data;
cogl_texture_multiple_rectangles (priv->glyph_texture, rectangles, cogl_texture_multiple_rectangles (priv->glyph_texture, rectangles,
priv->glyph_rectangles->len / 8); priv->glyph_rectangles->len / 8);
g_array_set_size (priv->glyph_rectangles, 0); g_array_set_size (priv->glyph_rectangles, 0);
@ -77,11 +77,11 @@ cogl_pango_renderer_glyphs_end (CoglPangoRenderer *priv)
static void static void
cogl_pango_renderer_draw_glyph (CoglPangoRenderer *priv, cogl_pango_renderer_draw_glyph (CoglPangoRenderer *priv,
CoglPangoGlyphCacheValue *cache_value, CoglPangoGlyphCacheValue *cache_value,
CoglFixed x1, float x1,
CoglFixed y1) float y1)
{ {
CoglFixed x2, y2; float x2, y2;
CoglFixed *p; float *p;
if (priv->glyph_rectangles->len > 0 if (priv->glyph_rectangles->len > 0
&& priv->glyph_texture != cache_value->texture) && priv->glyph_texture != cache_value->texture)
@ -93,7 +93,7 @@ cogl_pango_renderer_draw_glyph (CoglPangoRenderer *priv,
y2 = y1 + CLUTTER_INT_TO_FIXED (cache_value->draw_height); y2 = y1 + CLUTTER_INT_TO_FIXED (cache_value->draw_height);
g_array_set_size (priv->glyph_rectangles, priv->glyph_rectangles->len + 8); g_array_set_size (priv->glyph_rectangles, priv->glyph_rectangles->len + 8);
p = &g_array_index (priv->glyph_rectangles, CoglFixed, p = &g_array_index (priv->glyph_rectangles, float,
priv->glyph_rectangles->len - 8); priv->glyph_rectangles->len - 8);
*(p++) = x1; *(p++) = y1; *(p++) = x1; *(p++) = y1;
@ -102,8 +102,6 @@ cogl_pango_renderer_draw_glyph (CoglPangoRenderer *priv,
*(p++) = cache_value->tx2; *(p++) = cache_value->ty2; *(p++) = cache_value->tx2; *(p++) = cache_value->ty2;
} }
#define COGL_PANGO_UNIT_TO_FIXED(x) ((x) << (COGL_FIXED_Q - 10))
static void cogl_pango_renderer_finalize (GObject *object); static void cogl_pango_renderer_finalize (GObject *object);
static void cogl_pango_renderer_draw_glyphs (PangoRenderer *renderer, static void cogl_pango_renderer_draw_glyphs (PangoRenderer *renderer,
PangoFont *font, PangoFont *font,
@ -133,7 +131,7 @@ cogl_pango_renderer_init (CoglPangoRenderer *priv)
priv->glyph_cache = cogl_pango_glyph_cache_new (FALSE); priv->glyph_cache = cogl_pango_glyph_cache_new (FALSE);
priv->mipmapped_glyph_cache = cogl_pango_glyph_cache_new (TRUE); priv->mipmapped_glyph_cache = cogl_pango_glyph_cache_new (TRUE);
priv->use_mipmapping = FALSE; priv->use_mipmapping = FALSE;
priv->glyph_rectangles = g_array_new (FALSE, FALSE, sizeof (CoglFixed)); priv->glyph_rectangles = g_array_new (FALSE, FALSE, sizeof (float));
} }
static void static void
@ -413,10 +411,10 @@ static void
cogl_pango_renderer_draw_box (int x, int y, cogl_pango_renderer_draw_box (int x, int y,
int width, int height) int width, int height)
{ {
cogl_path_rectangle (COGL_FIXED_FROM_INT (x), cogl_path_rectangle ((float)(x),
COGL_FIXED_FROM_INT (y - height), (float)(y - height),
COGL_FIXED_FROM_INT (width), (float)(width),
COGL_FIXED_FROM_INT (height)); (float)(height));
cogl_path_stroke (); cogl_path_stroke ();
} }
@ -424,23 +422,23 @@ static void
cogl_pango_renderer_get_device_units (PangoRenderer *renderer, cogl_pango_renderer_get_device_units (PangoRenderer *renderer,
int xin, int xin,
int yin, int yin,
CoglFixed *xout, float *xout,
CoglFixed *yout) float *yout)
{ {
const PangoMatrix *matrix; const PangoMatrix *matrix;
if ((matrix = pango_renderer_get_matrix (renderer))) if ((matrix = pango_renderer_get_matrix (renderer)))
{ {
/* Convert user-space coords to device coords */ /* Convert user-space coords to device coords */
*xout = COGL_FIXED_FROM_FLOAT ((xin * matrix->xx + yin * matrix->xy) *xout = ((xin * matrix->xx + yin * matrix->xy)
/ PANGO_SCALE + matrix->x0); / PANGO_SCALE + matrix->x0);
*yout = COGL_FIXED_FROM_FLOAT ((yin * matrix->yy + xin * matrix->yx) *yout = ((yin * matrix->yy + xin * matrix->yx)
/ PANGO_SCALE + matrix->y0); / PANGO_SCALE + matrix->y0);
} }
else else
{ {
*xout = COGL_PANGO_UNIT_TO_FIXED (xin); *xout = PANGO_PIXELS (xin);
*yout = COGL_PANGO_UNIT_TO_FIXED (yin); *yout = PANGO_PIXELS (yin);
} }
} }
@ -452,7 +450,7 @@ cogl_pango_renderer_draw_rectangle (PangoRenderer *renderer,
int width, int width,
int height) int height)
{ {
CoglFixed x1, x2, y1, y2; float x1, x2, y1, y2;
cogl_pango_renderer_set_color_for_part (renderer, part); cogl_pango_renderer_set_color_for_part (renderer, part);
@ -463,7 +461,7 @@ cogl_pango_renderer_draw_rectangle (PangoRenderer *renderer,
x + width, y + height, x + width, y + height,
&x2, &y2); &x2, &y2);
cogl_rectanglex (x1, y1, x2 - x1, y2 - y1); cogl_rectangle (x1, y1, x2 - x1, y2 - y1);
} }
static void static void
@ -476,15 +474,15 @@ cogl_pango_renderer_draw_trapezoid (PangoRenderer *renderer,
double x12, double x12,
double x22) double x22)
{ {
CoglFixed points[8]; float points[8];
points[0] = COGL_FIXED_FROM_FLOAT (x11); points[0] = (x11);
points[1] = COGL_FIXED_FROM_FLOAT (y1); points[1] = (y1);
points[2] = COGL_FIXED_FROM_FLOAT (x12); points[2] = (x12);
points[3] = COGL_FIXED_FROM_FLOAT (y2); points[3] = (y2);
points[4] = COGL_FIXED_FROM_FLOAT (x22); points[4] = (x22);
points[5] = points[3]; points[5] = points[3];
points[6] = COGL_FIXED_FROM_FLOAT (x21); points[6] = (x21);
points[7] = points[1]; points[7] = points[1];
cogl_pango_renderer_set_color_for_part (renderer, part); cogl_pango_renderer_set_color_for_part (renderer, part);
@ -510,7 +508,7 @@ cogl_pango_renderer_draw_glyphs (PangoRenderer *renderer,
for (i = 0; i < glyphs->num_glyphs; i++) for (i = 0; i < glyphs->num_glyphs; i++)
{ {
PangoGlyphInfo *gi = glyphs->glyphs + i; PangoGlyphInfo *gi = glyphs->glyphs + i;
CoglFixed x, y; float x, y;
cogl_pango_renderer_get_device_units (renderer, cogl_pango_renderer_get_device_units (renderer,
xi + gi->geometry.x_offset, xi + gi->geometry.x_offset,
@ -526,15 +524,15 @@ cogl_pango_renderer_draw_glyphs (PangoRenderer *renderer,
if (font == NULL || if (font == NULL ||
(metrics = pango_font_get_metrics (font, NULL)) == NULL) (metrics = pango_font_get_metrics (font, NULL)) == NULL)
{ {
cogl_pango_renderer_draw_box (COGL_FIXED_TO_INT (x), cogl_pango_renderer_draw_box ( (x),
COGL_FIXED_TO_INT (y), (y),
PANGO_UNKNOWN_GLYPH_WIDTH, PANGO_UNKNOWN_GLYPH_WIDTH,
PANGO_UNKNOWN_GLYPH_HEIGHT); PANGO_UNKNOWN_GLYPH_HEIGHT);
} }
else else
{ {
cogl_pango_renderer_draw_box (COGL_FIXED_TO_INT (x), cogl_pango_renderer_draw_box ( (x),
COGL_FIXED_TO_INT (y), (y),
metrics->approximate_char_width metrics->approximate_char_width
/ PANGO_SCALE, / PANGO_SCALE,
metrics->ascent / PANGO_SCALE); metrics->ascent / PANGO_SCALE);
@ -555,20 +553,20 @@ cogl_pango_renderer_draw_glyphs (PangoRenderer *renderer,
{ {
cogl_pango_renderer_glyphs_end (priv); cogl_pango_renderer_glyphs_end (priv);
cogl_pango_renderer_draw_box (COGL_FIXED_TO_INT (x), cogl_pango_renderer_draw_box ( (x),
COGL_FIXED_TO_INT (y), (y),
PANGO_UNKNOWN_GLYPH_WIDTH, PANGO_UNKNOWN_GLYPH_WIDTH,
PANGO_UNKNOWN_GLYPH_HEIGHT); PANGO_UNKNOWN_GLYPH_HEIGHT);
} }
else else
{ {
CoglFixed width, height; float width, height;
x += COGL_FIXED_FROM_INT (cache_value->draw_x); x += (float)(cache_value->draw_x);
y += COGL_FIXED_FROM_INT (cache_value->draw_y); y += (float)(cache_value->draw_y);
width = x + COGL_FIXED_FROM_INT (cache_value->draw_width); width = x + (float)(cache_value->draw_width);
height = y + COGL_FIXED_FROM_INT (cache_value->draw_height); height = y + (float)(cache_value->draw_height);
cogl_pango_renderer_draw_glyph (priv, cache_value, x, y); cogl_pango_renderer_draw_glyph (priv, cache_value, x, y);
} }

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

@ -89,7 +89,7 @@ cogl_path_stroke
cogl_path_stroke_preserve cogl_path_stroke_preserve
cogl_set_source_color cogl_set_source_color
cogl_set_source_color4ub cogl_set_source_color4ub
cogl_set_source_color4x cogl_set_source_color4f
<SUBSECTION> <SUBSECTION>
cogl_rectangle cogl_rectangle
@ -257,7 +257,7 @@ cogl_color_copy
cogl_color_free cogl_color_free
cogl_color_set_from_4ub cogl_color_set_from_4ub
cogl_color_set_from_4d cogl_color_set_from_4d
cogl_color_set_from_4x cogl_color_set_from_4f
<SUBSECTION> <SUBSECTION>
cogl_color_get_red cogl_color_get_red

27
fixed-to-float-patches/clutter-actor.c.0.patch Normal file
View File

@ -0,0 +1,27 @@
diff --git a/clutter/clutter-actor.c b/clutter/clutter-actor.c
index 1e481cd..9cbee04 100644
--- a/clutter/clutter-actor.c
+++ b/clutter/clutter-actor.c
@@ -806,7 +806,7 @@ static inline void
mtx_transform (const ClutterFixed m[],
fixed_vertex_t *vertex)
{
- ClutterFixed _x, _y, _z, _w;
+ float _x, _y, _z, _w;
_x = vertex->x;
_y = vertex->y;
@@ -846,8 +846,11 @@ mtx_transform (const ClutterFixed m[],
/* Help macros to scale from OpenGL <-1,1> coordinates system to our
* X-window based <0,window-size> coordinates
*/
-#define MTX_GL_SCALE_X(x,w,v1,v2) (CLUTTER_FIXED_MUL (((CLUTTER_FIXED_DIV ((x), (w)) + 1.0) >> 1), (v1)) + (v2))
-#define MTX_GL_SCALE_Y(y,w,v1,v2) ((v1) - CLUTTER_FIXED_MUL (((CLUTTER_FIXED_DIV ((y), (w)) + 1.0) >> 1), (v1)) + (v2))
+#define MTX_GL_SCALE_X(x,w,v1,v2) \
+ (CLUTTER_FIXED_MUL (((CLUTTER_FIXED_DIV ((x), (w)) + 1.0) / 2), (v1)) + (v2))
+#define MTX_GL_SCALE_Y(y,w,v1,v2) \
+ ((v1) - CLUTTER_FIXED_MUL (((CLUTTER_FIXED_DIV ((y), (w)) + 1.0) / 2), \
+ (v1)) + (v2))
#define MTX_GL_SCALE_Z(z,w,v1,v2) (MTX_GL_SCALE_X ((z), (w), (v1), (v2)))
/* transforms a 4-tuple of coordinates using @matrix and

306
fixed-to-float-patches/clutter-alpha.c.0.patch Normal file
View File

@ -0,0 +1,306 @@
diff --git a/clutter/clutter-alpha.c b/clutter/clutter-alpha.c
index 60ef0d3..dda0f6c 100644
--- a/clutter/clutter-alpha.c
+++ b/clutter/clutter-alpha.c
@@ -697,6 +697,11 @@ clutter_ramp_func (ClutterAlpha *alpha,
}
}
+#if 0
+/*
+ * The following three functions are left in place for reference
+ * purposes.
+ */
static guint32
sincx1024_func (ClutterAlpha *alpha,
float angle,
@@ -716,7 +721,7 @@ sincx1024_func (ClutterAlpha *alpha,
x -= (512 * 512 / angle);
- sine = ((sinf (x * (G_PI/180.0)) + offset) / 2)
+ sine = ((cogl_angle_sin (x) + offset) / 2)
* CLUTTER_ALPHA_MAX_ALPHA;
sine = sine >> COGL_FIXED_Q;
@@ -724,11 +729,6 @@ sincx1024_func (ClutterAlpha *alpha,
return sine;
}
-#if 0
-/*
- * The following two functions are left in place for reference
- * purposes.
- */
static guint32
sincx_func (ClutterAlpha *alpha,
ClutterFixed angle,
@@ -747,7 +747,7 @@ sincx_func (ClutterAlpha *alpha,
x = CLUTTER_FIXED_MUL (x, CFX_PI)
- CLUTTER_FIXED_DIV (CFX_PI, angle);
- sine = (sinf (x) + offset) / 2;
+ sine = (cogl_angle_sin (x) + offset) / 2;
CLUTTER_NOTE (ALPHA, "sine: %2f\n", CLUTTER_FIXED_TO_DOUBLE (sine));
@@ -806,9 +806,28 @@ guint32
clutter_sine_func (ClutterAlpha *alpha,
gpointer dummy)
{
-#if 0
+#if 1
+ ClutterTimeline *timeline;
+ gint current_frame_num, n_frames;
+ float radians, sine;
+
+ timeline = clutter_alpha_get_timeline (alpha);
+
+ current_frame_num = clutter_timeline_get_current_frame (timeline);
+ n_frames = clutter_timeline_get_n_frames (timeline);
+
+ radians = ((float)current_frame_num / n_frames) * (2.0 * G_PI);
+ sine = sinf (radians);
+
+ /* shift from range [-1, 1] -> [0, 1] */
+ sine = (sine + 1.0) / 2.0;
+
+ CLUTTER_NOTE (ALPHA, "sine: %2f\n", sine);
+
+ return sine * CLUTTER_ALPHA_MAX_ALPHA;
+#elif 0
return sinc_func (alpha, 2.0, 1.0);
-#else
+#elif 0
/* 2.0 above represents full circle */
return sincx1024_func (alpha, 1024, 1.0);
#endif
@@ -842,18 +861,17 @@ clutter_sine_inc_func (ClutterAlpha *alpha,
ClutterTimeline * timeline;
gint frame;
gint n_frames;
- float x;
- ClutterFixed sine;
+ float radians;
+ float sine;
timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline);
n_frames = clutter_timeline_get_n_frames (timeline);
- x = 256 * frame / n_frames;
-
- sine = sinf (x * (G_PI/180.0)) * CLUTTER_ALPHA_MAX_ALPHA;
+ radians = ((float)frame / n_frames) * (G_PI / 2);
+ sine = sinf (radians);
- return ((guint32) sine) >> COGL_FIXED_Q;
+ return (guint32) (sine * CLUTTER_ALPHA_MAX_ALPHA);
}
/**
@@ -884,18 +902,17 @@ clutter_sine_dec_func (ClutterAlpha *alpha,
ClutterTimeline * timeline;
gint frame;
gint n_frames;
- float x;
- ClutterFixed sine;
+ float radians;
+ float sine;
timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline);
n_frames = clutter_timeline_get_n_frames (timeline);
- x = 256 * frame / n_frames + 256;
-
- sine = sinf (x * (G_PI/180.0)) * CLUTTER_ALPHA_MAX_ALPHA;
+ radians = ((float)frame / n_frames) * (G_PI / 2);
+ sine = sinf (radians + (G_PI / 2));
- return ((guint32) sine) >> COGL_FIXED_Q;
+ return (guint32) (sine * CLUTTER_ALPHA_MAX_ALPHA);
}
/**
@@ -926,18 +943,17 @@ clutter_sine_half_func (ClutterAlpha *alpha,
ClutterTimeline *timeline;
gint frame;
gint n_frames;
- float x;
- ClutterFixed sine;
+ float radians;
+ float sine;
timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline);
n_frames = clutter_timeline_get_n_frames (timeline);
- x = 512 * frame / n_frames;
+ radians = ((float)frame / n_frames) * G_PI;
+ sine = sinf (radians);
- sine = sinf (x * (G_PI/180.0)) * CLUTTER_ALPHA_MAX_ALPHA;
-
- return ((guint32) sine) >> COGL_FIXED_Q;
+ return (guint32) (sine * CLUTTER_ALPHA_MAX_ALPHA);
}
/**
@@ -962,19 +978,20 @@ clutter_sine_in_func (ClutterAlpha *alpha,
ClutterTimeline *timeline;
gint frame;
gint n_frames;
- float x;
- ClutterFixed sine;
+ float radians;
+ float sine;
timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline);
n_frames = clutter_timeline_get_n_frames (timeline);
- /* XXX- if we use 768 we overflow */
- x = 256 * frame / n_frames + 767;
+ radians = ((float)frame / n_frames) * (G_PI / 2);
+ sine = sinf (radians - (G_PI / 2));
- sine = (sinf (x * (G_PI/180.0)) + 1) * CLUTTER_ALPHA_MAX_ALPHA;
+ /* shift from range [-1, 0] -> [0, 1] */
+ sine = sine + 1.0;
- return ((guint32) sine) >> COGL_FIXED_Q;
+ return (guint32) (sine * CLUTTER_ALPHA_MAX_ALPHA);
}
/**
@@ -998,18 +1015,17 @@ clutter_sine_out_func (ClutterAlpha *alpha,
ClutterTimeline *timeline;
gint frame;
gint n_frames;
- float x;
- ClutterFixed sine;
+ float radians;
+ float sine;
timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline);
n_frames = clutter_timeline_get_n_frames (timeline);
- x = 256 * frame / n_frames;
-
- sine = sinf (x * (G_PI/180.0)) * CLUTTER_ALPHA_MAX_ALPHA;
+ radians = ((float)frame / n_frames) * (G_PI / 2);
+ sine = sinf (radians);
- return ((guint32) sine) >> COGL_FIXED_Q;
+ return (guint32) (sine * CLUTTER_ALPHA_MAX_ALPHA);
}
/**
@@ -1034,18 +1050,20 @@ clutter_sine_in_out_func (ClutterAlpha *alpha,
ClutterTimeline *timeline;
gint frame;
gint n_frames;
- float x;
- ClutterFixed sine;
+ float radians;
+ float sine;
timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline);
n_frames = clutter_timeline_get_n_frames (timeline);
- x = -256 * frame / n_frames + 256;
+ radians = ((float)frame / n_frames) * G_PI;
+ sine = sinf (radians - (G_PI / 2));
- sine = (sinf (x * (G_PI/180.0)) + 1) / 2 * CLUTTER_ALPHA_MAX_ALPHA;
+ /* shift from range [-1, 1] -> [0, 1] */
+ sine = (sine + 1.0) / 2.0;
- return ((guint32) sine) >> COGL_FIXED_Q;
+ return (guint32) (sine * CLUTTER_ALPHA_MAX_ALPHA);
}
/**
@@ -1113,30 +1131,23 @@ clutter_smoothstep_inc_func (ClutterAlpha *alpha,
ClutterTimeline *timeline;
gint frame;
gint n_frames;
- guint32 r;
- guint32 x;
+ float r;
+ float x;
/*
* The smoothstep function uses f(x) = -2x^3 + 3x^2 where x is from <0,1>,
- * and precission is critical -- we use 8.24 fixed format for this operation.
- * The earlier operations involve division, which we cannot do in 8.24 for
- * numbers in <0,1> we use ClutterFixed.
+ * and precission is critical.
*/
timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline);
n_frames = clutter_timeline_get_n_frames (timeline);
- /*
- * Convert x to 8.24 for next step.
- */
- x = CLUTTER_FIXED_DIV (frame, n_frames) << 8;
+ x = (float)frame / n_frames;
/*
* f(x) = -2x^3 + 3x^2
- *
- * Convert result to ClutterFixed to avoid overflow in next step.
*/
- r = ((x >> 12) * (x >> 12) * 3 - (x >> 15) * (x >> 16) * (x >> 16)) >> 8;
+ r = -2 * x * x * x + 3 * x * x;
return (r * CLUTTER_ALPHA_MAX_ALPHA);
}
@@ -1204,9 +1215,9 @@ clutter_exp_inc_func (ClutterAlpha *alpha,
*
* (2^x_alpha_max) - 1 == CLUTTER_ALPHA_MAX_ALPHA
*/
-#if CLUTTER_ALPHA_MAX_ALPHA != 0xffff
-#error Adjust x_alpha_max to match CLUTTER_ALPHA_MAX_ALPHA
-#endif
+ /* XXX: If this fails:
+ * Adjust x_alpha_max to match CLUTTER_ALPHA_MAX_ALPHA */
+ g_assert (CLUTTER_ALPHA_MAX_ALPHA == 65535.0);
timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline);
@@ -1214,7 +1225,7 @@ clutter_exp_inc_func (ClutterAlpha *alpha,
x = x_alpha_max * frame / n_frames;
- result = CLAMP (pow2f (x) - 1, 0, CLUTTER_ALPHA_MAX_ALPHA);
+ result = CLAMP (powf (2, x) - 1, 0, CLUTTER_ALPHA_MAX_ALPHA);
return result;
}
@@ -1255,9 +1266,9 @@ clutter_exp_dec_func (ClutterAlpha *alpha,
*
* (2^x_alpha_max) - 1 == CLUTTER_ALPHA_MAX_ALPHA
*/
-#if CLUTTER_ALPHA_MAX_ALPHA != 0xffff
-#error Adjust x_alpha_max to match CLUTTER_ALPHA_MAX_ALPHA
-#endif
+ /* XXX: If this fails:
+ * Adjust x_alpha_max to match CLUTTER_ALPHA_MAX_ALPHA */
+ g_assert (CLUTTER_ALPHA_MAX_ALPHA == 65535.0);
timeline = clutter_alpha_get_timeline (alpha);
frame = clutter_timeline_get_current_frame (timeline);
@@ -1265,7 +1276,7 @@ clutter_exp_dec_func (ClutterAlpha *alpha,
x = (x_alpha_max * (n_frames - frame)) / n_frames;
- result = CLAMP (pow2f (x) - 1, 0, CLUTTER_ALPHA_MAX_ALPHA);
+ result = CLAMP (powf (2, x) - 1, 0, CLUTTER_ALPHA_MAX_ALPHA);
return result;
}

13
fixed-to-float-patches/clutter-alpha.h.0.patch Normal file
View File

@ -0,0 +1,13 @@
diff --git a/clutter/clutter-alpha.h b/clutter/clutter-alpha.h
index eba9e3f..e409d77 100644
--- a/clutter/clutter-alpha.h
+++ b/clutter/clutter-alpha.h
@@ -106,7 +106,7 @@ struct _ClutterAlphaClass
*
* Since: 0.2
*/
-#define CLUTTER_ALPHA_MAX_ALPHA (0xffff)
+#define CLUTTER_ALPHA_MAX_ALPHA (65535.0f)
GType clutter_alpha_get_type (void) G_GNUC_CONST;

380
fixed-to-float-patches/clutter-behaviour-ellipse.c.0.patch Normal file
View File

@ -0,0 +1,380 @@
diff --git a/clutter/clutter-behaviour-ellipse.c b/clutter/clutter-behaviour-ellipse.c
index 162a949..4212b95 100644
--- a/clutter/clutter-behaviour-ellipse.c
+++ b/clutter/clutter-behaviour-ellipse.c
@@ -190,17 +190,13 @@ actor_apply_knot_foreach (ClutterBehaviour *behave,
static inline float
clamp_angle (float a)
{
- float a1, a2;
gint rounds;
- /* Need to add the 256 offset here, since the user space 0 maps to our
- * -256
- */
- rounds = (a + 256) / 1024;
- a1 = rounds * 1024;
- a2 = a - a1;
+ rounds = a / 360;
+ if (a < 0)
+ rounds--;
- return a2;
+ return a - 360 * rounds;
}
static void
@@ -218,11 +214,11 @@ clutter_behaviour_ellipse_alpha_notify (ClutterBehaviour *behave,
if (priv->direction == CLUTTER_ROTATE_CW && start >= end)
{
- end += 1024;
+ end += 360;
}
else if (priv->direction == CLUTTER_ROTATE_CCW && start <= end)
{
- end -= 1024;
+ end -= 360;
}
angle = (end - start) * alpha / CLUTTER_ALPHA_MAX_ALPHA + start;
@@ -247,30 +243,25 @@ clutter_behaviour_ellipse_set_property (GObject *gobject,
switch (prop_id)
{
case PROP_ANGLE_START:
- priv->angle_start =
- COGL_ANGLE_FROM_DEG (g_value_get_double (value)) - 256;
+ priv->angle_start = g_value_get_double (value);
break;
case PROP_ANGLE_END:
- priv->angle_end =
- COGL_ANGLE_FROM_DEG (g_value_get_double (value)) - 256;
+ priv->angle_end = g_value_get_double (value);
break;
case PROP_ANGLE_TILT_X:
- priv->angle_tilt_x =
- COGL_ANGLE_FROM_DEG (g_value_get_double (value));
+ priv->angle_tilt_x = g_value_get_double (value);
break;
case PROP_ANGLE_TILT_Y:
- priv->angle_tilt_y =
- COGL_ANGLE_FROM_DEG (g_value_get_double (value));
+ priv->angle_tilt_y = g_value_get_double (value);
break;
case PROP_ANGLE_TILT_Z:
- priv->angle_tilt_z =
- COGL_ANGLE_FROM_DEG (g_value_get_double (value));
+ priv->angle_tilt_z = g_value_get_double (value);
break;
case PROP_WIDTH:
- priv->a = g_value_get_int (value) >> 1;
+ priv->a = g_value_get_int (value) / 2;
break;
case PROP_HEIGHT:
- priv->b = g_value_get_int (value) >> 1;
+ priv->b = g_value_get_int (value) / 2;
break;
case PROP_CENTER:
{
@@ -301,30 +292,25 @@ clutter_behaviour_ellipse_get_property (GObject *gobject,
switch (prop_id)
{
case PROP_ANGLE_START:
- g_value_set_double (value,
- COGL_ANGLE_TO_DEG (priv->angle_start + 256));
+ g_value_set_double (value, priv->angle_start);
break;
case PROP_ANGLE_END:
- g_value_set_double (value,
- COGL_ANGLE_TO_DEG (priv->angle_end + 256));
+ g_value_set_double (value, priv->angle_end);
break;
case PROP_ANGLE_TILT_X:
- g_value_set_double (value,
- COGL_ANGLE_TO_DEG (priv->angle_tilt_x));
+ g_value_set_double (value, priv->angle_tilt_x);
break;
case PROP_ANGLE_TILT_Y:
- g_value_set_double (value,
- COGL_ANGLE_TO_DEG (priv->angle_tilt_y));
+ g_value_set_double (value, priv->angle_tilt_y);
break;
case PROP_ANGLE_TILT_Z:
- g_value_set_double (value,
- COGL_ANGLE_TO_DEG (priv->angle_tilt_z));
+ g_value_set_double (value, priv->angle_tilt_z);
break;
case PROP_WIDTH:
- g_value_set_int (value, (priv->a << 1));
+ g_value_set_int (value, (priv->a * 2));
break;
case PROP_HEIGHT:
- g_value_set_int (value, (priv->b << 1));
+ g_value_set_int (value, (priv->b * 2));
break;
case PROP_CENTER:
g_value_set_boxed (value, &priv->center);
@@ -513,12 +499,8 @@ clutter_behaviour_ellipse_init (ClutterBehaviourEllipse * self)
priv->direction = CLUTTER_ROTATE_CW;
- /* The inital values have to reflect the 90 degree offset between the normal
- * mathematical space and the clutter clock-based space; the default end
- * value of 360 is clamped to 0.
- */
- priv->angle_start = -256;
- priv->angle_end = -256;
+ priv->angle_start = 0;
+ priv->angle_end = 0;
}
/**
@@ -611,8 +593,8 @@ clutter_behaviour_ellipse_newx (ClutterAlpha * alpha,
"width", width,
"height", height,
"direction", direction,
- "angle-start", COGL_ANGLE_FROM_DEGX (start),
- "angle-end", COGL_ANGLE_FROM_DEGX (end),
+ "angle-start", (double)CLUTTER_FIXED_TO_FLOAT (start),
+ "angle-end", (double)CLUTTER_FIXED_TO_FLOAT (end),
NULL);
}
@@ -695,9 +677,9 @@ clutter_behaviour_ellipse_set_width (ClutterBehaviourEllipse * self,
priv = self->priv;
- if (priv->a != width >> 1)
+ if (priv->a != width / 2)
{
- priv->a = width >> 1;
+ priv->a = width / 2;
g_object_notify (G_OBJECT (self), "width");
}
@@ -718,7 +700,7 @@ clutter_behaviour_ellipse_get_width (ClutterBehaviourEllipse *self)
{
g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0);
- return self->priv->a << 1;
+ return self->priv->a * 2;
}
/**
@@ -740,9 +722,9 @@ clutter_behaviour_ellipse_set_height (ClutterBehaviourEllipse *self,
priv = self->priv;
- if (priv->b != height >> 1)
+ if (priv->b != height / 2)
{
- priv->b = height >> 1;
+ priv->b = height / 2;
g_object_notify (G_OBJECT (self), "height");
}
@@ -763,7 +745,7 @@ clutter_behaviour_ellipse_get_height (ClutterBehaviourEllipse *self)
{
g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0);
- return self->priv->b << 1;
+ return self->priv->b * 2;
}
/**
@@ -780,10 +762,11 @@ void
clutter_behaviour_ellipse_set_angle_start (ClutterBehaviourEllipse *self,
gdouble angle_start)
{
+ ClutterFixed new_angle = CLUTTER_FLOAT_TO_FIXED (angle_start);
+
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
- clutter_behaviour_ellipse_set_angle_startx (self,
- CLUTTER_FLOAT_TO_FIXED (angle_start));
+ clutter_behaviour_ellipse_set_angle_startx (self, new_angle);
}
/**
@@ -805,7 +788,7 @@ clutter_behaviour_ellipse_set_angle_startx (ClutterBehaviourEllipse *self,
float new_angle;
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
- new_angle = clamp_angle (COGL_ANGLE_FROM_DEGX (angle_start) - 256);
+ new_angle = clamp_angle (CLUTTER_FIXED_TO_FLOAT (angle_start));
priv = self->priv;
if (priv->angle_start != new_angle)
@@ -830,7 +813,7 @@ clutter_behaviour_ellipse_get_angle_start (ClutterBehaviourEllipse *self)
{
g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0.0);
- return COGL_ANGLE_TO_DEG (self->priv->angle_start + 256);
+ return (double)self->priv->angle_start;
}
/**
@@ -848,7 +831,7 @@ clutter_behaviour_ellipse_get_angle_startx (ClutterBehaviourEllipse *self)
{
g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0);
- return COGL_ANGLE_TO_DEGX (self->priv->angle_start);
+ return CLUTTER_FLOAT_TO_FIXED (self->priv->angle_start);
}
/**
@@ -865,10 +848,11 @@ void
clutter_behaviour_ellipse_set_angle_end (ClutterBehaviourEllipse *self,
gdouble angle_end)
{
+ ClutterFixed new_angle = CLUTTER_FLOAT_TO_FIXED (angle_end);
+
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
- clutter_behaviour_ellipse_set_angle_endx (self,
- CLUTTER_FLOAT_TO_FIXED (angle_end));
+ clutter_behaviour_ellipse_set_angle_endx (self, new_angle);
}
/**
@@ -891,7 +875,7 @@ clutter_behaviour_ellipse_set_angle_endx (ClutterBehaviourEllipse *self,
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
- new_angle = clamp_angle (COGL_ANGLE_FROM_DEGX (angle_end) - 256);
+ new_angle = clamp_angle (CLUTTER_FIXED_TO_FLOAT (angle_end));
priv = self->priv;
@@ -918,7 +902,7 @@ clutter_behaviour_ellipse_get_angle_end (ClutterBehaviourEllipse *self)
{
g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0.0);
- return COGL_ANGLE_TO_DEG (self->priv->angle_end + 256);
+ return self->priv->angle_end;
}
/**
@@ -936,7 +920,7 @@ clutter_behaviour_ellipse_get_angle_endx (ClutterBehaviourEllipse *self)
{
g_return_val_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self), 0);
- return COGL_ANGLE_TO_DEGX (self->priv->angle_end);
+ return CLUTTER_FLOAT_TO_FIXED (self->priv->angle_end);
}
/**
@@ -955,11 +939,11 @@ clutter_behaviour_ellipse_set_angle_tilt (ClutterBehaviourEllipse *self,
ClutterRotateAxis axis,
gdouble angle_tilt)
{
+ ClutterFixed new_angle = CLUTTER_FLOAT_TO_FIXED (angle_tilt);
+
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
- clutter_behaviour_ellipse_set_angle_tiltx (self,
- axis,
- CLUTTER_FLOAT_TO_FIXED (angle_tilt));
+ clutter_behaviour_ellipse_set_angle_tiltx (self, axis, new_angle);
}
/**
@@ -983,7 +967,7 @@ clutter_behaviour_ellipse_set_angle_tiltx (ClutterBehaviourEllipse *self,
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
- new_angle = COGL_ANGLE_FROM_DEGX (angle_tilt);
+ new_angle = CLUTTER_FIXED_TO_FLOAT (angle_tilt);
priv = self->priv;
@@ -1038,11 +1022,11 @@ clutter_behaviour_ellipse_get_angle_tilt (ClutterBehaviourEllipse *self,
switch (axis)
{
case CLUTTER_X_AXIS:
- return COGL_ANGLE_TO_DEG (self->priv->angle_tilt_x);
+ return self->priv->angle_tilt_x;
case CLUTTER_Y_AXIS:
- return COGL_ANGLE_TO_DEG (self->priv->angle_tilt_y);
+ return self->priv->angle_tilt_y;
case CLUTTER_Z_AXIS:
- return COGL_ANGLE_TO_DEG (self->priv->angle_tilt_z);
+ return self->priv->angle_tilt_z;
}
return 0;
@@ -1068,11 +1052,11 @@ clutter_behaviour_ellipse_get_angle_tiltx (ClutterBehaviourEllipse *self,
switch (axis)
{
case CLUTTER_X_AXIS:
- return COGL_ANGLE_TO_DEGX (self->priv->angle_tilt_x);
+ return CLUTTER_FLOAT_TO_FIXED (self->priv->angle_tilt_x);
case CLUTTER_Y_AXIS:
- return COGL_ANGLE_TO_DEGX (self->priv->angle_tilt_y);
+ return CLUTTER_FLOAT_TO_FIXED (self->priv->angle_tilt_y);
case CLUTTER_Z_AXIS:
- return COGL_ANGLE_TO_DEGX (self->priv->angle_tilt_z);
+ return CLUTTER_FLOAT_TO_FIXED (self->priv->angle_tilt_z);
}
return 0;
@@ -1100,9 +1084,9 @@ clutter_behaviour_ellipse_set_tilt (ClutterBehaviourEllipse *self,
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
- new_angle_x = COGL_ANGLE_FROM_DEG (angle_tilt_x);
- new_angle_y = COGL_ANGLE_FROM_DEG (angle_tilt_y);
- new_angle_z = COGL_ANGLE_FROM_DEG (angle_tilt_z);
+ new_angle_x = (float)angle_tilt_x;
+ new_angle_y = (float)angle_tilt_y;
+ new_angle_z = (float)angle_tilt_z;
priv = self->priv;
@@ -1154,9 +1138,9 @@ clutter_behaviour_ellipse_set_tiltx (ClutterBehaviourEllipse *self,
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
- new_angle_x = COGL_ANGLE_FROM_DEGX (angle_tilt_x);
- new_angle_y = COGL_ANGLE_FROM_DEGX (angle_tilt_y);
- new_angle_z = COGL_ANGLE_FROM_DEGX (angle_tilt_z);
+ new_angle_x = CLUTTER_FIXED_TO_FLOAT (angle_tilt_x);
+ new_angle_y = CLUTTER_FIXED_TO_FLOAT (angle_tilt_y);
+ new_angle_z = CLUTTER_FIXED_TO_FLOAT (angle_tilt_z);
priv = self->priv;
@@ -1210,13 +1194,13 @@ clutter_behaviour_ellipse_get_tilt (ClutterBehaviourEllipse *self,
priv = self->priv;
if (angle_tilt_x)
- *angle_tilt_x = COGL_ANGLE_TO_DEG (priv->angle_tilt_x);
+ *angle_tilt_x = priv->angle_tilt_x;
if (angle_tilt_y)
- *angle_tilt_y = COGL_ANGLE_TO_DEG (priv->angle_tilt_y);
+ *angle_tilt_y = priv->angle_tilt_y;
if (angle_tilt_z)
- *angle_tilt_z = COGL_ANGLE_TO_DEG (priv->angle_tilt_z);
+ *angle_tilt_z = priv->angle_tilt_z;
}
/**
@@ -1246,13 +1230,13 @@ clutter_behaviour_ellipse_get_tiltx (ClutterBehaviourEllipse *self,
priv = self->priv;
if (angle_tilt_x)
- *angle_tilt_x = COGL_ANGLE_TO_DEGX (priv->angle_tilt_x);
+ *angle_tilt_x = priv->angle_tilt_x;
if (angle_tilt_y)
- *angle_tilt_y = COGL_ANGLE_TO_DEGX (priv->angle_tilt_y);
+ *angle_tilt_y = priv->angle_tilt_y;
if (angle_tilt_z)
- *angle_tilt_z = COGL_ANGLE_TO_DEGX (priv->angle_tilt_z);
+ *angle_tilt_z = priv->angle_tilt_z;
}
/**

13
fixed-to-float-patches/clutter-bezier.c.0.patch Normal file
View File

@ -0,0 +1,13 @@
diff --git a/clutter/clutter-bezier.c b/clutter/clutter-bezier.c
index 6a47626..66c4ddf 100644
--- a/clutter/clutter-bezier.c
+++ b/clutter/clutter-bezier.c
@@ -252,7 +252,7 @@ _clutter_bezier_init (ClutterBezier *b,
int x = _clutter_bezier_t2x (b, t);
int y = _clutter_bezier_t2y (b, t);
- guint l = clutter_sqrti ((y - yp)*(y - yp) + (x - xp)*(x - xp));
+ guint l = cogl_sqrti ((y - yp)*(y - yp) + (x - xp)*(x - xp));
l += length[i-1];

15
fixed-to-float-patches/clutter-fixed.c.0.patch Normal file
View File

@ -0,0 +1,15 @@
diff --git a/clutter/clutter-fixed.c b/clutter/clutter-fixed.c
index 3027a75..315fe32 100644
--- a/clutter/clutter-fixed.c
+++ b/clutter/clutter-fixed.c
@@ -251,8 +251,8 @@ param_fixed_init (GParamSpec *pspec)
{
ClutterParamSpecFixed *fspec = CLUTTER_PARAM_SPEC_FIXED (pspec);
- fspec->minimum = COGL_FIXED_MIN;
- fspec->maximum = COGL_FIXED_MAX;
+ fspec->minimum = CLUTTER_MAXFIXED;
+ fspec->maximum = CLUTTER_MINFIXED;
fspec->default_value = 0;
}

333
fixed-to-float-patches/clutter-fixed.h.0.patch Normal file
View File

@ -0,0 +1,333 @@
diff --git a/clutter/clutter-fixed.h b/clutter/clutter-fixed.h
index 3ae0916..61e2fd4 100644
--- a/clutter/clutter-fixed.h
+++ b/clutter/clutter-fixed.h
@@ -39,126 +39,118 @@ G_BEGIN_DECLS
*
* Fixed point number (16.16)
*/
-typedef CoglFixed ClutterFixed;
+typedef float ClutterFixed;
/**
* ClutterAngle:
*
- * Integer representation of an angle such that 1024 corresponds to
- * full circle (i.e., 2*Pi).
+ * An abstract representation of an angle.
*/
-typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
+typedef float ClutterAngle;
-#define CLUTTER_ANGLE_FROM_DEG(x) (COGL_ANGLE_FROM_DEG (x))
-#define CLUTTER_ANGLE_FROM_DEGX(x) (COGL_ANGLE_FROM_DEGX (x))
-#define CLUTTER_ANGLE_TO_DEG(x) (COGL_ANGLE_TO_DEG (x))
-#define CLUTTER_ANGLE_TO_DEGX(x) (COGL_ANGLE_TO_DEGX (x))
+#define CLUTTER_ANGLE_FROM_DEG(x) ((float)(x))
+#define CLUTTER_ANGLE_FROM_DEGX(x) (CLUTTER_FIXED_TO_FLOAT (x))
+#define CLUTTER_ANGLE_TO_DEG(x) ((float)(x))
+#define CLUTTER_ANGLE_TO_DEGX(x) (CLUTTER_FLOAT_TO_FIXED (x))
/*
* some commonly used constants
*/
/**
- * CFX_Q:
- *
- * Size in bits of decimal part of floating point value.
- */
-#define CFX_Q COGL_FIXED_Q
-
-/**
* CFX_ONE:
*
* 1.0 represented as a fixed point value.
*/
-#define CFX_ONE COGL_FIXED_1
+#define CFX_ONE 1.0
/**
* CFX_HALF:
*
* 0.5 represented as a fixed point value.
*/
-#define CFX_HALF COGL_FIXED_0_5
+#define CFX_HALF 0.5
/**
* CFX_MAX:
*
* Maximum fixed point value.
*/
-#define CFX_MAX COGL_FIXED_MAX
+#define CFX_MAX G_MAXFLOAT
/**
* CFX_MIN:
*
* Minimum fixed point value.
*/
-#define CFX_MIN COGL_FIXED_MIN
+#define CFX_MIN (-G_MAXFLOAT)
/**
* CFX_PI:
*
* Fixed point representation of Pi
*/
-#define CFX_PI COGL_FIXED_PI
+#define CFX_PI G_PI
/**
* CFX_2PI:
*
* Fixed point representation of Pi*2
*/
-#define CFX_2PI COGL_FIXED_2_PI
+#define CFX_2PI (G_PI * 2)
/**
* CFX_PI_2:
*
* Fixed point representation of Pi/2
*/
-#define CFX_PI_2 COGL_FIXED_PI_2
+#define CFX_PI_2 (G_PI / 2)
/**
* CFX_PI_4:
*
* Fixed point representation of Pi/4
*/
-#define CFX_PI_4 COGL_FIXED_PI_4
+#define CFX_PI_4 (G_PI / 4)
/**
* CFX_360:
*
* Fixed point representation of the number 360
*/
-#define CFX_360 COGL_FIXED_360
+#define CFX_360 360.0
/**
* CFX_240:
*
* Fixed point representation of the number 240
*/
-#define CFX_240 COGL_FIXED_240
+#define CFX_240 240.0
/**
* CFX_180:
*
* Fixed point representation of the number 180
*/
-#define CFX_180 COGL_FIXED_180
+#define CFX_180 180.0
/**
* CFX_120:
*
* Fixed point representation of the number 120
*/
-#define CFX_120 COGL_FIXED_120
+#define CFX_120 120.0
/**
* CFX_60:
*
* Fixed point representation of the number 60
*/
-#define CFX_60 COGL_FIXED_60
+#define CFX_60 60.0
/**
* CFX_RADIANS_TO_DEGREES:
*
* Fixed point representation of the number 180 / pi
*/
-#define CFX_RADIANS_TO_DEGREES COGL_RADIANS_TO_DEGREES
+#define CFX_RADIANS_TO_DEGREES (180.0 / G_PI)
/**
* CFX_255:
*
* Fixed point representation of the number 255
*/
-#define CFX_255 COGL_FIXED_255
+#define CFX_255 255.0
/**
* CLUTTER_FIXED_TO_FLOAT:
@@ -166,7 +158,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
*
* Convert a fixed point value to float.
*/
-#define CLUTTER_FIXED_TO_FLOAT(x) COGL_FIXED_TO_FLOAT ((x))
+#define CLUTTER_FIXED_TO_FLOAT(x) (x)
/**
* CLUTTER_FIXED_TO_DOUBLE:
@@ -174,7 +166,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
*
* Convert a fixed point value to double.
*/
-#define CLUTTER_FIXED_TO_DOUBLE(x) COGL_FIXED_TO_DOUBLE ((x))
+#define CLUTTER_FIXED_TO_DOUBLE(x) ((double)(x))
/**
* CLUTTER_FLOAT_TO_FIXED:
@@ -182,7 +174,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
*
* Convert a float value to fixed.
*/
-#define CLUTTER_FLOAT_TO_FIXED(x) COGL_FIXED_FROM_FLOAT ((x))
+#define CLUTTER_FLOAT_TO_FIXED(x) ((x))
/**
* CLUTTER_FLOAT_TO_INT:
@@ -190,7 +182,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
*
* Convert a float value to int.
*/
-#define CLUTTER_FLOAT_TO_INT(x) COGL_FLOAT_TO_INT ((x))
+#define CLUTTER_FLOAT_TO_INT(x) ((int)(x))
/**
* CLUTTER_FLOAT_TO_UINT:
@@ -198,7 +190,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
*
* Convert a float value to unsigned int.
*/
-#define CLUTTER_FLOAT_TO_UINT(x) COGL_FLOAT_TO_UINT ((x))
+#define CLUTTER_FLOAT_TO_UINT(x) ((unsigned int)(x))
/**
* CLUTTER_INT_TO_FIXED:
@@ -206,7 +198,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
*
* Convert an integer value to fixed point.
*/
-#define CLUTTER_INT_TO_FIXED(x) COGL_FIXED_FROM_INT ((x))
+#define CLUTTER_INT_TO_FIXED(x) ((float)(x))
/**
* CLUTTER_FIXED_TO_INT:
@@ -216,7 +208,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
*
* Since: 0.6
*/
-#define CLUTTER_FIXED_TO_INT(x) COGL_FIXED_TO_INT ((x))
+#define CLUTTER_FIXED_TO_INT(x) ((int)(x))
/**
* CLUTTER_FIXED_FRACTION:
@@ -224,7 +216,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
*
* Retrieves the fractionary part of a fixed point value
*/
-#define CLUTTER_FIXED_FRACTION(x) COGL_FIXED_FRACTION ((x))
+#define CLUTTER_FIXED_FRACTION(x) ((x)-floorf (x))
/**
* CLUTTER_FIXED_FLOOR:
@@ -232,7 +224,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
*
* Round down a fixed point value to an integer.
*/
-#define CLUTTER_FIXED_FLOOR(x) COGL_FIXED_FLOOR ((x))
+#define CLUTTER_FIXED_FLOOR(x) (floorf (x))
/**
* CLUTTER_FIXED_CEIL:
@@ -240,7 +232,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
*
* Round up a fixed point value to an integer.
*/
-#define CLUTTER_FIXED_CEIL(x) COGL_FIXED_CEIL ((x))
+#define CLUTTER_FIXED_CEIL(x) (ceilf (x))
/**
* CLUTTER_FIXED_MUL:
@@ -249,7 +241,7 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
*
* Multiply two fixed point values
*/
-#define CLUTTER_FIXED_MUL(x,y) COGL_FIXED_MUL ((x), (y))
+#define CLUTTER_FIXED_MUL(x,y) ((x) * (y))
/**
* CLUTTER_FIXED_DIV:
@@ -258,54 +250,16 @@ typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
*
* Divide two fixed point values
*/
-#define CLUTTER_FIXED_DIV(x,y) COGL_FIXED_DIV ((x), (y))
-
-#define clutter_qmulx(x,y) cogl_fixed_mul ((x), (y))
-#define clutter_qdivx(x,y) cogl_fixed_div ((x), (y))
-
-#define clutter_sinx(a) cogl_fixed_sin ((a))
-#define clutter_sini(a) cogl_angle_sin ((a))
-#define clutter_tani(a) cogl_angle_tan ((a))
-#define clutter_atani(a) cogl_fixed_atan ((a))
-#define clutter_atan2i(x,y) cogl_fixed_atan2 ((x), (y))
-#define clutter_cosx(a) cogl_fixed_cos ((a))
-#define clutter_cosi(a) cogl_angle_cos ((a))
-
-/**
- * CLUTTER_SQRTI_ARG_MAX
- *
- * Maximum argument that can be passed to #clutter_sqrti function.
- *
- * Since: 0.6
- */
-#define CLUTTER_SQRTI_ARG_MAX COGL_SQRTI_ARG_MAX
-
-/**
- * CLUTTER_SQRTI_ARG_5_PERCENT
- *
- * Maximum argument that can be passed to #clutter_sqrti for which the
- * resulting error is < 5%
- *
- * Since: 0.6
- */
-#define CLUTTER_SQRTI_ARG_5_PERCENT COGL_SQRTI_ARG_5_PERCENT
-
-/**
- * CLUTTER_SQRTI_ARG_10_PERCENT
- *
- * Maximum argument that can be passed to #clutter_sqrti for which the
- * resulting error is < 10%
- *
- * Since: 0.6
- */
-#define CLUTTER_SQRTI_ARG_10_PERCENT COGL_SQRTI_ARG_10_PERCENT
+#define CLUTTER_FIXED_DIV(x,y) ((x) / (y))
-#define clutter_sqrtx(x) cogl_fixed_sqrt ((x))
-#define clutter_sqrti(x) cogl_sqrti ((x))
+#define clutter_qmulx(x,y) ((x) * (y))
+#define clutter_qdivx(x,y) ((x) / (y))
-#define clutter_log2x(x) cogl_fixed_log2 ((x))
-#define clutter_pow2x(x) cogl_fixed_pow2 ((x))
-#define clutter_powx(x,y) cogl_fixed_pow ((x), (y))
+#define clutter_sinx(a) sinf (a * (G_PI/180.0))
+#define clutter_tanx(a) tanf (a * (G_PI/180.0))
+#define clutter_atanx(a) atanf (a * (G_PI/180.0))
+#define clutter_atan2x(x,y) atan2f (x, y)
+#define clutter_cosx(a) cosf (a * (G_PI/180.0))
#define CLUTTER_TYPE_FIXED (clutter_fixed_get_type ())
#define CLUTTER_TYPE_PARAM_FIXED (clutter_param_fixed_get_type ())
@@ -331,7 +285,7 @@ typedef struct _ClutterParamSpecFixed ClutterParamSpecFixed;
*
* Since: 0.8
*/
-#define CLUTTER_MAXFIXED COGL_FIXED_MAX
+#define CLUTTER_MAXFIXED G_MAXFLOAT
/**
* CLUTTER_MINFIXED:
@@ -340,7 +294,7 @@ typedef struct _ClutterParamSpecFixed ClutterParamSpecFixed;
*
* Since: 0.8
*/
-#define CLUTTER_MINFIXED COGL_FIXED_MIN
+#define CLUTTER_MINFIXED (-G_MAXFLOAT)
/**
* ClutterParamSpecFixed

18
fixed-to-float-patches/clutter-path.c.0.patch Normal file
View File

@ -0,0 +1,18 @@
diff --git a/clutter/clutter-path.c b/clutter/clutter-path.c
index 6f93402..c459cdf 100644
--- a/clutter/clutter-path.c
+++ b/clutter/clutter-path.c
@@ -1217,11 +1217,11 @@ clutter_path_node_distance (const ClutterKnot *start,
* If we are using limited precision sqrti implementation, fallback on
* clib sqrt if the precission would be less than 10%
*/
-#if INT_MAX > CLUTTER_SQRTI_ARG_10_PERCENT
+#if INT_MAX > COGL_SQRTI_ARG_10_PERCENT
if (t <= COGL_SQRTI_ARG_10_PERCENT)
return cogl_sqrti (t);
else
- return COGL_FLOAT_TO_INT (sqrt(t));
+ return COGL_FLOAT_TO_INT (sqrtf(t));
#else
return cogl_sqrti (t);
#endif

13
fixed-to-float-patches/clutter-texture.c.0.patch Normal file
View File

@ -0,0 +1,13 @@
diff --git a/clutter/clutter-texture.c b/clutter/clutter-texture.c
index b0b46e4..8a306e9 100644
--- a/clutter/clutter-texture.c
+++ b/clutter/clutter-texture.c
@@ -474,7 +474,7 @@ clutter_texture_set_fbo_projection (ClutterActor *self)
/* Set up a projection matrix so that the actor will be projected as
if it was drawn at its original location */
- tan_angle = tanf (COGL_ANGLE_FROM_DEGX (perspective.fovy / 2 * (G_PI/180.0)));
+ tan_angle = tanf ((perspective.fovy / 2) * (G_PI/180.0));
near_size = CLUTTER_FIXED_MUL (perspective.z_near, tan_angle);
cogl_frustum (CLUTTER_FIXED_MUL (tx_min, near_size),

91
fixed-to-float-patches/clutter-units.h.0.patch Normal file
View File

@ -0,0 +1,91 @@
diff --git a/clutter/clutter-units.h b/clutter/clutter-units.h
index b85375a..1084095 100644
--- a/clutter/clutter-units.h
+++ b/clutter/clutter-units.h
@@ -42,7 +42,7 @@ G_BEGIN_DECLS
*
* Since: 0.4
*/
-typedef gint32 ClutterUnit;
+typedef float ClutterUnit;
/*
* Currently CLUTTER_UNIT maps directly onto ClutterFixed. Nevertheless, the
@@ -50,16 +50,16 @@ typedef gint32 ClutterUnit;
* decide to change this relationship in the future.
*/
-#define CLUTTER_UNITS_FROM_INT(x) (COGL_FIXED_FROM_INT ((x)))
-#define CLUTTER_UNITS_TO_INT(x) (COGL_FIXED_TO_INT ((x)))
+#define CLUTTER_UNITS_FROM_INT(x) ((float)(x))
+#define CLUTTER_UNITS_TO_INT(x) ((int)(x))
-#define CLUTTER_UNITS_FROM_FLOAT(x) (COGL_FIXED_FROM_FLOAT ((x)))
-#define CLUTTER_UNITS_TO_FLOAT(x) (COGL_FIXED_TO_FLOAT ((x)))
+#define CLUTTER_UNITS_FROM_FLOAT(x) (x)
+#define CLUTTER_UNITS_TO_FLOAT(x) (x)
#define CLUTTER_UNITS_FROM_FIXED(x) (x)
#define CLUTTER_UNITS_TO_FIXED(x) (x)
-#define CLUTTER_UNITS_FORMAT "d"
+#define CLUTTER_UNITS_FORMAT "f"
/**
* CLUTTER_UNITS_FROM_DEVICE:
@@ -92,7 +92,7 @@ typedef gint32 ClutterUnit;
*
* Since: 0.6
*/
-#define CLUTTER_UNITS_FROM_PANGO_UNIT(x) ((x) << 6)
+#define CLUTTER_UNITS_FROM_PANGO_UNIT(x) ((float)(x / 1024))
/**
* CLUTTER_UNITS_TO_PANGO_UNIT:
@@ -102,7 +102,7 @@ typedef gint32 ClutterUnit;
*
* Since: 0.6
*/
-#define CLUTTER_UNITS_TO_PANGO_UNIT(x) ((x) >> 6)
+#define CLUTTER_UNITS_TO_PANGO_UNIT(x) ((int)(x * 1024))
#define CLUTTER_UNITS_FROM_STAGE_WIDTH_PERCENTAGE(x) \
((clutter_actor_get_widthu (clutter_stage_get_default ()) * x) / 100)
@@ -127,8 +127,7 @@ typedef gint32 ClutterUnit;
#define CLUTTER_UNITS_FROM_MM(x) \
(CLUTTER_UNITS_FROM_FLOAT ((((x) * clutter_stage_get_resolution ((ClutterStage *) clutter_stage_get_default ())) / 25.4)))
-#define CLUTTER_UNITS_FROM_MMX(x) \
- (CFX_DIV (CFX_MUL ((x), clutter_stage_get_resolutionx ((ClutterStage *) clutter_stage_get_default ())), 0x196666))
+#define CLUTTER_UNITS_FROM_MMX(x) CLUTTER_UNITS_FROM_MM
/**
* CLUTTER_UNITS_FROM_POINTS:
@@ -141,9 +140,6 @@ typedef gint32 ClutterUnit;
#define CLUTTER_UNITS_FROM_POINTS(x) \
CLUTTER_UNITS_FROM_FLOAT ((((x) * clutter_stage_get_resolution ((ClutterStage *) clutter_stage_get_default ())) / 72.0))
-#define CLUTTER_UNITS_FROM_POINTSX(x) \
- (CFX_MUL ((x), clutter_stage_get_resolutionx ((ClutterStage *) clutter_stage_get_default ())) / 72)
-
#define CLUTTER_TYPE_UNIT (clutter_unit_get_type ())
#define CLUTTER_TYPE_PARAM_UNIT (clutter_param_unit_get_type ())
#define CLUTTER_PARAM_SPEC_UNIT(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), CLUTTER_TYPE_PARAM_UNIT, ClutterParamSpecUnit))
@@ -156,7 +152,7 @@ typedef gint32 ClutterUnit;
*
* Since: 0.8
*/
-#define CLUTTER_MAXUNIT (0x7fffffff)
+#define CLUTTER_MAXUNIT (G_MAXFLOAT)
/**
* CLUTTER_MINUNIT:
@@ -165,7 +161,7 @@ typedef gint32 ClutterUnit;
*
* Since: 0.8
*/
-#define CLUTTER_MINUNIT (0x80000000)
+#define CLUTTER_MINUNIT (-G_MAXFLOAT)
/**
* CLUTTER_VALUE_HOLDS_UNIT:

17
fixed-to-float-patches/cogl-fixed.c.0.patch Normal file
View File

@ -0,0 +1,17 @@
diff --git a/clutter/cogl/common/cogl-fixed.c b/clutter/cogl/common/cogl-fixed.c
index 348d2ce..2e27da1 100644
--- a/clutter/cogl/common/cogl-fixed.c
+++ b/clutter/cogl/common/cogl-fixed.c
@@ -482,6 +482,12 @@ cogl_angle_sin (CoglAngle angle)
}
CoglFixed
+cogl_fixed_tan (CoglFixed angle)
+{
+ return cogl_angle_tan (COGL_ANGLE_FROM_DEGX (angle));
+}
+
+CoglFixed
cogl_angle_tan (CoglAngle angle)
{
int sign = 1;

23
fixed-to-float-patches/cogl-fixed.h.0.patch Normal file
View File

@ -0,0 +1,23 @@
diff --git a/clutter/cogl/cogl-fixed.h b/clutter/cogl/cogl-fixed.h
index a521074..8d7c9e9 100644
--- a/clutter/cogl/cogl-fixed.h
+++ b/clutter/cogl/cogl-fixed.h
@@ -456,6 +456,18 @@ G_BEGIN_DECLS
CoglFixed cogl_fixed_sin (CoglFixed angle);
/**
+ * cogl_fixed_tan:
+ * @angle: a #CoglFixed number
+ *
+ * Computes the tangent of @angle.
+ *
+ * Return value: the tangent of the passed angle, in fixed point notation
+ *
+ * Since: 1.0
+ */
+CoglFixed cogl_fixed_tan (CoglFixed angle);
+
+/**
* cogl_fixed_cos:
* @angle: a #CoglFixed number
*

24
fixed-to-float-patches/cogl-pango-render.c.0.patch Normal file
View File

@ -0,0 +1,24 @@
diff --git a/clutter/pango/cogl-pango-render.c b/clutter/pango/cogl-pango-render.c
index d8f87fb..3e23309 100644
--- a/clutter/pango/cogl-pango-render.c
+++ b/clutter/pango/cogl-pango-render.c
@@ -102,8 +102,6 @@ cogl_pango_renderer_draw_glyph (CoglPangoRenderer *priv,
*(p++) = cache_value->tx2; *(p++) = cache_value->ty2;
}
-#define COGL_PANGO_UNIT_TO_FIXED(x) ((x) << (COGL_FIXED_Q - 10))
-
static void cogl_pango_renderer_finalize (GObject *object);
static void cogl_pango_renderer_draw_glyphs (PangoRenderer *renderer,
PangoFont *font,
@@ -439,8 +437,8 @@ cogl_pango_renderer_get_device_units (PangoRenderer *renderer,
}
else
{
- *xout = COGL_PANGO_UNIT_TO_FIXED (xin);
- *yout = COGL_PANGO_UNIT_TO_FIXED (yin);
+ *xout = PANGO_PIXELS (xin);
+ *yout = PANGO_PIXELS (yin);
}
}

12
fixed-to-float-patches/cogl-primitives.c.0.patch Normal file
View File

@ -0,0 +1,12 @@
diff --git a/clutter/cogl/common/cogl-primitives.c b/clutter/cogl/common/cogl-primitives.c
index 27e0e36..27834f7 100644
--- a/clutter/cogl/common/cogl-primitives.c
+++ b/clutter/cogl/common/cogl-primitives.c
@@ -33,6 +33,7 @@
#include <string.h>
#include <gmodule.h>
+#include <math.h>
#define _COGL_MAX_BEZ_RECURSE_DEPTH 16

26
fixed-to-float-patches/cogl.h.in.0.patch Normal file
View File

@ -0,0 +1,26 @@
diff --git a/clutter/cogl/cogl.h.in b/clutter/cogl/cogl.h.in
index cc26f88..f37d54d 100644
--- a/clutter/cogl/cogl.h.in
+++ b/clutter/cogl/cogl.h.in
@@ -271,9 +271,9 @@ void cogl_translate (gint x,
* rotation.
*/
void cogl_rotatex (float angle,
- gint x,
- gint y,
- gint z);
+ float x,
+ float y,
+ float z);
/**
* cogl_rotate:
@@ -442,7 +442,7 @@ void cogl_enable_backface_culling (gboolean setting);
* comparing with the value in @ref. The default function is CGL_ALWAYS the
* initial reference value is 1.0.
*/
-void cogl_alpha_func (COGLenum func,
+void cogl_alpha_func (COGLenum func,
float ref);
/**

12
fixed-to-float-patches/gl-cogl-primitives.c.0.patch Normal file
View File

@ -0,0 +1,12 @@
diff --git a/clutter/cogl/gl/cogl-primitives.c b/clutter/cogl/gl/cogl-primitives.c
index dc5c5c6..8a0843d 100644
--- a/clutter/cogl/gl/cogl-primitives.c
+++ b/clutter/cogl/gl/cogl-primitives.c
@@ -34,6 +34,7 @@
#include <string.h>
#include <gmodule.h>
+#include <math.h>
#define _COGL_MAX_BEZ_RECURSE_DEPTH 16

30
fixed-to-float-patches/gl-cogl-texture.c.0.patch Normal file
View File

@ -0,0 +1,30 @@
diff --git a/clutter/cogl/gl/cogl-texture.c b/clutter/cogl/gl/cogl-texture.c
index 5b7326c..1dac073 100644
--- a/clutter/cogl/gl/cogl-texture.c
+++ b/clutter/cogl/gl/cogl-texture.c
@@ -37,6 +37,7 @@
#include <string.h>
#include <stdlib.h>
+#include <math.h>
/*
#define COGL_DEBUG 1
@@ -555,7 +556,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
guint wx, wy;
src = source_bmp->data
- + (src_y + (y_iter.intersect_start)
+ + (src_y + ((int)y_iter.intersect_start)
- dst_y)
* source_bmp->rowstride
+ (src_x + x_span->start + x_span->size - x_span->waste
@@ -600,7 +601,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
guint copy_width;
src = source_bmp->data
- + (src_x + (x_iter.intersect_start)
+ + (src_x + ((int)x_iter.intersect_start)
- dst_x)
* bpp
+ (src_y + y_span->start + y_span->size - y_span->waste

172
fixed-to-float-patches/gl-cogl.c.0.patch Normal file
View File

@ -0,0 +1,172 @@
diff --git a/clutter/cogl/gl/cogl.c b/clutter/cogl/gl/cogl.c
index 7b61b63..d815e3b 100644
--- a/clutter/cogl/gl/cogl.c
+++ b/clutter/cogl/gl/cogl.c
@@ -211,17 +211,17 @@ cogl_pop_matrix (void)
void
cogl_scale (float x, float y)
{
- glScaled ((double)(x),
- (double)(y),
+ glScalef ((float)(x),
+ (float)(y),
1.0);
}
void
cogl_translatex (float x, float y, float z)
{
- glTranslated ((double)(x),
- (double)(y),
- (double)(z));
+ glTranslatef ((float)(x),
+ (float)(y),
+ (float)(z));
}
void
@@ -231,12 +231,12 @@ cogl_translate (gint x, gint y, gint z)
}
void
-cogl_rotatex (float angle, gint x, gint y, gint z)
+cogl_rotatex (float angle, float x, float y, float z)
{
- glRotated ((double)(angle),
- (double)(x),
- (double)(y),
- (double)(z));
+ glRotatef ((float)(angle),
+ (float)(x),
+ (float)(y),
+ (float)(z));
}
void
@@ -645,17 +645,13 @@ cogl_perspective (float fovy,
* 2) When working with small numbers, we are loosing significant
* precision
*/
- ymax =
- (zNear *
- (sinf (fovy_rad_half) /
- cosf (fovy_rad_half)));
-
+ ymax = (zNear * (sinf (fovy_rad_half) / cosf (fovy_rad_half)));
xmax = (ymax * aspect);
x = (zNear / xmax);
y = (zNear / ymax);
c = (-(zFar + zNear) / ( zFar - zNear));
- d = cogl_fixed_mul_div (-(2 * zFar), zNear, (zFar - zNear));
+ d = (-(2 * zFar) * zNear) / (zFar - zNear);
#define M(row,col) m[col*4+row]
M(0,0) = (x);
@@ -696,12 +692,12 @@ cogl_frustum (float left,
GE( glMatrixMode (GL_PROJECTION) );
GE( glLoadIdentity () );
- GE( glFrustum ((double)(left),
- (double)(right),
- (double)(bottom),
- (double)(top),
- (double)(z_near),
- (double)(z_far)) );
+ GE( glFrustum ((GLdouble)(left),
+ (GLdouble)(right),
+ (GLdouble)(bottom),
+ (GLdouble)(top),
+ (GLdouble)(z_near),
+ (GLdouble)(z_far)) );
GE( glMatrixMode (GL_MODELVIEW) );
@@ -773,9 +769,7 @@ cogl_setup_viewport (guint width,
{
float fovy_rad = (fovy * G_PI) / 180;
- z_camera =
- ((sinf (fovy_rad) /
- cosf (fovy_rad)) >> 1);
+ z_camera = ((sinf (fovy_rad) / cosf (fovy_rad)) / 2);
}
GE( glTranslatef (-0.5f, -0.5f, -z_camera) );
@@ -1166,73 +1160,19 @@ cogl_features_available (CoglFeatureFlags features)
void
cogl_get_modelview_matrix (float m[16])
{
- GLdouble md[16];
-
- glGetDoublev(GL_MODELVIEW_MATRIX, &md[0]);
-
-#define M(m,row,col) m[col*4+row]
- M(m,0,0) = (M(md,0,0));
- M(m,0,1) = (M(md,0,1));
- M(m,0,2) = (M(md,0,2));
- M(m,0,3) = (M(md,0,3));
-
- M(m,1,0) = (M(md,1,0));
- M(m,1,1) = (M(md,1,1));
- M(m,1,2) = (M(md,1,2));
- M(m,1,3) = (M(md,1,3));
-
- M(m,2,0) = (M(md,2,0));
- M(m,2,1) = (M(md,2,1));
- M(m,2,2) = (M(md,2,2));
- M(m,2,3) = (M(md,2,3));
-
- M(m,3,0) = (M(md,3,0));
- M(m,3,1) = (M(md,3,1));
- M(m,3,2) = (M(md,3,2));
- M(m,3,3) = (M(md,3,3));
-#undef M
+ glGetFloatv (GL_MODELVIEW_MATRIX, m);
}
void
cogl_get_projection_matrix (float m[16])
{
- GLdouble md[16];
-
- glGetDoublev(GL_PROJECTION_MATRIX, &md[0]);
-
-#define M(m,row,col) m[col*4+row]
- M(m,0,0) = (M(md,0,0));
- M(m,0,1) = (M(md,0,1));
- M(m,0,2) = (M(md,0,2));
- M(m,0,3) = (M(md,0,3));
-
- M(m,1,0) = (M(md,1,0));
- M(m,1,1) = (M(md,1,1));
- M(m,1,2) = (M(md,1,2));
- M(m,1,3) = (M(md,1,3));
-
- M(m,2,0) = (M(md,2,0));
- M(m,2,1) = (M(md,2,1));
- M(m,2,2) = (M(md,2,2));
- M(m,2,3) = (M(md,2,3));
-
- M(m,3,0) = (M(md,3,0));
- M(m,3,1) = (M(md,3,1));
- M(m,3,2) = (M(md,3,2));
- M(m,3,3) = (M(md,3,3));
-#undef M
+ glGetFloatv (GL_PROJECTION_MATRIX, m);
}
void
cogl_get_viewport (float v[4])
{
- GLdouble vd[4];
- glGetDoublev(GL_VIEWPORT, &vd[0]);
-
- v[0] = (vd[0]);
- v[1] = (vd[1]);
- v[2] = (vd[2]);
- v[3] = (vd[3]);
+ glGetFloatv (GL_VIEWPORT, v);
}
void

90
fixed-to-float-patches/gles-cogl-gles2-wrapper.c.0.patch Normal file
View File

@ -0,0 +1,90 @@
diff --git a/clutter/cogl/gles/cogl-gles2-wrapper.c b/clutter/cogl/gles/cogl-gles2-wrapper.c
index b2e19eb..a7800c5 100644
--- a/clutter/cogl/gles/cogl-gles2-wrapper.c
+++ b/clutter/cogl/gles/cogl-gles2-wrapper.c
@@ -515,15 +515,6 @@ cogl_gles2_wrapper_update_matrix (CoglGles2Wrapper *wrapper, GLenum matrix_num)
}
void
-cogl_wrap_glClearColorx (GLclampx r, GLclampx g, GLclampx b, GLclampx a)
-{
- glClearColor ( (r),
- (g),
- (b),
- (a));
-}
-
-void
cogl_wrap_glPushMatrix ()
{
const float *src;
@@ -1143,13 +1134,9 @@ cogl_wrap_glAlphaFunc (GLenum func, GLclampf ref)
}
void
-cogl_wrap_glColor4f (GLclampx r, GLclampx g, GLclampx b, GLclampx a)
+cogl_wrap_glColor4f (GLclampf r, GLclampf g, GLclampf b, GLclampf a)
{
- glVertexAttrib4f (COGL_GLES2_WRAPPER_COLOR_ATTRIB,
- (r),
- (g),
- (b),
- (a));
+ glVertexAttrib4f (COGL_GLES2_WRAPPER_COLOR_ATTRIB, r, g, b, a);
}
void
@@ -1158,15 +1145,6 @@ cogl_wrap_glClipPlanex (GLenum plane, GLfloat *equation)
/* FIXME */
}
-static void
-cogl_gles2_float_array_to_fixed (int size,
- const GLfloat *floats,
- GLfloat *fixeds)
-{
- while (size-- > 0)
- *(fixeds++) = (*(floats++));
-}
-
void
cogl_wrap_glGetIntegerv (GLenum pname, GLint *params)
{
@@ -1185,31 +1163,24 @@ cogl_wrap_glGetIntegerv (GLenum pname, GLint *params)
}
void
-cogl_wrap_glGetFixedv (GLenum pname, GLfloat *params)
+cogl_wrap_glGetFloatv (GLenum pname, GLfloat *params)
{
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
switch (pname)
{
case GL_MODELVIEW_MATRIX:
- cogl_gles2_float_array_to_fixed (16, w->modelview_stack
- + w->modelview_stack_pos * 16,
- params);
+ memcpy (params, w->modelview_stack + w->modelview_stack_pos * 16,
+ sizeof (GLfloat) * 16);
break;
case GL_PROJECTION_MATRIX:
- cogl_gles2_float_array_to_fixed (16, w->projection_stack
- + w->projection_stack_pos * 16,
- params);
+ memcpy (params, w->projection_stack + w->projection_stack_pos * 16,
+ sizeof (GLfloat) * 16);
break;
case GL_VIEWPORT:
- {
- GLfloat v[4];
-
- glGetFloatv (GL_VIEWPORT, v);
- cogl_gles2_float_array_to_fixed (4, v, params);
- }
+ glGetFloatv (GL_VIEWPORT, params);
break;
}
}

76
fixed-to-float-patches/gles-cogl-gles2-wrapper.h.0.patch Normal file
View File

@ -0,0 +1,76 @@
diff --git a/clutter/cogl/gles/cogl-gles2-wrapper.h b/clutter/cogl/gles/cogl-gles2-wrapper.h
index cb700cc..f126993 100644
--- a/clutter/cogl/gles/cogl-gles2-wrapper.h
+++ b/clutter/cogl/gles/cogl-gles2-wrapper.h
@@ -203,8 +203,6 @@ struct _CoglGles2WrapperShader
void cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper);
void cogl_gles2_wrapper_deinit (CoglGles2Wrapper *wrapper);
-void cogl_wrap_glClearColorx (GLclampx r, GLclampx g, GLclampx b, GLclampx a);
-
void cogl_wrap_glPushMatrix ();
void cogl_wrap_glPopMatrix ();
void cogl_wrap_glMatrixMode (GLenum mode);
@@ -239,12 +237,12 @@ void cogl_wrap_glDisableClientState (GLenum array);
void cogl_wrap_glAlphaFunc (GLenum func, GLclampf ref);
-void cogl_wrap_glColor4f (GLclampx r, GLclampx g, GLclampx b, GLclampx a);
+void cogl_wrap_glColor4f (GLclampf r, GLclampf g, GLclampf b, GLclampf a);
void cogl_wrap_glClipPlanef (GLenum plane, GLfloat *equation);
void cogl_wrap_glGetIntegerv (GLenum pname, GLint *params);
-void cogl_wrap_glGetFixedv (GLenum pname, GLfloat *params);
+void cogl_wrap_glGetFloatv (GLenum pname, GLfloat *params);
void cogl_wrap_glFogf (GLenum pname, GLfloat param);
void cogl_wrap_glFogfv (GLenum pname, const GLfloat *params);
@@ -273,35 +271,34 @@ void _cogl_gles2_clear_cache_for_program (CoglHandle program);
/* If we're not using GL ES 2 then just use the GL functions
directly */
-#define cogl_wrap_glClearColorx glClearColorx
#define cogl_wrap_glDrawArrays glDrawArrays
#define cogl_wrap_glDrawElements glDrawElements
#define cogl_wrap_glPushMatrix glPushMatrix
#define cogl_wrap_glPopMatrix glPopMatrix
#define cogl_wrap_glMatrixMode glMatrixMode
#define cogl_wrap_glLoadIdentity glLoadIdentity
-#define cogl_wrap_glMultMatrixf glMultMatrixx
-#define cogl_wrap_glFrustumf glFrustumx
-#define cogl_wrap_glScalef glScalex
-#define cogl_wrap_glTranslatef glTranslatex
-#define cogl_wrap_glRotatef glRotatex
-#define cogl_wrap_glOrthof glOrthox
+#define cogl_wrap_glMultMatrixf glMultMatrixf
+#define cogl_wrap_glFrustumf glFrustumf
+#define cogl_wrap_glScalef glScalef
+#define cogl_wrap_glTranslatef glTranslatef
+#define cogl_wrap_glRotatef glRotatef
+#define cogl_wrap_glOrthof glOrthof
#define cogl_wrap_glEnable glEnable
#define cogl_wrap_glDisable glDisable
#define cogl_wrap_glTexCoordPointer glTexCoordPointer
#define cogl_wrap_glVertexPointer glVertexPointer
#define cogl_wrap_glColorPointer glColorPointer
#define cogl_wrap_glNormalPointer glNormalPointer
-#define cogl_wrap_glTexEnvf glTexEnvx
+#define cogl_wrap_glTexEnvf glTexEnvf
#define cogl_wrap_glEnableClientState glEnableClientState
#define cogl_wrap_glDisableClientState glDisableClientState
#define cogl_wrap_glAlphaFunc glAlphaFunc
-#define cogl_wrap_glColor4f glColor4x
-#define cogl_wrap_glClipPlanef glClipPlanex
+#define cogl_wrap_glColor4f glColor4f
+#define cogl_wrap_glClipPlanef glClipPlanef
#define cogl_wrap_glGetIntegerv glGetIntegerv
-#define cogl_wrap_glGetFixedv glGetFixedv
-#define cogl_wrap_glFogf glFogx
-#define cogl_wrap_glFogfv glFogxv
+#define cogl_wrap_glGetFloatv glGetFloatv
+#define cogl_wrap_glFogf glFogf
+#define cogl_wrap_glFogfv glFogfv
#define cogl_wrap_glTexParameteri glTexParameteri
/* The extra third parameter of the bind texture wrapper isn't needed

12
fixed-to-float-patches/gles-cogl-primitives.c.0.patch Normal file
View File

@ -0,0 +1,12 @@
diff --git a/clutter/cogl/gles/cogl-primitives.c b/clutter/cogl/gles/cogl-primitives.c
index 901fa5d..d8fe121 100644
--- a/clutter/cogl/gles/cogl-primitives.c
+++ b/clutter/cogl/gles/cogl-primitives.c
@@ -34,6 +34,7 @@
#include <string.h>
#include <gmodule.h>
+#include <math.h>
#define _COGL_MAX_BEZ_RECURSE_DEPTH 16

30
fixed-to-float-patches/gles-cogl-texture.c.0.patch Normal file
View File

@ -0,0 +1,30 @@
diff --git a/clutter/cogl/gles/cogl-texture.c b/clutter/cogl/gles/cogl-texture.c
index ca48a33..e054d84 100644
--- a/clutter/cogl/gles/cogl-texture.c
+++ b/clutter/cogl/gles/cogl-texture.c
@@ -39,6 +39,7 @@
#include <string.h>
#include <stdlib.h>
+#include <math.h>
#define glVertexPointer cogl_wrap_glVertexPointer
#define glTexCoordPointer cogl_wrap_glTexCoordPointer
@@ -768,7 +769,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
guint wx, wy;
src = source_bmp->data
- + (src_y + (y_iter.intersect_start)
+ + (src_y + ((int)y_iter.intersect_start)
- dst_y)
* source_bmp->rowstride
+ (src_x + x_span->start + x_span->size - x_span->waste
@@ -813,7 +814,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
guint copy_width;
src = source_bmp->data
- + (src_x + (x_iter.intersect_start)
+ + (src_x + ((int)x_iter.intersect_start)
- dst_x)
* bpp
+ (src_y + y_span->start + y_span->size - y_span->waste

102
fixed-to-float-patches/gles-cogl.c.0.patch Normal file
View File

@ -0,0 +1,102 @@
diff --git a/clutter/cogl/gles/cogl.c b/clutter/cogl/gles/cogl.c
index 422d8b6..cb7aa8e 100644
--- a/clutter/cogl/gles/cogl.c
+++ b/clutter/cogl/gles/cogl.c
@@ -37,6 +37,7 @@
#include "cogl-context.h"
#include "cogl-gles2-wrapper.h"
+#include <math.h>
/* GL error to string conversion */
#if COGL_DEBUG
@@ -92,10 +93,10 @@ cogl_paint_init (const CoglColor *color)
fprintf(stderr, "\n ============== Paint Start ================ \n");
#endif
- cogl_wrap_glClearColorx (cogl_color_get_red (color),
- cogl_color_get_green (color),
- cogl_color_get_blue (color),
- 0);
+ glClearColor (cogl_color_get_red (color),
+ cogl_color_get_green (color),
+ cogl_color_get_blue (color),
+ 0);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
cogl_wrap_glDisable (GL_LIGHTING);
@@ -365,9 +366,8 @@ set_clip_plane (GLint plane_num,
/* Calculate the angle between the axes and the line crossing the
two points */
- angle = (atan2f (vertex_b[1] - vertex_a[1] *
- vertex_b[0] - vertex_a[0]),
- COGL_RADIANS_TO_DEGREES);
+ angle = atan2f (vertex_b[1] - vertex_a[1],
+ vertex_b[0] - vertex_a[0]) * (180.0/G_PI);
GE( cogl_wrap_glPushMatrix () );
/* Load the identity matrix and multiply by the reverse of the
@@ -405,8 +405,8 @@ _cogl_set_clip_planes (float x_offset,
float vertex_br[4] = { x_offset + width, y_offset + height,
0, 1.0 };
- GE( cogl_wrap_glGetFixedv (GL_MODELVIEW_MATRIX, modelview) );
- GE( cogl_wrap_glGetFixedv (GL_PROJECTION_MATRIX, projection) );
+ GE( cogl_wrap_glGetFloatv (GL_MODELVIEW_MATRIX, modelview) );
+ GE( cogl_wrap_glGetFloatv (GL_PROJECTION_MATRIX, projection) );
project_vertex (modelview, projection, vertex_tl);
project_vertex (modelview, projection, vertex_tr);
@@ -558,15 +558,13 @@ cogl_perspective (float fovy,
* 2) When working with small numbers, we can are loosing significant
* precision
*/
- ymax = (zNear *
- (sinf (fovy_rad_half) /
- cosf (fovy_rad_half)));
+ ymax = (zNear * (sinf (fovy_rad_half) / cosf (fovy_rad_half)));
xmax = (ymax * aspect);
x = (zNear / xmax);
y = (zNear / ymax);
c = (-(zFar + zNear) / ( zFar - zNear));
- d = (-((2 * zFar * zNear)) / (zFar - zNear));
+ d = (-(2 * zFar) * zNear) / (zFar - zNear);
#define M(row,col) m[col*4+row]
M(0,0) = x;
@@ -671,13 +669,13 @@ cogl_setup_viewport (guint w,
if (fovy != 60.0)
{
float fovy_rad = (fovy * G_PI) / 180;
-
- z_camera = (sinf (fovy_rad) /
- cosf (fovy_rad)) >> 1;
+
+ z_camera = (sinf (fovy_rad) / cosf (fovy_rad)) / 2;
}
- GE( cogl_wrap_glTranslatef (-1 << 15, -1 << 15, -z_camera) );
+
+ GE( cogl_wrap_glTranslatef (-0.5f, -0.5f, -z_camera) );
GE( cogl_wrap_glScalef ( 1.0 / width,
-1.0 / height,
@@ -737,13 +735,13 @@ cogl_features_available (CoglFeatureFlags features)
void
cogl_get_modelview_matrix (float m[16])
{
- cogl_wrap_glGetFixedv(GL_MODELVIEW_MATRIX, &m[0]);
+ cogl_wrap_glGetFloatv (GL_MODELVIEW_MATRIX, m);
}
void
cogl_get_projection_matrix (float m[16])
{
- cogl_wrap_glGetFixedv(GL_PROJECTION_MATRIX, &m[0]);
+ cogl_wrap_glGetFloatv (GL_PROJECTION_MATRIX, m);
}
void

735
fixed-to-float-patches/remove_cogl_apis_taking_fixed_params.0.patch Normal file
View File

@ -0,0 +1,735 @@
diff --git a/clutter/clutter-actor.c b/clutter/clutter-actor.c
index 9cbee04..e0903fe 100644
--- a/clutter/clutter-actor.c
+++ b/clutter/clutter-actor.c
@@ -1348,8 +1348,8 @@ _clutter_actor_apply_modelview_transform (ClutterActor *self)
gboolean is_stage = CLUTTER_IS_STAGE (self);
if (!is_stage)
- cogl_translatex (CLUTTER_UNITS_TO_FIXED (priv->allocation.x1),
- CLUTTER_UNITS_TO_FIXED (priv->allocation.y1),
+ cogl_translate (CLUTTER_UNITS_TO_FLOAT (priv->allocation.x1),
+ CLUTTER_UNITS_TO_FLOAT (priv->allocation.y1),
0);
/*
@@ -1363,50 +1363,50 @@ _clutter_actor_apply_modelview_transform (ClutterActor *self)
if (priv->rzang)
{
- cogl_translatex (CLUTTER_UNITS_TO_FIXED (priv->rzx),
- CLUTTER_UNITS_TO_FIXED (priv->rzy),
+ cogl_translate (CLUTTER_UNITS_TO_FLOAT (priv->rzx),
+ CLUTTER_UNITS_TO_FLOAT (priv->rzy),
0);
- cogl_rotatex (priv->rzang, 0, 0, 1.0);
+ cogl_rotate (priv->rzang, 0, 0, 1.0);
- cogl_translatex (CLUTTER_UNITS_TO_FIXED (-priv->rzx),
- CLUTTER_UNITS_TO_FIXED (-priv->rzy),
+ cogl_translate (CLUTTER_UNITS_TO_FLOAT (-priv->rzx),
+ CLUTTER_UNITS_TO_FLOAT (-priv->rzy),
0);
}
if (priv->ryang)
{
- cogl_translatex (CLUTTER_UNITS_TO_FIXED (priv->ryx),
+ cogl_translate (CLUTTER_UNITS_TO_FLOAT (priv->ryx),
0,
- CLUTTER_UNITS_TO_FIXED (priv->z + priv->ryz));
+ CLUTTER_UNITS_TO_FLOAT (priv->z + priv->ryz));
- cogl_rotatex (priv->ryang, 0, 1.0, 0);
+ cogl_rotate (priv->ryang, 0, 1.0, 0);
- cogl_translatex (CLUTTER_UNITS_TO_FIXED (-priv->ryx),
+ cogl_translate (CLUTTER_UNITS_TO_FLOAT (-priv->ryx),
0,
- CLUTTER_UNITS_TO_FIXED (-(priv->z + priv->ryz)));
+ CLUTTER_UNITS_TO_FLOAT (-(priv->z + priv->ryz)));
}
if (priv->rxang)
{
- cogl_translatex (0,
- CLUTTER_UNITS_TO_FIXED (priv->rxy),
- CLUTTER_UNITS_TO_FIXED (priv->z + priv->rxz));
+ cogl_translate (0,
+ CLUTTER_UNITS_TO_FLOAT (priv->rxy),
+ CLUTTER_UNITS_TO_FLOAT (priv->z + priv->rxz));
- cogl_rotatex (priv->rxang, 1.0, 0, 0);
+ cogl_rotate (priv->rxang, 1.0, 0, 0);
- cogl_translatex (0,
- CLUTTER_UNITS_TO_FIXED (-priv->rxy),
- CLUTTER_UNITS_TO_FIXED (-(priv->z + priv->rxz)));
+ cogl_translate (0,
+ CLUTTER_UNITS_TO_FLOAT (-priv->rxy),
+ CLUTTER_UNITS_TO_FLOAT (-(priv->z + priv->rxz)));
}
if (!is_stage && (priv->anchor_x || priv->anchor_y))
- cogl_translatex (CLUTTER_UNITS_TO_FIXED (-priv->anchor_x),
- CLUTTER_UNITS_TO_FIXED (-priv->anchor_y),
+ cogl_translate (CLUTTER_UNITS_TO_FLOAT (-priv->anchor_x),
+ CLUTTER_UNITS_TO_FLOAT (-priv->anchor_y),
0);
if (priv->z)
- cogl_translatex (0, 0, priv->z);
+ cogl_translate (0, 0, priv->z);
}
/* Recursively applies the transforms associated with this actor and
diff --git a/clutter/cogl/cogl-color.h b/clutter/cogl/cogl-color.h
index 6cdf52b..05650d3 100644
--- a/clutter/cogl/cogl-color.h
+++ b/clutter/cogl/cogl-color.h
@@ -68,7 +68,7 @@ void cogl_color_set_from_4d (CoglColor *dest,
gdouble alpha);
/**
- * cogl_color_set_from_4x:
+ * cogl_color_set_from_4f:
* @dest: return location for a #CoglColor
* @red: value of the red channel, between 0 and %1.0
* @green: value of the green channel, between 0 and %1.0
@@ -79,7 +79,7 @@ void cogl_color_set_from_4d (CoglColor *dest,
*
* Since: 1.0
*/
-void cogl_color_set_from_4x (CoglColor *dest,
+void cogl_color_set_from_4f (CoglColor *dest,
float red,
float green,
float blue,
@@ -248,7 +248,7 @@ float cogl_color_get_alpha (const CoglColor *color);
* Sets the source color using normalized values for each component.
* This color will be used for any subsequent drawing operation.
*
- * See also cogl_set_source_color4ub() and cogl_set_source_color4x()
+ * See also cogl_set_source_color4ub() and cogl_set_source_color4f()
* if you already have the color components.
*
* Since: 1.0
@@ -276,7 +276,7 @@ void cogl_set_source_color4ub (guint8 red,
guint8 alpha);
/**
- * cogl_set_source_color4x:
+ * cogl_set_source_color4f:
* @red: value of the red channel, between 0 and %1.0
* @green: value of the green channel, between 0 and %1.0
* @blue: value of the blue channel, between 0 and %1.0
@@ -291,7 +291,7 @@ void cogl_set_source_color4ub (guint8 red,
*
* Since: 1.0
*/
-void cogl_set_source_color4x (float red,
+void cogl_set_source_color4f (float red,
float green,
float blue,
float alpha);
diff --git a/clutter/cogl/cogl-path.h b/clutter/cogl/cogl-path.h
index 0d29829..aa37864 100644
--- a/clutter/cogl/cogl-path.h
+++ b/clutter/cogl/cogl-path.h
@@ -60,24 +60,10 @@ G_BEGIN_DECLS
* Fills a rectangle at the given coordinates with the current
* drawing color in a highly optimizied fashion.
**/
-void cogl_rectangle (gint x,
- gint y,
- guint width,
- guint height);
-
-/**
- * cogl_rectanglex:
- * @x: X coordinate of the top-left corner
- * @y: Y coordinate of the top-left corner
- * @width: Width of the rectangle
- * @height: Height of the rectangle
- *
- * A fixed-point version of cogl_fast_fill_rectangle.
- **/
-void cogl_rectanglex (float x,
- float y,
- float width,
- float height);
+void cogl_rectangle (float x,
+ float y,
+ float width,
+ float height);
/**
* cogl_path_fill:
diff --git a/clutter/cogl/cogl.h.in b/clutter/cogl/cogl.h.in
index f37d54d..f8d5745 100644
--- a/clutter/cogl/cogl.h.in
+++ b/clutter/cogl/cogl.h.in
@@ -231,7 +231,7 @@ void cogl_scale (float x,
float y);
/**
- * cogl_translatex:
+ * cogl_translate:
* @x: Distance to translate along the x-axis
* @y: Distance to translate along the y-axis
* @z: Distance to translate along the z-axis
@@ -239,26 +239,12 @@ void cogl_scale (float 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 (float x,
- float y,
- float z);
-
-/**
- * cogl_translate:
- * @x: Distance to translate along the x-axis
- * @y: Distance to translate along the y-axis
- * @z: Distance to translate along the z-axis
- *
- * Integer version of cogl_translatex(). Multiplies the current
- * model-view matrix by one that translates the model along all three
- * axes according to the given values.
- */
-void cogl_translate (gint x,
- gint y,
- gint z);
+void cogl_translate (float x,
+ float y,
+ float z);
/**
- * cogl_rotatex:
+ * cogl_rotate:
* @angle: Angle in degrees to rotate.
* @x: X-component of vertex to rotate around.
* @y: Y-component of vertex to rotate around.
@@ -270,26 +256,10 @@ void cogl_translate (gint x,
* degrees about the vertex (0, 0, 1) causes a small counter-clockwise
* rotation.
*/
-void cogl_rotatex (float angle,
- float x,
- float y,
- float z);
-
-/**
- * cogl_rotate:
- * @angle: Angle in degrees to rotate.
- * @x: X-component of vertex to rotate around.
- * @y: Y-component of vertex to rotate around.
- * @z: Z-component of vertex to rotate around.
- *
- * Integer version of cogl_rotatex(). Multiplies the current
- * model-view matrix by one that rotates the model around the vertex
- * specified by @x, @y and @z.
- */
-void cogl_rotate (gint angle,
- gint x,
- gint y,
- gint z);
+void cogl_rotate (float angle,
+ float x,
+ float y,
+ float z);
/**
* cogl_get_modelview_matrix:
diff --git a/clutter/cogl/common/cogl-color.c b/clutter/cogl/common/cogl-color.c
index dac3584..e4b74c6 100644
--- a/clutter/cogl/common/cogl-color.c
+++ b/clutter/cogl/common/cogl-color.c
@@ -58,7 +58,7 @@ cogl_color_set_from_4d (CoglColor *dest,
}
void
-cogl_color_set_from_4x (CoglColor *dest,
+cogl_color_set_from_4f (CoglColor *dest,
float red,
float green,
float blue,
@@ -157,13 +157,13 @@ cogl_set_source_color4ub (guint8 red,
}
void
-cogl_set_source_color4x (float red,
+cogl_set_source_color4f (float red,
float green,
float blue,
float alpha)
{
CoglColor c = { 0, };
- cogl_color_set_from_4x (&c, red, green, blue, alpha);
+ cogl_color_set_from_4f (&c, red, green, blue, alpha);
cogl_set_source_color (&c);
}
diff --git a/clutter/cogl/common/cogl-primitives.c b/clutter/cogl/common/cogl-primitives.c
index 27834f7..7e9b1b9 100644
--- a/clutter/cogl/common/cogl-primitives.c
+++ b/clutter/cogl/common/cogl-primitives.c
@@ -43,19 +43,15 @@ void _cogl_path_add_node (gboolean new_sub_path,
float 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 (float x,
- float y,
- float width,
- float height);
+void _cogl_rectangle (float x,
+ float y,
+ float width,
+ float height);
void
-cogl_rectangle (gint x,
- gint y,
- guint width,
- guint height)
+cogl_rectangle (float x,
+ float y,
+ float width,
+ float height)
{
cogl_clip_ensure ();
@@ -63,18 +59,6 @@ cogl_rectangle (gint x,
}
void
-cogl_rectanglex (float x,
- float y,
- float width,
- float height)
-{
- cogl_clip_ensure ();
-
- _cogl_rectanglex (x, y, width, height);
-}
-
-
-void
cogl_path_fill (void)
{
cogl_path_fill_preserve ();
diff --git a/clutter/cogl/gl/cogl-primitives.c b/clutter/cogl/gl/cogl-primitives.c
index 8a0843d..e445657 100644
--- a/clutter/cogl/gl/cogl-primitives.c
+++ b/clutter/cogl/gl/cogl-primitives.c
@@ -39,35 +39,17 @@
#define _COGL_MAX_BEZ_RECURSE_DEPTH 16
void
-_cogl_rectangle (gint x,
- gint y,
- guint width,
- guint height)
+_cogl_rectangle (float x,
+ float y,
+ float width,
+ float height)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
cogl_enable (ctx->color_alpha < 255
? COGL_ENABLE_BLEND : 0);
- GE( glRecti (x, y, x + width, y + height) );
-}
-
-
-void
-_cogl_rectanglex (float x,
- float y,
- float width,
- float height)
-{
- _COGL_GET_CONTEXT (ctx, NO_RETVAL);
-
- cogl_enable (ctx->color_alpha < 255
- ? COGL_ENABLE_BLEND : 0);
-
- GE( glRectf ( (x),
- (y),
- (x + width),
- (y + height)) );
+ GE( glRectf (x, y, x + width, y + height) );
}
void
@@ -132,17 +114,15 @@ _cogl_path_stroke_nodes ()
static void
_cogl_path_get_bounds (floatVec2 nodes_min,
floatVec2 nodes_max,
- gint *bounds_x,
- gint *bounds_y,
- guint *bounds_w,
- guint *bounds_h)
+ float *bounds_x,
+ float *bounds_y,
+ float *bounds_w,
+ float *bounds_h)
{
- *bounds_x = floorf (nodes_min.x);
- *bounds_y = floorf (nodes_min.y);
- *bounds_w = ceilf (nodes_max.x
- - (float)(*bounds_x));
- *bounds_h = ceilf (nodes_max.y
- - (float)(*bounds_y));
+ *bounds_x = nodes_min.x;
+ *bounds_y = nodes_min.y;
+ *bounds_w = nodes_max.x - *bounds_x;
+ *bounds_h = nodes_max.y - *bounds_y;
}
void
@@ -154,10 +134,10 @@ _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
{
guint path_start = 0;
guint sub_path_num = 0;
- gint bounds_x;
- gint bounds_y;
- guint bounds_w;
- guint bounds_h;
+ float bounds_x;
+ float bounds_y;
+ float bounds_w;
+ float bounds_h;
_cogl_path_get_bounds (nodes_min, nodes_max,
&bounds_x, &bounds_y, &bounds_w, &bounds_h);
@@ -239,10 +219,10 @@ _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
void
_cogl_path_fill_nodes ()
{
- gint bounds_x;
- gint bounds_y;
- guint bounds_w;
- guint bounds_h;
+ float bounds_x;
+ float bounds_y;
+ float bounds_w;
+ float bounds_h;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
diff --git a/clutter/cogl/gl/cogl.c b/clutter/cogl/gl/cogl.c
index d815e3b..aa0ec78 100644
--- a/clutter/cogl/gl/cogl.c
+++ b/clutter/cogl/gl/cogl.c
@@ -217,32 +217,15 @@ cogl_scale (float x, float y)
}
void
-cogl_translatex (float x, float y, float z)
+cogl_translate (float x, float y, float z)
{
- glTranslatef ((float)(x),
- (float)(y),
- (float)(z));
+ glTranslatef (x, y, z);
}
void
-cogl_translate (gint x, gint y, gint z)
+cogl_rotate (float angle, float x, float y, float z)
{
- glTranslatef ((float)x, (float)y, (float)z);
-}
-
-void
-cogl_rotatex (float angle, float x, float y, float z)
-{
- glRotatef ((float)(angle),
- (float)(x),
- (float)(y),
- (float)(z));
-}
-
-void
-cogl_rotate (gint angle, gint x, gint y, gint z)
-{
- glRotatef ((float)angle, (float)x, (float)y, (float)z);
+ glRotatef (angle, x, y, z);
}
static inline gboolean
diff --git a/clutter/cogl/gles/cogl-primitives.c b/clutter/cogl/gles/cogl-primitives.c
index d8fe121..1a58805 100644
--- a/clutter/cogl/gles/cogl-primitives.c
+++ b/clutter/cogl/gles/cogl-primitives.c
@@ -39,55 +39,26 @@
#define _COGL_MAX_BEZ_RECURSE_DEPTH 16
void
-_cogl_rectangle (gint x,
- gint y,
- guint width,
- guint height)
+_cogl_rectangle (float x,
+ float y,
+ float width,
+ float height)
{
- /* 32-bit integers are not supported as coord types
- in GLES . Fixed type has got 16 bits left of the
- point which is equal to short anyway. */
-
- GLshort rect_verts[8] = {
- (GLshort) x, (GLshort) y,
- (GLshort) (x + width), (GLshort) y,
- (GLshort) x, (GLshort) (y + height),
- (GLshort) (x + width), (GLshort) (y + height)
+ GLfloat rect_verts[8] = {
+ (GLfloat) x, (GLfloat) y,
+ (GLfloat) (x + width), (GLfloat) y,
+ (GLfloat) x, (GLfloat) (y + height),
+ (GLfloat) (x + width), (GLfloat) (y + height)
};
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
cogl_enable (COGL_ENABLE_VERTEX_ARRAY
| (ctx->color_alpha < 255 ? COGL_ENABLE_BLEND : 0));
- GE ( cogl_wrap_glVertexPointer (2, GL_SHORT, 0, rect_verts ) );
+ GE ( cogl_wrap_glVertexPointer (2, GL_FLOAT, 0, rect_verts ) );
GE ( cogl_wrap_glDrawArrays (GL_TRIANGLE_STRIP, 0, 4) );
}
-
-void
-_cogl_rectanglex (float x,
- float y,
- float width,
- float height)
-{
- GLfloat rect_verts[8] = {
- x, y,
- x + width, y,
- x, y + height,
- x + width, y + height
- };
-
- _COGL_GET_CONTEXT (ctx, NO_RETVAL);
-
- cogl_enable (COGL_ENABLE_VERTEX_ARRAY
- | (ctx->color_alpha < 255
- ? COGL_ENABLE_BLEND : 0));
-
- GE( cogl_wrap_glVertexPointer (2, GL_FIXED, 0, rect_verts) );
- GE( cogl_wrap_glDrawArrays (GL_TRIANGLE_STRIP, 0, 4) );
-
-}
-
void
_cogl_path_add_node (gboolean new_sub_path,
float x,
@@ -150,17 +121,15 @@ _cogl_path_stroke_nodes ()
static void
_cogl_path_get_bounds (floatVec2 nodes_min,
floatVec2 nodes_max,
- gint *bounds_x,
- gint *bounds_y,
- guint *bounds_w,
- guint *bounds_h)
+ float *bounds_x,
+ float *bounds_y,
+ float *bounds_w,
+ float *bounds_h)
{
- *bounds_x = floorf (nodes_min.x);
- *bounds_y = floorf (nodes_min.y);
- *bounds_w = ceilf (nodes_max.x
- - (float)(*bounds_x));
- *bounds_h = ceilf (nodes_max.y
- - (float)(*bounds_y));
+ *bounds_x = nodes_min.x;
+ *bounds_y = nodes_min.y;
+ *bounds_w = nodes_max.x - *bounds_x;
+ *bounds_h = nodes_max.y - *bounds_y;
}
static gint compare_ints (gconstpointer a,
@@ -178,10 +147,10 @@ _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
{
guint path_start = 0;
guint sub_path_num = 0;
- gint bounds_x;
- gint bounds_y;
- guint bounds_w;
- guint bounds_h;
+ float bounds_x;
+ float bounds_y;
+ float bounds_w;
+ float bounds_h;
_cogl_path_get_bounds (nodes_min, nodes_max,
&bounds_x, &bounds_y, &bounds_w, &bounds_h);
@@ -245,12 +214,8 @@ _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () );
- cogl_rectanglex (-1.0, -1.0,
- (float)(2),
- (float)(2));
- cogl_rectanglex (-1.0, -1.0,
- (float)(2),
- (float)(2));
+ cogl_rectangle (-1.0, -1.0, 2, 2);
+ cogl_rectangle (-1.0, -1.0, 2, 2);
GE( cogl_wrap_glPopMatrix () );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPopMatrix () );
@@ -436,10 +401,10 @@ _cogl_path_fill_nodes_scanlines (CoglPathNode *path,
void
_cogl_path_fill_nodes ()
{
- gint bounds_x;
- gint bounds_y;
- guint bounds_w;
- guint bounds_h;
+ float bounds_x;
+ float bounds_y;
+ float bounds_w;
+ float bounds_h;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
diff --git a/clutter/cogl/gles/cogl.c b/clutter/cogl/gles/cogl.c
index f8c5413..997f24a 100644
--- a/clutter/cogl/gles/cogl.c
+++ b/clutter/cogl/gles/cogl.c
@@ -123,35 +123,15 @@ cogl_scale (float x, float y)
}
void
-cogl_translatex (float x, float y, float z)
+cogl_translate (float x, float y, float z)
{
GE( cogl_wrap_glTranslatef (x, y, z) );
}
void
-cogl_translate (gint x, gint y, gint z)
+cogl_rotate (float angle, float x, float y, float z)
{
- GE( cogl_wrap_glTranslatef ((float)(x),
- (float)(y),
- (float)(z)) );
-}
-
-void
-cogl_rotatex (float angle,
- float x,
- float y,
- float z)
-{
- GE( cogl_wrap_glRotatef (angle,x,y,z) );
-}
-
-void
-cogl_rotate (gint angle, gint x, gint y, gint z)
-{
- GE( cogl_wrap_glRotatef ((float)(angle),
- (float)(x),
- (float)(y),
- (float)(z)) );
+ GE( cogl_wrap_glRotatef (angle, x, y, z) );
}
static inline gboolean
@@ -457,7 +437,7 @@ _cogl_add_stencil_clip (float x_offset,
GE( glStencilFunc (GL_NEVER, 0x1, 0x1) );
GE( glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE) );
- cogl_rectanglex (x_offset, y_offset, width, height);
+ cogl_rectangle (x_offset, y_offset, width, height);
}
else
{
@@ -465,7 +445,7 @@ _cogl_add_stencil_clip (float x_offset,
rectangle */
GE( glStencilFunc (GL_NEVER, 0x1, 0x3) );
GE( glStencilOp (GL_INCR, GL_INCR, GL_INCR) );
- cogl_rectanglex (x_offset, y_offset, width, height);
+ cogl_rectangle (x_offset, y_offset, width, height);
/* Subtract one from all pixels in the stencil buffer so that
only pixels where both the original stencil buffer and the
@@ -476,9 +456,7 @@ _cogl_add_stencil_clip (float x_offset,
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () );
- cogl_rectanglex (-1.0, -1.0,
- (float)(2),
- (float)(2));
+ cogl_rectangle (-1.0, -1.0, 2, 2);
GE( cogl_wrap_glPopMatrix () );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPopMatrix () );
diff --git a/clutter/pango/cogl-pango-render.c b/clutter/pango/cogl-pango-render.c
index 3e23309..3cafc81 100644
--- a/clutter/pango/cogl-pango-render.c
+++ b/clutter/pango/cogl-pango-render.c
@@ -461,7 +461,7 @@ cogl_pango_renderer_draw_rectangle (PangoRenderer *renderer,
x + width, y + height,
&x2, &y2);
- cogl_rectanglex (x1, y1, x2 - x1, y2 - y1);
+ cogl_rectangle (x1, y1, x2 - x1, y2 - y1);
}
static void
diff --git a/doc/reference/cogl/cogl-sections.txt b/doc/reference/cogl/cogl-sections.txt
index dcd7c93..db4e16a 100644
--- a/doc/reference/cogl/cogl-sections.txt
+++ b/doc/reference/cogl/cogl-sections.txt
@@ -89,7 +89,7 @@ cogl_path_stroke
cogl_path_stroke_preserve
cogl_set_source_color
cogl_set_source_color4ub
-cogl_set_source_color4x
+cogl_set_source_color4f
<SUBSECTION>
cogl_rectangle
@@ -257,7 +257,7 @@ cogl_color_copy
cogl_color_free
cogl_color_set_from_4ub
cogl_color_set_from_4d
-cogl_color_set_from_4x
+cogl_color_set_from_4f
<SUBSECTION>
cogl_color_get_red
diff --git a/tests/conform/test-backface-culling.c b/tests/conform/test-backface-culling.c
index 50c19fd..6303949 100644
--- a/tests/conform/test-backface-culling.c
+++ b/tests/conform/test-backface-culling.c
@@ -121,7 +121,7 @@ on_paint (ClutterActor *actor, TestState *state)
/* Set the color to white so that all the textures will be drawn
at their own color */
- cogl_set_source_color4x (1.0, 1.0,
+ cogl_set_source_color4f (1.0, 1.0,
1.0, 1.0);
x2 = x1 + (float)(TEXTURE_SIZE);
@@ -173,7 +173,7 @@ on_paint (ClutterActor *actor, TestState *state)
x2 = x1 + (float)(TEXTURE_SIZE);
/* Draw a regular rectangle (this should always show) */
- cogl_set_source_color4x (1.0, 0, 0, 1.0);
+ cogl_set_source_color4f (1.0, 0, 0, 1.0);
cogl_rectangle ( (x1), (y1),
(x2 - x1), (y2 - y1));

24
fixed-to-float-patches/test-cogl-tex-tile.c.0.patch Normal file
View File

@ -0,0 +1,24 @@
diff --git a/tests/interactive/test-cogl-tex-tile.c b/tests/interactive/test-cogl-tex-tile.c
index 5063dff..177d60e 100644
--- a/tests/interactive/test-cogl-tex-tile.c
+++ b/tests/interactive/test-cogl-tex-tile.c
@@ -90,14 +90,14 @@ test_coglbox_paint(ClutterActor *self)
ClutterFixed sin_frame, cos_frame;
ClutterFixed frac_frame;
gint t;
- sin_frame = clutter_sini (CLUTTER_ANGLE_FROM_DEG (priv->frame));
- cos_frame = clutter_cosi (CLUTTER_ANGLE_FROM_DEG (priv->frame));
+ sin_frame = clutter_sinx (priv->frame);
+ cos_frame = clutter_cosx (priv->frame);
pingpong_frame = (priv->frame <= 180 ? priv->frame : 360 - priv->frame);
frac_frame = (CLUTTER_INT_TO_FIXED (pingpong_frame) /
- CLUTTER_INT_TO_FIXED (180));
- frac_frame += (1.0 >> 1);
- frac_frame <<= 1;
+ CLUTTER_INT_TO_FIXED (180));
+ frac_frame += 0.5;
+ frac_frame *= 2;
for (t=0; t<4; t+=2)
{

239
fixed-to-float.sh Executable file
View File

@ -0,0 +1,239 @@
#!/bin/sh
# The ClutterFixed type and macros now use floats, but we are keeping the
# CoglFixed type + macros using fixed point so now we convert all uses of
# the Cogl fixed point macros within Clutter proper to use the ClutterFixed
# macros instead.
find ./clutter ./tests -maxdepth 1 -iname '*.c' -exec sed -i \
-e 's/COGL_FIXED_MUL/CLUTTER_FIXED_MUL/g' \
-e 's/COGL_FIXED_DIV/CLUTTER_FIXED_DIV/g' \
-e 's/COGL_FIXED_FAST_MUL/CLUTTER_FIXED_MUL/g' \
-e 's/COGL_FIXED_FAST_DIV/CLUTTER_FIXED_DIV/g' \
-e 's/COGL_FIXED_FROM_FLOAT/CLUTTER_FLOAT_TO_FIXED/g' \
-e 's/COGL_FIXED_TO_FLOAT/CLUTTER_FIXED_TO_FLOAT/g' \
-e 's/COGL_FIXED_TO_DOUBLE/CLUTTER_FIXED_TO_DOUBLE/g' \
-e 's/COGL_FIXED_PI/CFX_PI/g' \
{} \;
# All remaining uses of the Cogl fixed point API now get expanded out to simply
# use float calculations... (we will restore the cogl-fixed code itself later)
# XXX: The following three assume that no nested function - with
# multiple arguments - is ever found as the RHS argument to
# COGL_FIXED_MUL. This is because we simply replace the last ',' with
# the * operator. If you want to double check that's still true:
# $ grep -r --include=*.c COGL_FIXED_MUL *|less
#
# XXX: (Note in the third regexp there were examples of COGL_FIXED_MUL
# being used as the RHS argument, but since we have already replaced
# instances of COGL_FIXED_MUL, that works out ok.
find ./clutter ./tests -iname '*.[ch]' -exec sed -i -r \
-e 's/COGL_FIXED_MUL (.*),/\1 */g' \
-e 's|COGL_FIXED_FAST_DIV (.*),|\1 /|g' \
-e 's|COGL_FIXED_DIV (.*),|\1 /|g' \
{} \;
# A fix due to the assumptions used above
sed -i 's/#define DET2X(a,b,c,d).*/#define DET2X(a,b,c,d) ((a * d) - (b * c))/g' ./clutter/clutter-actor.c
find ./clutter/cogl/gles -iname '*.[ch]' -exec sed -i 's/GLfixed/GLfloat/g' {} \;
#we get some redundant brackets like this, but C's automatic type promotion
#works out fine for most cases...
find ./clutter ./tests -iname '*.[ch]' -exec sed -r -i \
-e 's/COGL_FIXED_TO_INT//g' \
-e 's/COGL_FIXED_FROM_INT /(float)/g' \
-e 's/COGL_FIXED_FROM_INT/(float)/g' \
-e 's/COGL_FIXED_TO_FLOAT//g' \
-e 's/COGL_FIXED_FROM_FLOAT//g' \
-e 's/COGL_FIXED_TO_DOUBLE /(double)/g' \
\
-e 's/COGL_FIXED_FLOOR/floorf/g' \
-e 's/COGL_FIXED_CEIL/ceilf/g' \
-e 's/COGL_FIXED_360/360.0/g' \
-e 's/COGL_FIXED_240/240.0/g' \
-e 's/COGL_FIXED_255/255.0/g' \
-e 's/COGL_FIXED_180/180.0/g' \
-e 's/COGL_FIXED_120/120.0/g' \
-e 's/COGL_FIXED_60/60.0/g' \
-e 's/COGL_FIXED_1/1.0/g' \
-e 's/COGL_FIXED_0_5/0.5/g' \
-e 's/COGL_FIXED_PI/G_PI/g' \
\
-e 's/COGL_ANGLE_FROM_DEG \((.*)\),/\1,/g' \
{} \; \
\
-exec perl -p -i \
-e "s|cogl_angle_cos \((.*?)\)|cosf (\1 * (G_PI/180.0))|;" \
-e "s|cogl_angle_sin \((.*?)\)|sinf (\1 * (G_PI/180.0))|;" \
-e "s|cogl_angle_tan \((.*?)\)|tanf (\1 * (G_PI/180.0))|;" \
{} \;
#XXX: NB: cogl_fixed_div must be done before mul since there is a case were they
#are nested which would otherwise break the assumption used here that the last
#coma of the line can simply be replaced with the corresponding operator
find ./clutter ./tests -iname '*.[ch]' -exec sed -i -r \
-e 's|cogl_fixed_div (.*),|\1 /|g' \
-e 's|cogl_fixed_mul (.*),|\1 *|g' \
-e 's/cogl_fixed_pow2/pow2f/g' \
-e 's/cogl_fixed_pow/powf/g' \
-e 's/cogl_fixed_log2/log2f/g' \
-e 's/cogl_fixed_sqrt/sqrtf/g' \
-e 's/cogl_fixed_cos/cosf/g' \
-e 's/cogl_fixed_sin/sinf/g' \
-e 's/cogl_fixed_atan2/atan2f/g' \
-e 's/cogl_fixed_atan/atanf/g' \
-e 's/cogl_fixed_tan/tanf/g' \
{} \;
#TODO: fixup gles/cogl.c set_clip_plane
cat clutter/cogl/common/cogl-primitives.c| \
grep -v '#define CFX_MUL2'| \
grep -v '#undef CFX_MUL2'| \
grep -v '#define CFX_MUL3'| \
grep -v '#undef CFX_MUL3'| \
grep -v '#define CFX_SQ'| \
grep -v '#undef CFX_SQ'| \
sed -r 's/CFX_MUL2 \((.{7})\)/(\1 * 2)/g' | \
sed -r 's/CFX_MUL3 \((.{7})\)/(\1 * 3)/g' | \
sed -r 's/CFX_SQ \((.{7})\)/(\1 * \1)/g' \
>./tmp
mv ./tmp clutter/cogl/common/cogl-primitives.c
#this has too many false positives...
#find ./clutter -iname '*.[ch]' -exec sed -i 's|>> 1|/ 2|g' {} \;
#find ./clutter -iname '*.[ch]' -exec sed -i 's|<< 1|* 2|g' {} \;
sed -i -e 's|>> 1|/ 2|g' -e 's|<< 1|* 2|g' \
./clutter/cogl/common/cogl-primitives.c
#find ./clutter -iname '*.[ch]' -exec sed -i 's|<< 1|* 2|g' {} \;
find ./clutter ./tests -iname '*.[ch]' \
-exec sed -i 's/CoglFixed/float/g' {} \;
#XXX: This might need changing later...
find ./clutter ./tests -iname '*.[ch]' \
-exec sed -i 's/CoglFixedVec2/CoglVec2/g' {} \;
sed -i 's/CoglFixed/float/g' ./clutter/cogl/cogl.h.in
# maintain the existing CoglFixed code as utility code for applications:
sed -i 's/float:/CoglFixed:/g' clutter/cogl/cogl-types.h
sed -i 's/gint32 float/gint32 CoglFixed/g' clutter/cogl/cogl-types.h
git-checkout clutter/cogl/cogl-fixed.h clutter/cogl/common/cogl-fixed.c
find ./clutter ./tests -iname '*.[ch]' -exec sed -i 's/CoglAngle/float/g' {} \;
# maintain the existing CoglAngle code as utility code for applications:
sed -i 's/float:/CoglAngle:/g' clutter/cogl/cogl-types.h
sed -i 's/gint32 float/gint32 CoglAngle/g' clutter/cogl/cogl-types.h
git-checkout clutter/cogl/cogl-fixed.h clutter/cogl/common/cogl-fixed.c
find ./clutter ./tests -iname '*.[ch]' ! -iname 'clutter-fixed.h' \
-exec sed -i 's/ClutterAngle/float/g' {} \;
# use the floating point names for GL ES functions instead of the
# fixed. These get #define'd to the float versions in one of the
# patches anyway but the names should be fixed up to avoid confusion
find ./clutter/cogl -iname '*.[ch]' -exec perl -p -i -e \
's/\b(cogl_wrap_(?:glMultMatrix|glFrustum|glScale|glTranslate
|glRotate|glOrtho|glTexEnv|glClipPlane|glFog|glColor4))x(v?)\b/$1f$2/gx' {} \;
echo "Cogl API to remove/replace with float versions:"
find ./clutter/ ./tests -iname '*.c' -exec grep '^cogl_[a-zA-Z_]*x ' {} \; | cut -d' ' -f1|grep -v 'box$'|grep -v 'matrix$'
echo "Clutter API to remove/replace with float versions:"
find ./clutter/ ./tests -iname '*.c' -exec grep '^clutter_[a-zA-Z_]*x ' {} \; | cut -d' ' -f1|grep -v 'box$'|grep -v 'matrix$'|grep -v '_x$'
#
# Now the last mile is dealt with manually with a bunch of patches...
#
cat > log_message <<EOF
[Automatic fixed-to-float.sh change] Applies all scripted changes
This is the result of running a number of sed and perl scripts over the code to
do 90% of the work in converting from 16.16 fixed to single precision floating
point.
Note: A pristine cogl-fixed.c has been maintained as a standalone utility API
so that applications may still take advantage of fixed point if they
desire for certain optimisations where lower precision may be acceptable.
Note: no API changes were made in Clutter, only in Cogl.
Overview of changes:
- Within clutter/* all usage of the COGL_FIXED_ macros have been changed to use
the CLUTTER_FIXED_ macros.
- Within cogl/* all usage of the COGL_FIXED_ macros have been completly stripped
and expanded into code that works with single precision floats instead.
- Uses of cogl_fixed_* have been replaced with single precision math.h
alternatives.
- Uses of COGL_ANGLE_* and cogl_angle_* have been replaced so we use a float for
angles and math.h replacements.
EOF
git-commit -a -F log_message --no-verify
patch -p1<fixed-to-float-patches/gl-cogl-texture.c.0.patch
patch -p1<fixed-to-float-patches/clutter-actor.c.0.patch
patch -p1<fixed-to-float-patches/clutter-alpha.c.0.patch
patch -p1<fixed-to-float-patches/clutter-alpha.h.0.patch
patch -p1<fixed-to-float-patches/clutter-behaviour-ellipse.c.0.patch
patch -p1<fixed-to-float-patches/clutter-bezier.c.0.patch
patch -p1<fixed-to-float-patches/clutter-path.c.0.patch
patch -p1<fixed-to-float-patches/cogl-fixed.h.0.patch
patch -p1<fixed-to-float-patches/cogl-fixed.c.0.patch
patch -p1<fixed-to-float-patches/test-cogl-tex-tile.c.0.patch
patch -p1<fixed-to-float-patches/clutter-texture.c.0.patch
patch -p1<fixed-to-float-patches/clutter-fixed.c.0.patch
patch -p1<fixed-to-float-patches/gl-cogl.c.0.patch
patch -p1<fixed-to-float-patches/cogl-pango-render.c.0.patch
patch -p1<fixed-to-float-patches/cogl-primitives.c.0.patch
patch -p1<fixed-to-float-patches/gl-cogl-primitives.c.0.patch
patch -p1<fixed-to-float-patches/gles-cogl.c.0.patch
patch -p1<fixed-to-float-patches/gles-cogl-gles2-wrapper.h.0.patch
patch -p1<fixed-to-float-patches/gles-cogl-gles2-wrapper.c.0.patch
patch -p1<fixed-to-float-patches/gles-cogl-primitives.c.0.patch
patch -p1<fixed-to-float-patches/gles-cogl-texture.c.0.patch
patch -p1<fixed-to-float-patches/cogl.h.in.0.patch
# Finally remove any cogl_blahx Cogl interfaces that used to take CoglFixed
# params. The corresponding interfaces that take integer params are also
# patched to take floats instead:
patch -p1<fixed-to-float-patches/remove_cogl_apis_taking_fixed_params.0.patch
#XXX: COGL_PANGO_UNIT_TO_FIXED
cat > log_message <<EOF
[Automatic fixed-to-float.sh change] Applies a number fixed to float patches
To deal with all the corner cases that couldn't be scripted a number of patches
were written for the remaining 10% of the effort.
Note: again no API changes were made in Clutter, only in Cogl.
EOF
git-commit -a -F log_message --no-verify
# The fixes in these files are entirely handcoded, so to avoid clashes with the
# automatic stuff above the patches below are based against the pristine
# versions, and we don't want to commit any of the automatic changes here.
git-checkout HEAD~2 clutter/clutter-fixed.h
git-checkout HEAD~2 clutter/clutter-units.h
patch -p1<fixed-to-float-patches/clutter-fixed.h.0.patch
patch -p1<fixed-to-float-patches/clutter-units.h.0.patch
cat > log_message <<EOF
[Automatic fixed-to-float.sh change] Hand coded changes for clutter-{fixed,units}
To avoid clashing with all the scripted changes, clutter-fixed.h and
clutter-units.h were manually converted to internally use floats instead of
16.16 fixed numbers.
Note: again no API changes were made in Clutter.
EOF
git-commit -a -F log_message --no-verify

38
tests/conform/test-backface-culling.c
View File

@ -114,33 +114,33 @@ on_paint (ClutterActor *actor, TestState *state)
the first */ the first */
for (i = 0; i < 2; i++) for (i = 0; i < 2; i++)
{ {
CoglFixed x1 = 0, x2, y1 = 0, y2 = COGL_FIXED_FROM_INT (TEXTURE_SIZE); float x1 = 0, x2, y1 = 0, y2 = (float)(TEXTURE_SIZE);
CoglTextureVertex verts[4]; CoglTextureVertex verts[4];
memset (verts, 0, sizeof (verts)); memset (verts, 0, sizeof (verts));
/* Set the color to white so that all the textures will be drawn /* Set the color to white so that all the textures will be drawn
at their own color */ at their own color */
cogl_set_source_color4x (COGL_FIXED_1, COGL_FIXED_1, cogl_set_source_color4f (1.0, 1.0,
COGL_FIXED_1, COGL_FIXED_1); 1.0, 1.0);
x2 = x1 + COGL_FIXED_FROM_INT (TEXTURE_SIZE); x2 = x1 + (float)(TEXTURE_SIZE);
/* Draw a front-facing texture */ /* Draw a front-facing texture */
cogl_texture_rectangle (state->texture, cogl_texture_rectangle (state->texture,
x1, y1, x2, y2, x1, y1, x2, y2,
0, 0, COGL_FIXED_1, COGL_FIXED_1); 0, 0, 1.0, 1.0);
x1 = x2; x1 = x2;
x2 = x1 + COGL_FIXED_FROM_INT (TEXTURE_SIZE); x2 = x1 + (float)(TEXTURE_SIZE);
/* Draw a back-facing texture */ /* Draw a back-facing texture */
cogl_texture_rectangle (state->texture, cogl_texture_rectangle (state->texture,
x2, y1, x1, y2, x2, y1, x1, y2,
0, 0, COGL_FIXED_1, COGL_FIXED_1); 0, 0, 1.0, 1.0);
x1 = x2; x1 = x2;
x2 = x1 + COGL_FIXED_FROM_INT (TEXTURE_SIZE); x2 = x1 + (float)(TEXTURE_SIZE);
/* Draw a front-facing texture polygon */ /* Draw a front-facing texture polygon */
verts[0].x = x1; verts[0].y = y2; verts[0].x = x1; verts[0].y = y2;
@ -148,14 +148,14 @@ on_paint (ClutterActor *actor, TestState *state)
verts[2].x = x2; verts[2].y = y1; verts[2].x = x2; verts[2].y = y1;
verts[3].x = x1; verts[3].y = y1; verts[3].x = x1; verts[3].y = y1;
verts[0].tx = 0; verts[0].ty = 0; verts[0].tx = 0; verts[0].ty = 0;
verts[1].tx = COGL_FIXED_1; verts[1].ty = 0; verts[1].tx = 1.0; verts[1].ty = 0;
verts[2].tx = COGL_FIXED_1; verts[2].ty = COGL_FIXED_1; verts[2].tx = 1.0; verts[2].ty = 1.0;
verts[3].tx = 0; verts[3].ty = COGL_FIXED_1; verts[3].tx = 0; verts[3].ty = 1.0;
cogl_texture_polygon (state->texture, 4, cogl_texture_polygon (state->texture, 4,
verts, FALSE); verts, FALSE);
x1 = x2; x1 = x2;
x2 = x1 + COGL_FIXED_FROM_INT (TEXTURE_SIZE); x2 = x1 + (float)(TEXTURE_SIZE);
/* Draw a back-facing texture polygon */ /* Draw a back-facing texture polygon */
verts[0].x = x1; verts[0].y = y1; verts[0].x = x1; verts[0].y = y1;
@ -163,19 +163,19 @@ on_paint (ClutterActor *actor, TestState *state)
verts[2].x = x2; verts[2].y = y2; verts[2].x = x2; verts[2].y = y2;
verts[3].x = x1; verts[3].y = y2; verts[3].x = x1; verts[3].y = y2;
verts[0].tx = 0; verts[0].ty = 0; verts[0].tx = 0; verts[0].ty = 0;
verts[1].tx = COGL_FIXED_1; verts[1].ty = 0; verts[1].tx = 1.0; verts[1].ty = 0;
verts[2].tx = COGL_FIXED_1; verts[2].ty = COGL_FIXED_1; verts[2].tx = 1.0; verts[2].ty = 1.0;
verts[3].tx = 0; verts[3].ty = COGL_FIXED_1; verts[3].tx = 0; verts[3].ty = 1.0;
cogl_texture_polygon (state->texture, 4, cogl_texture_polygon (state->texture, 4,
verts, FALSE); verts, FALSE);
x1 = x2; x1 = x2;
x2 = x1 + COGL_FIXED_FROM_INT (TEXTURE_SIZE); x2 = x1 + (float)(TEXTURE_SIZE);
/* Draw a regular rectangle (this should always show) */ /* Draw a regular rectangle (this should always show) */
cogl_set_source_color4x (COGL_FIXED_1, 0, 0, COGL_FIXED_1); cogl_set_source_color4f (1.0, 0, 0, 1.0);
cogl_rectangle (COGL_FIXED_TO_INT (x1), COGL_FIXED_TO_INT (y1), cogl_rectangle ( (x1), (y1),
COGL_FIXED_TO_INT (x2 - x1), COGL_FIXED_TO_INT (y2 - y1)); (x2 - x1), (y2 - y1));
/* The second time round draw beneath the first with backface /* The second time round draw beneath the first with backface
culling disabled */ culling disabled */

16
tests/interactive/test-cogl-tex-tile.c
View File

@ -90,22 +90,22 @@ test_coglbox_paint(ClutterActor *self)
ClutterFixed sin_frame, cos_frame; ClutterFixed sin_frame, cos_frame;
ClutterFixed frac_frame; ClutterFixed frac_frame;
gint t; gint t;
sin_frame = clutter_sini (CLUTTER_ANGLE_FROM_DEG (priv->frame)); sin_frame = clutter_sinx (priv->frame);
cos_frame = clutter_cosi (CLUTTER_ANGLE_FROM_DEG (priv->frame)); cos_frame = clutter_cosx (priv->frame);
pingpong_frame = (priv->frame <= 180 ? priv->frame : 360 - priv->frame); pingpong_frame = (priv->frame <= 180 ? priv->frame : 360 - priv->frame);
frac_frame = COGL_FIXED_DIV (CLUTTER_INT_TO_FIXED (pingpong_frame), frac_frame = (CLUTTER_INT_TO_FIXED (pingpong_frame) /
CLUTTER_INT_TO_FIXED (180)); CLUTTER_INT_TO_FIXED (180));
frac_frame += (COGL_FIXED_1 >> 1); frac_frame += 0.5;
frac_frame <<= 1; frac_frame *= 2;
for (t=0; t<4; t+=2) for (t=0; t<4; t+=2)
{ {
texcoords[t] += cos_frame; texcoords[t] += cos_frame;
texcoords[t+1] += sin_frame; texcoords[t+1] += sin_frame;
texcoords[t] = COGL_FIXED_MUL (texcoords[t], frac_frame); texcoords[t] = (texcoords[t] * frac_frame);
texcoords[t+1] = COGL_FIXED_MUL (texcoords[t+1], frac_frame); texcoords[t+1] = (texcoords[t+1] * frac_frame);
} }
priv = TEST_COGLBOX_GET_PRIVATE (self); priv = TEST_COGLBOX_GET_PRIVATE (self);

2
tests/interactive/test-text-field.c
View File

@ -19,7 +19,7 @@ on_entry_paint (ClutterActor *actor,
cogl_path_round_rectangle (0, 0, cogl_path_round_rectangle (0, 0,
CLUTTER_UNITS_TO_FIXED (width), CLUTTER_UNITS_TO_FIXED (width),
CLUTTER_UNITS_TO_FIXED (height), CLUTTER_UNITS_TO_FIXED (height),
COGL_FIXED_FROM_INT (4), (float)(4),
COGL_ANGLE_FROM_DEG (1.0)); COGL_ANGLE_FROM_DEG (1.0));
cogl_path_stroke (); cogl_path_stroke ();
} }