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 {
- CoglFixed x;
- CoglFixed y;
- CoglFixed z;
- CoglFixed w;
+ float x;
+ float y;
+ float z;
+ float w;
} fixed_vertex_t;
/* copies a fixed vertex into a ClutterVertex */
/* We care lot about precision here, so have to use MUL instead
* of FAST_MUL
*/
- vertex->x = COGL_FIXED_MUL (M (m, 0, 0), _x)
- + COGL_FIXED_MUL (M (m, 0, 1), _y)
- + COGL_FIXED_MUL (M (m, 0, 2), _z)
- + COGL_FIXED_MUL (M (m, 0, 3), _w);
-
- vertex->y = COGL_FIXED_MUL (M (m, 1, 0), _x)
- + COGL_FIXED_MUL (M (m, 1, 1), _y)
- + COGL_FIXED_MUL (M (m, 1, 2), _z)
- + COGL_FIXED_MUL (M (m, 1, 3), _w);
-
- vertex->z = COGL_FIXED_MUL (M (m, 2, 0), _x)
- + COGL_FIXED_MUL (M (m, 2, 1), _y)
- + COGL_FIXED_MUL (M (m, 2, 2), _z)
- + COGL_FIXED_MUL (M (m, 2, 3), _w);
-
- vertex->w = COGL_FIXED_MUL (M (m, 3, 0), _x)
- + COGL_FIXED_MUL (M (m, 3, 1), _y)
- + COGL_FIXED_MUL (M (m, 3, 2), _z)
- + COGL_FIXED_MUL (M (m, 3, 3), _w);
+ vertex->x = CLUTTER_FIXED_MUL (M (m, 0, 0), _x)
+ + CLUTTER_FIXED_MUL (M (m, 0, 1), _y)
+ + CLUTTER_FIXED_MUL (M (m, 0, 2), _z)
+ + CLUTTER_FIXED_MUL (M (m, 0, 3), _w);
+
+ vertex->y = CLUTTER_FIXED_MUL (M (m, 1, 0), _x)
+ + CLUTTER_FIXED_MUL (M (m, 1, 1), _y)
+ + CLUTTER_FIXED_MUL (M (m, 1, 2), _z)
+ + CLUTTER_FIXED_MUL (M (m, 1, 3), _w);
+
+ vertex->z = CLUTTER_FIXED_MUL (M (m, 2, 0), _x)
+ + CLUTTER_FIXED_MUL (M (m, 2, 1), _y)
+ + CLUTTER_FIXED_MUL (M (m, 2, 2), _z)
+ + CLUTTER_FIXED_MUL (M (m, 2, 3), _w);
+
+ vertex->w = CLUTTER_FIXED_MUL (M (m, 3, 0), _x)
+ + CLUTTER_FIXED_MUL (M (m, 3, 1), _y)
+ + CLUTTER_FIXED_MUL (M (m, 3, 2), _z)
+ + CLUTTER_FIXED_MUL (M (m, 3, 3), _w);
/* Specially for Matthew: was going to put a comment here, but could not
* think of anything at all to say ;)
/* 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) (COGL_FIXED_MUL (((COGL_FIXED_DIV ((x), (w)) + COGL_FIXED_1) >> 1), (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))
+#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_Z(z,w,v1,v2) (MTX_GL_SCALE_X ((z), (w), (v1), (v2)))
/* transforms a 4-tuple of coordinates using @matrix and
x = CLUTTER_UNITS_TO_FIXED (vertex->x);
y = CLUTTER_UNITS_TO_FIXED (vertex->y);
z = CLUTTER_UNITS_TO_FIXED (vertex->z);
- w = COGL_FIXED_1;
+ w = 1.0;
/* First we tranform the point using the OpenGL modelview matrix */
clutter_actor_transform_point_relative (self, ancestor, &x, &y, &z, &w);
* 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.
*/
- tmp.x = COGL_FIXED_MUL (CLUTTER_UNITS_TO_FIXED (x) + COGL_FIXED_0_5, v[2]);
- tmp.y = COGL_FIXED_MUL (COGL_FIXED_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.x = CLUTTER_FIXED_MUL (CLUTTER_UNITS_TO_FIXED (x) + 0.5, v[2]);
+ tmp.y = CLUTTER_FIXED_MUL (0.5 - CLUTTER_UNITS_TO_FIXED (y), v[3]);
+ tmp.z = CLUTTER_FIXED_MUL (CLUTTER_UNITS_TO_FIXED (z) + 0.5, v[2]);
tmp.w = 0;
fixed_vertex_to_units (&tmp, vertex);
cogl_get_modelview_matrix (mtx);
- fixed_vertex_transform (mtx, 0, 0, 0, COGL_FIXED_1, &vertices[0]);
- fixed_vertex_transform (mtx, width, 0, 0, COGL_FIXED_1, &vertices[1]);
- fixed_vertex_transform (mtx, 0, height, 0, COGL_FIXED_1, &vertices[2]);
- fixed_vertex_transform (mtx, width, height, 0, COGL_FIXED_1, &vertices[3]);
+ fixed_vertex_transform (mtx, 0, 0, 0, 1.0, &vertices[0]);
+ fixed_vertex_transform (mtx, width, 0, 0, 1.0, &vertices[1]);
+ fixed_vertex_transform (mtx, 0, height, 0, 1.0, &vertices[2]);
+ fixed_vertex_transform (mtx, width, height, 0, 1.0, &vertices[3]);
cogl_pop_matrix();
}
cogl_get_modelview_matrix (mtx);
- fixed_vertex_transform (mtx, 0, 0, 0, COGL_FIXED_1, &vertices[0]);
- fixed_vertex_transform (mtx, width, 0, 0, COGL_FIXED_1, &vertices[1]);
- fixed_vertex_transform (mtx, 0, height, 0, COGL_FIXED_1, &vertices[2]);
- fixed_vertex_transform (mtx, width, height, 0, COGL_FIXED_1, &vertices[3]);
+ fixed_vertex_transform (mtx, 0, 0, 0, 1.0, &vertices[0]);
+ fixed_vertex_transform (mtx, width, 0, 0, 1.0, &vertices[1]);
+ fixed_vertex_transform (mtx, 0, height, 0, 1.0, &vertices[2]);
+ fixed_vertex_transform (mtx, width, height, 0, 1.0, &vertices[3]);
cogl_pop_matrix();
* 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.
*/
- tmp.x = COGL_FIXED_MUL ((vertices[0].x + COGL_FIXED_0_5), v[2]);
- tmp.y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - vertices[0].y), v[3]);
- tmp.z = COGL_FIXED_MUL ((vertices[0].z + COGL_FIXED_0_5), v[2]);
+ tmp.x = CLUTTER_FIXED_MUL ((vertices[0].x + 0.5), v[2]);
+ tmp.y = CLUTTER_FIXED_MUL ((0.5 - vertices[0].y), v[3]);
+ tmp.z = CLUTTER_FIXED_MUL ((vertices[0].z + 0.5), v[2]);
fixed_vertex_to_units (&tmp, &verts[0]);
- tmp.x = COGL_FIXED_MUL ((vertices[1].x + COGL_FIXED_0_5), v[2]);
- tmp.y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - vertices[1].y), v[3]);
- tmp.z = COGL_FIXED_MUL ((vertices[1].z + COGL_FIXED_0_5), v[2]);
+ tmp.x = CLUTTER_FIXED_MUL ((vertices[1].x + 0.5), v[2]);
+ tmp.y = CLUTTER_FIXED_MUL ((0.5 - vertices[1].y), v[3]);
+ tmp.z = CLUTTER_FIXED_MUL ((vertices[1].z + 0.5), v[2]);
fixed_vertex_to_units (&tmp, &verts[1]);
- tmp.x = COGL_FIXED_MUL ((vertices[2].x + COGL_FIXED_0_5), v[2]);
- tmp.y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - vertices[2].y), v[3]);
- tmp.z = COGL_FIXED_MUL ((vertices[2].z + COGL_FIXED_0_5), v[2]);
+ tmp.x = CLUTTER_FIXED_MUL ((vertices[2].x + 0.5), v[2]);
+ tmp.y = CLUTTER_FIXED_MUL ((0.5 - vertices[2].y), v[3]);
+ tmp.z = CLUTTER_FIXED_MUL ((vertices[2].z + 0.5), v[2]);
fixed_vertex_to_units (&tmp, &verts[2]);
- tmp.x = COGL_FIXED_MUL ((vertices[3].x + COGL_FIXED_0_5), v[2]);
- tmp.y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - vertices[3].y), v[3]);
- tmp.z = COGL_FIXED_MUL ((vertices[3].z + COGL_FIXED_0_5), v[2]);
+ tmp.x = CLUTTER_FIXED_MUL ((vertices[3].x + 0.5), v[2]);
+ tmp.y = CLUTTER_FIXED_MUL ((0.5 - vertices[3].y), v[3]);
+ tmp.z = CLUTTER_FIXED_MUL ((vertices[3].z + 0.5), v[2]);
fixed_vertex_to_units (&tmp, &verts[3]);
}
* 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).
*/
- 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);
if (priv->rzang)
CLUTTER_UNITS_TO_FIXED (priv->rzy),
0);
- cogl_rotatex (priv->rzang, 0, 0, COGL_FIXED_1);
+ cogl_rotatex (priv->rzang, 0, 0, 1.0);
cogl_translatex (CLUTTER_UNITS_TO_FIXED (-priv->rzx),
CLUTTER_UNITS_TO_FIXED (-priv->rzy),
0,
CLUTTER_UNITS_TO_FIXED (priv->z + priv->ryz));
- cogl_rotatex (priv->ryang, 0, COGL_FIXED_1, 0);
+ cogl_rotatex (priv->ryang, 0, 1.0, 0);
cogl_translatex (CLUTTER_UNITS_TO_FIXED (-priv->ryx),
0,
CLUTTER_UNITS_TO_FIXED (priv->rxy),
CLUTTER_UNITS_TO_FIXED (priv->z + priv->rxz));
- cogl_rotatex (priv->rxang, COGL_FIXED_1, 0, 0);
+ cogl_rotatex (priv->rxang, 1.0, 0, 0);
cogl_translatex (0,
CLUTTER_UNITS_TO_FIXED (-priv->rxy),
case PROP_SCALE_X:
clutter_actor_set_scalex
(actor,
- COGL_FIXED_FROM_FLOAT (g_value_get_double (value)),
+ CLUTTER_FLOAT_TO_FIXED (g_value_get_double (value)),
priv->scale_y);
break;
case PROP_SCALE_Y:
clutter_actor_set_scalex
(actor,
priv->scale_x,
- COGL_FIXED_FROM_FLOAT (g_value_get_double (value)));
+ CLUTTER_FLOAT_TO_FIXED (g_value_get_double (value)));
break;
case PROP_CLIP:
{
{
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_X_AXIS,
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_Y_AXIS,
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_Z_AXIS,
angle,
}
break;
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;
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;
case PROP_REACTIVE:
g_value_set_boolean (value, clutter_actor_get_reactive (actor));
break;
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;
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;
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;
case PROP_ROTATION_CENTER_X:
{
priv->has_clip = FALSE;
priv->opacity = 0xff;
priv->id = clutter_id_pool_add (CLUTTER_CONTEXT()->id_pool, self);
- priv->scale_x = COGL_FIXED_1;
- priv->scale_y = COGL_FIXED_1;
+ priv->scale_x = 1.0;
+ priv->scale_y = 1.0;
priv->shader_data = NULL;
priv->show_on_set_parent = TRUE;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
clutter_actor_set_scalex (self,
- COGL_FIXED_FROM_FLOAT (scale_x),
- COGL_FIXED_FROM_FLOAT (scale_y));
+ CLUTTER_FLOAT_TO_FIXED (scale_x),
+ CLUTTER_FLOAT_TO_FIXED (scale_y));
}
/**
g_return_if_fail (CLUTTER_IS_ACTOR (self));
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)
- *scale_y = COGL_FIXED_TO_FLOAT (self->priv->scale_y);
+ *scale_y = CLUTTER_FIXED_TO_FLOAT (self->priv->scale_y);
}
/**
g_return_if_fail (CLUTTER_IS_ACTOR (self));
clutter_actor_set_rotation_internal (self, axis,
- COGL_FIXED_FROM_FLOAT (angle),
+ CLUTTER_FLOAT_TO_FIXED (angle),
x, y, z);
}
g_return_if_fail (CLUTTER_IS_ACTOR (self));
clutter_actor_set_rotationx (self, axis,
- COGL_FIXED_FROM_FLOAT (angle),
+ CLUTTER_FLOAT_TO_FIXED (angle),
x, y, z);
}
switch (axis)
{
case CLUTTER_X_AXIS:
- retval = COGL_FIXED_TO_DOUBLE (priv->rxang);
+ retval = CLUTTER_FIXED_TO_DOUBLE (priv->rxang);
if (y)
*y = priv->rxy;
if (z)
break;
case CLUTTER_Y_AXIS:
- retval = COGL_FIXED_TO_DOUBLE (priv->ryang);
+ retval = CLUTTER_FIXED_TO_DOUBLE (priv->ryang);
if (x)
*x = priv->ryx;
if (z)
break;
case CLUTTER_Z_AXIS:
- retval = COGL_FIXED_TO_DOUBLE (priv->rzang);
+ retval = CLUTTER_FIXED_TO_DOUBLE (priv->rzang);
if (x)
*x = priv->rzx;
if (y)
{
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,
x, y, z));
}
/* angle */
element = json_array_get_element (array, 0);
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
return FALSE;
if (!du || !dv)
return FALSE;
-#define FP2FX COGL_FIXED_FROM_FLOAT
-#define FX2FP COGL_FIXED_TO_DOUBLE
+#define FP2FX CLUTTER_FLOAT_TO_FIXED
+#define FX2FP CLUTTER_FIXED_TO_DOUBLE
#define UX2FP CLUTTER_UNITS_TO_FLOAT
#define UX2FX CLUTTER_UNITS_TO_FIXED
#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))
/*
RQ[2][1] = UX2FX (v[0].y);
RQ[0][2] = 0;
RQ[1][2] = 0;
- RQ[2][2] = COGL_FIXED_1;
+ RQ[2][2] = 1.0;
}
else
{
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[2][2] = COGL_FIXED_1;
+ RQ[2][2] = 1.0;
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)
- + 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[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)
- + 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);
}
/*
* Check the resutling martix is OK.
*/
- det = COGL_FIXED_MUL (RQ[0][0], ST[0][0])
- + COGL_FIXED_MUL (RQ[0][1], ST[0][1])
- + COGL_FIXED_MUL (RQ[0][2], ST[0][2]);
+ det = CLUTTER_FIXED_MUL (RQ[0][0], ST[0][0])
+ + CLUTTER_FIXED_MUL (RQ[0][1], ST[0][1])
+ + CLUTTER_FIXED_MUL (RQ[0][2], ST[0][2]);
if (!det)
return FALSE;
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 FALSE;
static guint32
sincx1024_func (ClutterAlpha *alpha,
- ClutterAngle angle,
+ float angle,
ClutterFixed offset)
{
ClutterTimeline *timeline;
gint current_frame_num, n_frames;
- ClutterAngle x;
+ float x;
ClutterFixed sine;
timeline = clutter_alpha_get_timeline (alpha);
x -= (512 * 512 / angle);
- sine = ((cogl_angle_sin (x) + offset) / 2)
+ sine = ((sinf (x * (G_PI/180.0)) + offset) / 2)
* CLUTTER_ALPHA_MAX_ALPHA;
sine = sine >> COGL_FIXED_Q;
n_frames = clutter_timeline_get_n_frames (timeline);
x = angle * current_frame_num / n_frames;
- x = COGL_FIXED_FAST_MUL (x, COGL_FIXED_PI)
- - COGL_FIXED_FAST_DIV (COGL_FIXED_PI, angle);
+ x = CLUTTER_FIXED_MUL (x, CFX_PI)
+ - CLUTTER_FIXED_DIV (CFX_PI, angle);
- sine = (cogl_fixed_sin (x) + offset) / 2;
+ sine = (sinf (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
return sinc_func (alpha, 2.0, 1.0);
#else
/* 2.0 above represents full circle */
- return sincx1024_func (alpha, 1024, COGL_FIXED_1);
+ return sincx1024_func (alpha, 1024, 1.0);
#endif
}
ClutterTimeline * timeline;
gint frame;
gint n_frames;
- ClutterAngle x;
+ float x;
ClutterFixed sine;
timeline = clutter_alpha_get_timeline (alpha);
x = 256 * frame / n_frames;
- sine = cogl_angle_sin (x) * CLUTTER_ALPHA_MAX_ALPHA;
+ sine = sinf (x * (G_PI/180.0)) * CLUTTER_ALPHA_MAX_ALPHA;
return ((guint32) sine) >> COGL_FIXED_Q;
}
ClutterTimeline * timeline;
gint frame;
gint n_frames;
- ClutterAngle x;
+ float x;
ClutterFixed sine;
timeline = clutter_alpha_get_timeline (alpha);
x = 256 * frame / n_frames + 256;
- sine = cogl_angle_sin (x) * CLUTTER_ALPHA_MAX_ALPHA;
+ sine = sinf (x * (G_PI/180.0)) * CLUTTER_ALPHA_MAX_ALPHA;
return ((guint32) sine) >> COGL_FIXED_Q;
}
ClutterTimeline *timeline;
gint frame;
gint n_frames;
- ClutterAngle x;
+ float x;
ClutterFixed sine;
timeline = clutter_alpha_get_timeline (alpha);
x = 512 * frame / n_frames;
- sine = cogl_angle_sin (x) * CLUTTER_ALPHA_MAX_ALPHA;
+ sine = sinf (x * (G_PI/180.0)) * CLUTTER_ALPHA_MAX_ALPHA;
return ((guint32) sine) >> COGL_FIXED_Q;
}
ClutterTimeline *timeline;
gint frame;
gint n_frames;
- ClutterAngle x;
+ float x;
ClutterFixed sine;
timeline = clutter_alpha_get_timeline (alpha);
/* XXX- if we use 768 we overflow */
x = 256 * frame / n_frames + 767;
- sine = (cogl_angle_sin (x) + 1) * CLUTTER_ALPHA_MAX_ALPHA;
+ sine = (sinf (x * (G_PI/180.0)) + 1) * CLUTTER_ALPHA_MAX_ALPHA;
return ((guint32) sine) >> COGL_FIXED_Q;
}
ClutterTimeline *timeline;
gint frame;
gint n_frames;
- ClutterAngle x;
+ float x;
ClutterFixed sine;
timeline = clutter_alpha_get_timeline (alpha);
x = 256 * frame / n_frames;
- sine = cogl_angle_sin (x) * CLUTTER_ALPHA_MAX_ALPHA;
+ sine = sinf (x * (G_PI/180.0)) * CLUTTER_ALPHA_MAX_ALPHA;
return ((guint32) sine) >> COGL_FIXED_Q;
}
ClutterTimeline *timeline;
gint frame;
gint n_frames;
- ClutterAngle x;
+ float x;
ClutterFixed sine;
timeline = clutter_alpha_get_timeline (alpha);
x = -256 * frame / n_frames + 256;
- sine = (cogl_angle_sin (x) + 1) / 2 * CLUTTER_ALPHA_MAX_ALPHA;
+ sine = (sinf (x * (G_PI/180.0)) + 1) / 2 * CLUTTER_ALPHA_MAX_ALPHA;
return ((guint32) sine) >> COGL_FIXED_Q;
}
/*
* Convert x to 8.24 for next step.
*/
- x = COGL_FIXED_FAST_DIV (frame, n_frames) << 8;
+ x = CLUTTER_FIXED_DIV (frame, n_frames) << 8;
/*
* f(x) = -2x^3 + 3x^2
*/
r = ((x >> 12) * (x >> 12) * 3 - (x >> 15) * (x >> 16) * (x >> 16)) >> 8;
- return COGL_FIXED_TO_INT (r * CLUTTER_ALPHA_MAX_ALPHA);
+ return (r * CLUTTER_ALPHA_MAX_ALPHA);
}
/**
x = x_alpha_max * frame / n_frames;
- result = CLAMP (cogl_fixed_pow2 (x) - 1, 0, CLUTTER_ALPHA_MAX_ALPHA);
+ result = CLAMP (pow2f (x) - 1, 0, CLUTTER_ALPHA_MAX_ALPHA);
return result;
}
x = (x_alpha_max * (n_frames - frame)) / n_frames;
- result = CLAMP (cogl_fixed_pow2 (x) - 1, 0, CLUTTER_ALPHA_MAX_ALPHA);
+ result = CLAMP (pow2f (x) - 1, 0, CLUTTER_ALPHA_MAX_ALPHA);
return result;
}
priv = backend->priv;
- fixed_dpi = COGL_FIXED_FROM_FLOAT (dpi);
+ fixed_dpi = CLUTTER_FLOAT_TO_FIXED (dpi);
if (priv->resolution != fixed_dpi)
priv->resolution = fixed_dpi;
{
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);
}
/**
priv = CLUTTER_BEHAVIOUR_DEPTH (behaviour)->priv;
/* 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
- + 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);
gint a;
gint b;
- ClutterAngle angle_start;
- ClutterAngle angle_end;
- ClutterAngle angle_tilt_x;
- ClutterAngle angle_tilt_y;
- ClutterAngle angle_tilt_z;
+ float angle_start;
+ float angle_end;
+ float angle_tilt_x;
+ float angle_tilt_y;
+ float angle_tilt_z;
ClutterRotateDirection direction;
};
static void
clutter_behaviour_ellipse_advance (ClutterBehaviourEllipse *e,
- ClutterAngle angle,
+ float angle,
knot3d *knot)
{
ClutterBehaviourEllipsePrivate *priv = e->priv;
gint x, y, z;
- x = COGL_FIXED_TO_INT (priv->a * cogl_angle_cos (angle));
- y = COGL_FIXED_TO_INT (priv->b * cogl_angle_sin (angle));
+ x = (priv->a * cosf (angle * (G_PI/180.0)));
+ y = (priv->b * sinf (angle * (G_PI/180.0)));
z = 0;
if (priv->angle_tilt_z)
*/
ClutterFixed x2, y2;
- x2 = x * cogl_angle_cos (priv->angle_tilt_z)
- - y * cogl_angle_sin (priv->angle_tilt_z);
+ x2 = x * cosf (priv->angle_tilt_z * (G_PI/180.0))
+ - y * sinf (priv->angle_tilt_z * (G_PI/180.0));
- y2 = y * cogl_angle_cos (priv->angle_tilt_z)
- + x * cogl_angle_sin (priv->angle_tilt_z);
+ y2 = y * cosf (priv->angle_tilt_z * (G_PI/180.0))
+ + x * sinf (priv->angle_tilt_z * (G_PI/180.0));
- x = COGL_FIXED_TO_INT (x2);
- y = COGL_FIXED_TO_INT (y2);
+ x = (x2);
+ y = (y2);
}
if (priv->angle_tilt_x)
{
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);
- y = COGL_FIXED_TO_INT (y2);
+ z = (z2);
+ y = (y2);
}
if (priv->angle_tilt_y)
{
ClutterFixed x2, z2;
- x2 = x * cogl_angle_cos (priv->angle_tilt_y)
- - z * cogl_angle_sin (priv->angle_tilt_y);
+ x2 = x * cosf (priv->angle_tilt_y * (G_PI/180.0))
+ - z * sinf (priv->angle_tilt_y * (G_PI/180.0));
- z2 = z * cogl_angle_cos (priv->angle_tilt_y)
- + x * cogl_angle_sin (priv->angle_tilt_y);
+ z2 = z * cosf (priv->angle_tilt_y * (G_PI/180.0))
+ + x * sinf (priv->angle_tilt_y * (G_PI/180.0));
- x = COGL_FIXED_TO_INT (x2);
- z = COGL_FIXED_TO_INT (z2);
+ x = (x2);
+ z = (z2);
}
knot->x = x;
clutter_actor_set_depth (actor, knot->z);
}
-static inline ClutterAngle
-clamp_angle (ClutterAngle a)
+static inline float
+clamp_angle (float a)
{
- ClutterAngle a1, a2;
+ float a1, a2;
gint rounds;
/* Need to add the 256 offset here, since the user space 0 maps to our
{
ClutterBehaviourEllipse *self = CLUTTER_BEHAVIOUR_ELLIPSE (behave);
ClutterBehaviourEllipsePrivate *priv = self->priv;
- ClutterAngle start, end;
+ float start, end;
knot3d knot;
- ClutterAngle angle = 0;
+ float angle = 0;
start = priv->angle_start;
end = priv->angle_end;
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
clutter_behaviour_ellipse_set_angle_startx (self,
- COGL_FIXED_FROM_FLOAT (angle_start));
+ CLUTTER_FLOAT_TO_FIXED (angle_start));
}
/**
ClutterFixed angle_start)
{
ClutterBehaviourEllipsePrivate *priv;
- ClutterAngle new_angle;
+ float new_angle;
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
new_angle = clamp_angle (COGL_ANGLE_FROM_DEGX (angle_start) - 256);
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
clutter_behaviour_ellipse_set_angle_endx (self,
- COGL_FIXED_FROM_FLOAT (angle_end));
+ CLUTTER_FLOAT_TO_FIXED (angle_end));
}
/**
ClutterFixed angle_end)
{
ClutterBehaviourEllipsePrivate *priv;
- ClutterAngle new_angle;
+ float new_angle;
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
clutter_behaviour_ellipse_set_angle_tiltx (self,
axis,
- COGL_FIXED_FROM_FLOAT (angle_tilt));
+ CLUTTER_FLOAT_TO_FIXED (angle_tilt));
}
/**
ClutterFixed angle_tilt)
{
ClutterBehaviourEllipsePrivate *priv;
- ClutterAngle new_angle;
+ float new_angle;
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ELLIPSE (self));
gdouble angle_tilt_z)
{
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));
ClutterFixed angle_tilt_z)
{
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));
ClutterFixed a1, a2;
gint rounds;
- rounds = a / COGL_FIXED_360;
- a1 = rounds * COGL_FIXED_360;
+ rounds = a / 360.0;
+ a1 = rounds * 360.0;
a2 = a - a1;
return a2;
rotate_behaviour = CLUTTER_BEHAVIOUR_ROTATE (behaviour);
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;
start = priv->angle_start;
if (priv->direction == CLUTTER_ROTATE_CW && start >= end)
{
- end += COGL_FIXED_360;
+ end += 360.0;
}
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,
alpha_notify_foreach,
switch (prop_id)
{
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;
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;
case PROP_AXIS:
priv->axis = g_value_get_enum (value);
switch (prop_id)
{
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;
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;
case PROP_AXIS:
g_value_set_enum (value, priv->axis);
rotate->priv = priv = CLUTTER_BEHAVIOUR_ROTATE_GET_PRIVATE (rotate);
- priv->angle_start = COGL_FIXED_FROM_FLOAT (0.0);
- priv->angle_end = COGL_FIXED_FROM_FLOAT (0.0);
+ priv->angle_start = CLUTTER_FLOAT_TO_FIXED (0.0);
+ priv->angle_end = CLUTTER_FLOAT_TO_FIXED (0.0);
priv->axis = CLUTTER_Z_AXIS;
priv->direction = CLUTTER_ROTATE_CW;
priv->center_x = priv->center_y = priv->center_z = 0;
priv = rotate->priv;
if (angle_start)
- *angle_start = COGL_FIXED_TO_DOUBLE (priv->angle_start);
+ *angle_start = CLUTTER_FIXED_TO_DOUBLE (priv->angle_start);
if (angle_end)
- *angle_end = COGL_FIXED_TO_DOUBLE (priv->angle_end);
+ *angle_end = CLUTTER_FIXED_TO_DOUBLE (priv->angle_end);
}
/**
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ROTATE (rotate));
clutter_behaviour_rotate_set_boundsx (rotate,
- COGL_FIXED_FROM_FLOAT (angle_start),
- COGL_FIXED_FROM_FLOAT (angle_end));
+ CLUTTER_FLOAT_TO_FIXED (angle_start),
+ CLUTTER_FLOAT_TO_FIXED (angle_end));
}
/**
{
ClutterFixed factor;
- factor = COGL_FIXED_FROM_INT (alpha_value) / CLUTTER_ALPHA_MAX_ALPHA;
+ factor = (float)(alpha_value) / CLUTTER_ALPHA_MAX_ALPHA;
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_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;
}
switch (prop_id)
{
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;
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;
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;
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;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
switch (prop_id)
{
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;
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;
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;
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;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
self->priv = priv = CLUTTER_BEHAVIOUR_SCALE_GET_PRIVATE (self);
- priv->x_scale_start = priv->x_scale_end = COGL_FIXED_1;
- priv->y_scale_start = priv->y_scale_end = COGL_FIXED_1;
+ priv->x_scale_start = priv->x_scale_end = 1.0;
+ priv->y_scale_start = priv->y_scale_end = 1.0;
}
/**
g_return_val_if_fail (alpha == NULL || CLUTTER_IS_ALPHA (alpha), NULL);
return clutter_behaviour_scale_newx (alpha,
- COGL_FIXED_FROM_FLOAT (x_scale_start),
- COGL_FIXED_FROM_FLOAT (y_scale_start),
- COGL_FIXED_FROM_FLOAT (x_scale_end),
- COGL_FIXED_FROM_FLOAT (y_scale_end));
+ CLUTTER_FLOAT_TO_FIXED (x_scale_start),
+ CLUTTER_FLOAT_TO_FIXED (y_scale_start),
+ CLUTTER_FLOAT_TO_FIXED (x_scale_end),
+ CLUTTER_FLOAT_TO_FIXED (y_scale_end));
}
/**
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_SCALE (scale));
clutter_behaviour_scale_set_boundsx (scale,
- COGL_FIXED_FROM_FLOAT (x_scale_start),
- COGL_FIXED_FROM_FLOAT (y_scale_start),
- COGL_FIXED_FROM_FLOAT (x_scale_end),
- COGL_FIXED_FROM_FLOAT (y_scale_end));
+ CLUTTER_FLOAT_TO_FIXED (x_scale_start),
+ CLUTTER_FLOAT_TO_FIXED (y_scale_start),
+ CLUTTER_FLOAT_TO_FIXED (x_scale_end),
+ CLUTTER_FLOAT_TO_FIXED (y_scale_end));
}
/**
priv = scale->priv;
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)
- *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)
- *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)
- *y_scale_end = COGL_FIXED_TO_DOUBLE (priv->y_scale_end);
+ *y_scale_end = CLUTTER_FIXED_TO_DOUBLE (priv->y_scale_end);
}
/**
tex_height = cogl_texture_get_height (cogl_texture);
if (priv->repeat_x && tex_width > 0)
- t_w = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (x_2 - x_1),
- COGL_FIXED_FROM_INT (tex_width));
+ t_w = CLUTTER_FIXED_DIV ((float)(x_2 - x_1),
+ (float)(tex_width));
else
- t_w = COGL_FIXED_1;
+ t_w = 1.0;
if (priv->repeat_y && tex_height > 0)
- t_h = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (y_2 - y_1),
- COGL_FIXED_FROM_INT (tex_height));
+ t_h = CLUTTER_FIXED_DIV ((float)(y_2 - y_1),
+ (float)(tex_height));
else
- t_h = COGL_FIXED_1;
+ t_h = 1.0;
/* Parent paint translated us into position */
cogl_texture_rectangle (cogl_texture, 0, 0,
- COGL_FIXED_FROM_INT (x_2 - x_1),
- COGL_FIXED_FROM_INT (y_2 - y_1),
+ (float)(x_2 - x_1),
+ (float)(y_2 - y_1),
0, 0, t_w, t_h);
}
g_return_if_fail (src != NULL);
- red = COGL_FIXED_FROM_INT (src->red) / 255;
- green = COGL_FIXED_FROM_INT (src->green) / 255;
- blue = COGL_FIXED_FROM_INT (src->blue) / 255;
+ red = (float)(src->red) / 255;
+ green = (float)(src->green) / 255;
+ blue = (float)(src->blue) / 255;
if (red > green)
{
if (max != min)
{
- if (l <= COGL_FIXED_0_5)
- s = COGL_FIXED_FAST_DIV ((max - min), (max + min));
+ if (l <= 0.5)
+ s = CLUTTER_FIXED_DIV ((max - min), (max + min));
else
- s = COGL_FIXED_FAST_DIV ((max - min),
- (COGL_FIXED_FROM_INT (2) - max - min));
+ s = CLUTTER_FIXED_DIV ((max - min),
+ ((float)(2) - max - min));
delta = max - min;
if (red == max)
- h = COGL_FIXED_FAST_DIV ((green - blue), delta);
+ h = CLUTTER_FIXED_DIV ((green - blue), delta);
else if (green == max)
{
- h = COGL_FIXED_FROM_INT (2)
- + COGL_FIXED_FAST_DIV ((blue - red), delta);
+ h = (float)(2)
+ + CLUTTER_FIXED_DIV ((blue - red), delta);
}
else if (blue == max)
{
- h = COGL_FIXED_FROM_INT (4)
- + COGL_FIXED_FAST_DIV ((red - green), delta);
+ h = (float)(4)
+ + CLUTTER_FIXED_DIV ((red - green), delta);
}
h *= 60;
if (h < 0)
- h += COGL_FIXED_360;
+ h += 360.0;
}
if (hue)
l = luminance;
s = saturation;
- if (l <= COGL_FIXED_0_5)
- m2 = COGL_FIXED_FAST_MUL (l, (COGL_FIXED_1 + s));
+ if (l <= 0.5)
+ m2 = CLUTTER_FIXED_MUL (l, (1.0 + s));
else
- m2 = l + s - COGL_FIXED_FAST_MUL (l, s);
+ m2 = l + s - CLUTTER_FIXED_MUL (l, s);
m1 = 2 * l - m2;
if (s == 0)
{
- dest->red = (guint8) COGL_FIXED_TO_INT (l * 255);
- dest->green = (guint8) COGL_FIXED_TO_INT (l * 255);
- dest->blue = (guint8) COGL_FIXED_TO_INT (l * 255);
+ dest->red = (guint8) (l * 255);
+ dest->green = (guint8) (l * 255);
+ dest->blue = (guint8) (l * 255);
}
else
{
- h = hue + COGL_FIXED_120;
+ h = hue + 120.0;
- while (h > COGL_FIXED_360)
- h -= COGL_FIXED_360;
+ while (h > 360.0)
+ h -= 360.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);
- dest->red = (guint8) COGL_FIXED_TO_INT (tmp * 255);
+ tmp = (m1 + CLUTTER_FIXED_MUL ((m2 - m1), h) / 60);
+ dest->red = (guint8) (tmp * 255);
}
- else if (h < COGL_FIXED_180)
- dest->red = (guint8) COGL_FIXED_TO_INT (m2 * 255);
- else if (h < COGL_FIXED_240)
+ else if (h < 180.0)
+ dest->red = (guint8) (m2 * 255);
+ 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;
- dest->red = (guint8) COGL_FIXED_TO_INT (tmp * 255);
+ dest->red = (guint8) (tmp * 255);
}
else
- dest->red = (guint8) COGL_FIXED_TO_INT (m1 * 255);
+ dest->red = (guint8) (m1 * 255);
h = hue;
- while (h > COGL_FIXED_360)
- h -= COGL_FIXED_360;
+ while (h > 360.0)
+ h -= 360.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);
- dest->green = (guint8) COGL_FIXED_TO_INT (tmp * 255);
+ tmp = (m1 + CLUTTER_FIXED_MUL ((m2 - m1), h) / 60);
+ dest->green = (guint8) (tmp * 255);
}
- else if (h < COGL_FIXED_180)
- dest->green = (guint8) COGL_FIXED_TO_INT (m2 * 255);
- else if (h < COGL_FIXED_240)
+ else if (h < 180.0)
+ dest->green = (guint8) (m2 * 255);
+ 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;
- dest->green = (guint8) COGL_FIXED_TO_INT (tmp * 255);
+ dest->green = (guint8) (tmp * 255);
}
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)
- h -= COGL_FIXED_360;
+ while (h > 360.0)
+ h -= 360.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);
- dest->blue = (guint8) COGL_FIXED_TO_INT (tmp * 255);
+ tmp = (m1 + CLUTTER_FIXED_MUL ((m2 - m1), h) / 60);
+ dest->blue = (guint8) (tmp * 255);
}
- else if (h < COGL_FIXED_180)
- dest->blue = (guint8) COGL_FIXED_TO_INT (m2 * 255);
- else if (h < COGL_FIXED_240)
+ else if (h < 180.0)
+ dest->blue = (guint8) (m2 * 255);
+ 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;
- dest->blue = (guint8) COGL_FIXED_TO_INT (tmp * 255);
+ dest->blue = (guint8) (tmp * 255);
}
else
- dest->blue = (guint8) COGL_FIXED_TO_INT (m1 * 255);
+ dest->blue = (guint8) (m1 * 255);
}
}
clutter_color_to_hlsx (src, &h, &l, &s);
if (hue)
- *hue = (guint8) COGL_FIXED_TO_INT (h * 255) / 360;
+ *hue = (guint8) (h * 255) / 360;
if (luminance)
- *luminance = (guint8) COGL_FIXED_TO_INT (l * 255);
+ *luminance = (guint8) (l * 255);
if (saturation)
- *saturation = (guint8) COGL_FIXED_TO_INT (s * 255);
+ *saturation = (guint8) (s * 255);
}
/**
{
ClutterFixed h, l, s;
- h = COGL_FIXED_FROM_INT (hue * 360) / 255;
- l = COGL_FIXED_FROM_INT (luminance) / 255;
- s = COGL_FIXED_FROM_INT (saturation) / 255;
+ h = (float)(hue * 360) / 255;
+ l = (float)(luminance) / 255;
+ s = (float)(saturation) / 255;
clutter_color_from_hlsx (dest, h, l, s);
}
ClutterColor *dest,
gdouble shade)
{
- clutter_color_shadex (src, dest, COGL_FIXED_FROM_FLOAT (shade));
+ clutter_color_shadex (src, dest, CLUTTER_FLOAT_TO_FIXED (shade));
}
/**
clutter_color_to_hlsx (src, &h, &l, &s);
- l = COGL_FIXED_FAST_MUL (l, shade);
- if (l > COGL_FIXED_1)
- l = COGL_FIXED_1;
+ l = CLUTTER_FIXED_MUL (l, shade);
+ if (l > 1.0)
+ l = 1.0;
else if (l < 0)
l = 0;
- s = COGL_FIXED_FAST_MUL (s, shade);
- if (s > COGL_FIXED_1)
- s = COGL_FIXED_1;
+ s = CLUTTER_FIXED_MUL (s, shade);
+ if (s > 1.0)
+ s = 1.0;
else if (s < 0)
s = 0;
clutter_value_transform_fixed_int (const GValue *src,
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
clutter_value_transform_fixed_double (const GValue *src,
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
clutter_value_transform_fixed_float (const GValue *src,
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
clutter_value_transform_int_fixed (const GValue *src,
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
clutter_value_transform_double_fixed (const GValue *src,
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
clutter_value_transform_float_fixed (const GValue *src,
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);
}
GValue *value)
{
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;
g_assert (CLUTTER_IS_PARAM_SPEC_FIXED (pspec));
min = fspec->minimum;
max = fspec->maximum;
- val = COGL_FIXED_TO_INT (value->data[0].v_int);
+ val = (value->data[0].v_int);
val = CLAMP (val, min, max);
if (val != oval)
*
* 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).
*/
-typedef CoglAngle ClutterAngle; /* angle such that 1024 == 2*PI */
+typedef float ClutterAngle; /* angle such that 1024 == 2*PI */
#define CLUTTER_ANGLE_FROM_DEG(x) (COGL_ANGLE_FROM_DEG (x))
#define CLUTTER_ANGLE_FROM_DEGX(x) (COGL_ANGLE_FROM_DEGX (x))
*
* 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:
*
* 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_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 255
*/
-#define CFX_255 COGL_FIXED_255
+#define CFX_255 255.0
/**
* CLUTTER_FIXED_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:
*
* 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:
*
* 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:
*
* 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:
*
* Since: 0.6
*/
-#define CLUTTER_FIXED_TO_INT(x) COGL_FIXED_TO_INT ((x))
+#define CLUTTER_FIXED_TO_INT(x) ((x))
/**
* CLUTTER_FIXED_FRACTION:
*
* 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:
*
* 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:
*
* 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:
*
* 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_qdivx(x,y) cogl_fixed_div ((x), (y))
+#define clutter_qmulx(x,y) ((x) * (y))
+#define clutter_qdivx(x,y) ((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))
+#define clutter_sinx(a) sinf ((a))
+#define clutter_sini(a) sinf ((a * (G_PI/180.0)))
+#define clutter_tani(a) tanf ((a * (G_PI/180.0)))
+#define clutter_atani(a) atanf ((a))
+#define clutter_atan2i(x,y) atan2f ((x), (y))
+#define clutter_cosx(a) cosf ((a))
+#define clutter_cosi(a) cosf ((a * (G_PI/180.0)))
/**
* CLUTTER_SQRTI_ARG_MAX
*/
#define CLUTTER_SQRTI_ARG_10_PERCENT COGL_SQRTI_ARG_10_PERCENT
-#define clutter_sqrtx(x) cogl_fixed_sqrt ((x))
+#define clutter_sqrtx(x) sqrtf ((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_log2x(x) log2f ((x))
+#define clutter_pow2x(x) pow2f ((x))
+#define clutter_powx(x,y) powf ((x), (y))
#define CLUTTER_TYPE_FIXED (clutter_fixed_get_type ())
#define CLUTTER_TYPE_PARAM_FIXED (clutter_param_fixed_get_type ())
break;
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);
else
g_value_set_boolean (value, FALSE);
priv->color = default_stage_color;
- priv->perspective.fovy = COGL_FIXED_60; /* 60 Degrees */
- priv->perspective.aspect = COGL_FIXED_1;
- priv->perspective.z_near = COGL_FIXED_FROM_FLOAT (0.1);
- priv->perspective.z_far = COGL_FIXED_FROM_FLOAT (100.0);
+ priv->perspective.fovy = 60.0; /* 60 Degrees */
+ priv->perspective.aspect = 1.0;
+ priv->perspective.z_near = CLUTTER_FLOAT_TO_FIXED (0.1);
+ priv->perspective.z_far = CLUTTER_FLOAT_TO_FIXED (100.0);
/* depth cueing */
- priv->fog.density = COGL_FIXED_FROM_FLOAT (0.1);
- priv->fog.z_near = COGL_FIXED_FROM_FLOAT (1.0);
- priv->fog.z_far = COGL_FIXED_FROM_FLOAT (2.0);
+ priv->fog.density = CLUTTER_FLOAT_TO_FIXED (0.1);
+ priv->fog.z_near = CLUTTER_FLOAT_TO_FIXED (1.0);
+ priv->fog.z_far = CLUTTER_FLOAT_TO_FIXED (2.0);
clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE);
clutter_stage_set_key_focus (self, NULL);
priv = stage->priv;
- priv->perspective.fovy = COGL_FIXED_FROM_FLOAT (fovy);
- priv->perspective.aspect = COGL_FIXED_FROM_FLOAT (aspect);
- priv->perspective.z_near = COGL_FIXED_FROM_FLOAT (z_near);
- priv->perspective.z_far = COGL_FIXED_FROM_FLOAT (z_far);
+ priv->perspective.fovy = CLUTTER_FLOAT_TO_FIXED (fovy);
+ priv->perspective.aspect = CLUTTER_FLOAT_TO_FIXED (aspect);
+ priv->perspective.z_near = CLUTTER_FLOAT_TO_FIXED (z_near);
+ priv->perspective.z_far = CLUTTER_FLOAT_TO_FIXED (z_far);
/* this will cause the viewport to be reset; see
* clutter_maybe_setup_viewport() inside clutter-main.c
priv = stage->priv;
if (fovy)
- *fovy = COGL_FIXED_TO_FLOAT (priv->perspective.fovy);
+ *fovy = CLUTTER_FIXED_TO_FLOAT (priv->perspective.fovy);
if (aspect)
- *aspect = COGL_FIXED_TO_FLOAT (priv->perspective.aspect);
+ *aspect = CLUTTER_FIXED_TO_FLOAT (priv->perspective.aspect);
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)
- *z_far = COGL_FIXED_TO_FLOAT (priv->perspective.z_far);
+ *z_far = CLUTTER_FIXED_TO_FLOAT (priv->perspective.z_far);
}
/**
priv = stage->priv;
if (density)
- *density = COGL_FIXED_TO_FLOAT (priv->fog.density);
+ *density = CLUTTER_FIXED_TO_FLOAT (priv->fog.density);
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)
- *z_far = COGL_FIXED_TO_FLOAT (priv->fog.z_far);
+ *z_far = CLUTTER_FIXED_TO_FLOAT (priv->fog.z_far);
}
/**
priv = stage->priv;
- priv->fog.density = COGL_FIXED_FROM_FLOAT (density);
- priv->fog.z_near = COGL_FIXED_FROM_FLOAT (z_near);
- priv->fog.z_far = COGL_FIXED_FROM_FLOAT (z_far);
+ priv->fog.density = CLUTTER_FLOAT_TO_FIXED (density);
+ priv->fog.z_near = CLUTTER_FLOAT_TO_FIXED (z_near);
+ priv->fog.z_far = CLUTTER_FLOAT_TO_FIXED (z_far);
if (priv->use_fog && CLUTTER_ACTOR_IS_VISIBLE (stage))
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
res = clutter_backend_get_resolution (context->backend);
- return COGL_FIXED_FROM_FLOAT (res);
+ return CLUTTER_FLOAT_TO_FIXED (res);
}
/*** Perspective boxed type ******/
/* Set the natural width so as to preserve the aspect ratio */
ClutterFixed ratio, height;
- ratio = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (priv->width),
- COGL_FIXED_FROM_INT (priv->height));
+ ratio = CLUTTER_FIXED_DIV ((float)(priv->width),
+ (float)(priv->height));
height = CLUTTER_UNITS_TO_FIXED (for_height);
*natural_width_p =
- CLUTTER_UNITS_FROM_FIXED (COGL_FIXED_MUL (ratio, height));
+ CLUTTER_UNITS_FROM_FIXED (CLUTTER_FIXED_MUL (ratio, height));
}
}
}
/* Set the natural height so as to preserve the aspect ratio */
ClutterFixed ratio, width;
- ratio = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (priv->height),
- COGL_FIXED_FROM_INT (priv->width));
+ ratio = CLUTTER_FIXED_DIV ((float)(priv->height),
+ (float)(priv->width));
width = CLUTTER_UNITS_TO_FIXED (for_width);
*natural_height_p =
- CLUTTER_UNITS_FROM_FIXED (COGL_FIXED_MUL (ratio, width));
+ CLUTTER_UNITS_FROM_FIXED (CLUTTER_FIXED_MUL (ratio, width));
}
}
}
/* Convert the coordinates back to [-1,1] range */
cogl_get_viewport (viewport);
- tx_min = COGL_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (x_min), viewport[2])
- * 2 - COGL_FIXED_1;
- tx_max = COGL_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (x_max), viewport[2])
- * 2 - COGL_FIXED_1;
- ty_min = COGL_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (y_min), viewport[3])
- * 2 - COGL_FIXED_1;
- ty_max = COGL_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (y_max), viewport[3])
- * 2 - COGL_FIXED_1;
+ tx_min = CLUTTER_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (x_min), viewport[2])
+ * 2 - 1.0;
+ tx_max = CLUTTER_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (x_max), viewport[2])
+ * 2 - 1.0;
+ ty_min = CLUTTER_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (y_min), viewport[3])
+ * 2 - 1.0;
+ ty_max = CLUTTER_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (y_max), viewport[3])
+ * 2 - 1.0;
/* Set up a projection matrix so that the actor will be projected as
if it was drawn at its original location */
- tan_angle = cogl_angle_tan (COGL_ANGLE_FROM_DEGX (perspective.fovy / 2));
- near_size = COGL_FIXED_MUL (perspective.z_near, tan_angle);
+ tan_angle = tanf (COGL_ANGLE_FROM_DEGX (perspective.fovy / 2 * (G_PI/180.0)));
+ near_size = CLUTTER_FIXED_MUL (perspective.z_near, tan_angle);
- cogl_frustum (COGL_FIXED_MUL (tx_min, near_size),
- COGL_FIXED_MUL (tx_max, near_size),
- COGL_FIXED_MUL (-ty_min, near_size),
- COGL_FIXED_MUL (-ty_max, near_size),
+ cogl_frustum (CLUTTER_FIXED_MUL (tx_min, near_size),
+ CLUTTER_FIXED_MUL (tx_max, near_size),
+ CLUTTER_FIXED_MUL (-ty_min, near_size),
+ CLUTTER_FIXED_MUL (-ty_max, near_size),
perspective.z_near, perspective.z_far);
}
clutter_actor_get_opacity (self));
if (priv->repeat_x && priv->width > 0)
- t_w = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (x_2 - x_1),
- COGL_FIXED_FROM_INT (priv->width));
+ t_w = CLUTTER_FIXED_DIV ((float)(x_2 - x_1),
+ (float)(priv->width));
else
- t_w = COGL_FIXED_1;
+ t_w = 1.0;
if (priv->repeat_y && priv->height > 0)
- t_h = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (y_2 - y_1),
- COGL_FIXED_FROM_INT (priv->height));
+ t_h = CLUTTER_FIXED_DIV ((float)(y_2 - y_1),
+ (float)(priv->height));
else
- t_h = COGL_FIXED_1;
+ t_h = 1.0;
/* Paint will have translated us */
cogl_texture_rectangle (priv->texture, 0, 0,
- COGL_FIXED_FROM_INT (x_2 - x_1),
- COGL_FIXED_FROM_INT (y_2 - y_1),
+ (float)(x_2 - x_1),
+ (float)(y_2 - y_1),
0, 0, t_w, t_h);
}
{
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));
}
/**
priv = timeline->priv;
- progress = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (priv->current_frame_num),
- COGL_FIXED_FROM_INT (priv->n_frames));
+ progress = CLUTTER_FIXED_DIV ((float)(priv->current_frame_num),
+ (float)(priv->n_frames));
if (priv->direction == CLUTTER_TIMELINE_BACKWARD)
- progress = COGL_FIXED_1 - progress;
+ progress = 1.0 - progress;
return progress;
}
* 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) ( ((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)
/**
* cogl_color_set_from_4x:
* @dest: return location for a #CoglColor
- * @red: value of the red channel, between 0 and %COGL_FIXED_1
- * @green: value of the green channel, between 0 and %COGL_FIXED_1
- * @blue: value of the blue channel, between 0 and %COGL_FIXED_1
- * @alpha: value of the alpha 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 %1.0
+ * @blue: value of the blue channel, between 0 and %1.0
+ * @alpha: value of the alpha channel, between 0 and %1.0
*
* Sets the values of the passed channels into a #CoglColor
*
* Since: 1.0
*/
void cogl_color_set_from_4x (CoglColor *dest,
- CoglFixed red,
- CoglFixed green,
- CoglFixed blue,
- CoglFixed alpha);
+ float red,
+ float green,
+ float blue,
+ float alpha);
/**
* cogl_color_get_red_byte:
* @color: a #CoglColor
*
* 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
*
* Since: 1.0
*/
-CoglFixed cogl_color_get_red (const CoglColor *color);
+float cogl_color_get_red (const CoglColor *color);
/**
* cogl_color_get_green:
* @color: a #CoglColor
*
* 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
*
* Since: 1.0
*/
-CoglFixed cogl_color_get_green (const CoglColor *color);
+float cogl_color_get_green (const CoglColor *color);
/**
* cogl_color_get_blue:
* @color: a #CoglColor
*
* 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
*
* Since: 1.0
*/
-CoglFixed cogl_color_get_blue (const CoglColor *color);
+float cogl_color_get_blue (const CoglColor *color);
/**
* cogl_color_get_alpha:
* @color: a #CoglColor
*
* 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
*
* 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_color4x:
- * @red: value of the red channel, between 0 and %COGL_FIXED_1
- * @green: value of the green channel, between 0 and %COGL_FIXED_1
- * @blue: value of the blue channel, between 0 and %COGL_FIXED_1
- * @alpha: value of the alpha 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 %1.0
+ * @blue: value of the blue channel, between 0 and %1.0
+ * @alpha: value of the alpha channel, between 0 and %1.0
*
* Sets the source color using normalized values for each component.
* This color will be used for any subsequent drawing operation.
*
* 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.
*
* Since: 1.0
*/
-void cogl_set_source_color4x (CoglFixed red,
- CoglFixed green,
- CoglFixed blue,
- CoglFixed alpha);
+void cogl_set_source_color4x (float red,
+ float green,
+ float blue,
+ float alpha);
G_END_DECLS
*
* A fixed-point version of cogl_fast_fill_rectangle.
**/
-void cogl_rectanglex (CoglFixed x,
- CoglFixed y,
- CoglFixed width,
- CoglFixed height);
+void cogl_rectanglex (float x,
+ float y,
+ float width,
+ float height);
/**
* cogl_path_fill:
* Moves the pen to the given location. If there is an existing path
* this will start a new disjoint subpath.
**/
-void cogl_path_move_to (CoglFixed x,
- CoglFixed y);
+void cogl_path_move_to (float x,
+ float y);
/**
* location. If there is an existing path this will start a new
* disjoint subpath.
**/
-void cogl_path_rel_move_to (CoglFixed x,
- CoglFixed y);
+void cogl_path_rel_move_to (float x,
+ float y);
/**
* cogl_path_line_to:
* Adds a straight line segment to the current path that ends at the
* given coordinates.
**/
-void cogl_path_line_to (CoglFixed x,
- CoglFixed y);
+void cogl_path_line_to (float x,
+ float y);
/**
* cogl_path_rel_line_to:
* Adds a straight line segment to the current path that ends at the
* given coordinates relative to the current pen location.
**/
-void cogl_path_rel_line_to (CoglFixed x,
- CoglFixed y);
+void cogl_path_rel_line_to (float x,
+ float y);
/**
* of the arc. If you perform a move_to to the arcs start just before
* drawing it you create a free standing arc.
**/
-void cogl_path_arc (CoglFixed center_x,
- CoglFixed center_y,
- CoglFixed radius_x,
- CoglFixed radius_y,
- CoglAngle angle_1,
- CoglAngle angle_2);
+void cogl_path_arc (float center_x,
+ float center_y,
+ float radius_x,
+ float radius_y,
+ float angle_1,
+ float angle_2);
* second, third and fourth control points and using current pen location
* as the first control point.
**/
-void cogl_path_curve_to (CoglFixed x1,
- CoglFixed y1,
- CoglFixed x2,
- CoglFixed y2,
- CoglFixed x3,
- CoglFixed y3);
+void cogl_path_curve_to (float x1,
+ float y1,
+ float x2,
+ float y2,
+ float x3,
+ float y3);
/**
* cogl_path_rel_curve_to:
* as the first control point. The given coordinates are relative to the
* current pen location.
*/
-void cogl_path_rel_curve_to (CoglFixed x1,
- CoglFixed y1,
- CoglFixed x2,
- CoglFixed y2,
- CoglFixed x3,
- CoglFixed y3);
+void cogl_path_rel_curve_to (float x1,
+ float y1,
+ float x2,
+ float y2,
+ float x3,
+ float y3);
/**
* cogl_path_close:
* coordinates. If there is an existing path this will start a new
* disjoint sub-path.
**/
-void cogl_path_line (CoglFixed x1,
- CoglFixed y1,
- CoglFixed x2,
- CoglFixed y2);
+void cogl_path_line (float x1,
+ float y1,
+ float x2,
+ float y2);
/**
* cogl_path_polyline:
* fashion for the rest of the vertices. (num_points - 1) segments will
* be constructed.
**/
-void cogl_path_polyline (CoglFixed *coords,
+void cogl_path_polyline (float *coords,
gint num_points);
* represents the Y coordinate of the first vertex, continuing in the same
* fashion for the rest of the vertices.
**/
-void cogl_path_polygon (CoglFixed *coords,
+void cogl_path_polygon (float *coords,
gint num_points);
* Constructs a rectangular shape at the given coordinates. If there
* is an existing path this will start a new disjoint sub-path.
**/
-void cogl_path_rectangle (CoglFixed x,
- CoglFixed y,
- CoglFixed width,
- CoglFixed height);
+void cogl_path_rectangle (float x,
+ float y,
+ float width,
+ float height);
/**
* cogl_path_ellipse:
* Constructs an ellipse shape. If there is an existing path this will
* start a new disjoint sub-path.
**/
-void cogl_path_ellipse (CoglFixed center_x,
- CoglFixed center_y,
- CoglFixed radius_x,
- CoglFixed radius_y);
+void cogl_path_ellipse (float center_x,
+ float center_y,
+ float radius_x,
+ float radius_y);
/**
* cogl_path_round_rectangle:
* Constructs a rectangular shape with rounded corners. If there is an
* existing path this will start a new disjoint sub-path.
**/
-void cogl_path_round_rectangle (CoglFixed x,
- CoglFixed y,
- CoglFixed width,
- CoglFixed height,
- CoglFixed radius,
- CoglAngle arc_step);
+void cogl_path_round_rectangle (float x,
+ float y,
+ float width,
+ float height,
+ float radius,
+ float arc_step);
G_END_DECLS
* texture pass in @tx1=0.0 @ty1=0.0 @tx2=1.0 @ty2=1.0.
*/
void cogl_texture_rectangle (CoglHandle handle,
- CoglFixed x1,
- CoglFixed y1,
- CoglFixed x2,
- CoglFixed y2,
- CoglFixed tx1,
- CoglFixed ty1,
- CoglFixed tx2,
- CoglFixed ty2);
+ float x1,
+ float y1,
+ float x2,
+ float y2,
+ float tx1,
+ float ty1,
+ float tx2,
+ float ty2);
/**
* cogl_texture_polygon:
* significant performance boost to use this function rather than
* 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
* parameters x1, y1, x2, y2, tx1, ty1, tx2 and ty2 and have the same
* meaning as in cogl_texture_rectangle().
*/
void cogl_texture_multiple_rectangles
(CoglHandle handle,
- const CoglFixed *verts,
+ const float *verts,
guint n_rects);
G_END_DECLS
*/
struct _CoglTextureVertex
{
- CoglFixed x, y, z;
- CoglFixed tx, ty;
+ float x, y, z;
+ float tx, ty;
CoglColor color;
};
* Replaces the current projection matrix with a perspective matrix
* based on the provided values.
*/
-void cogl_perspective (CoglFixed fovy,
- CoglFixed aspect,
- CoglFixed z_near,
- CoglFixed z_far);
+void cogl_perspective (float fovy,
+ float aspect,
+ float z_near,
+ float z_far);
/**
* cogl_frustum:
*
* Since: 0.8.2
*/
-void cogl_frustum (CoglFixed left,
- CoglFixed right,
- CoglFixed bottom,
- CoglFixed top,
- CoglFixed z_near,
- CoglFixed z_far);
+void cogl_frustum (float left,
+ float right,
+ float bottom,
+ float top,
+ float z_near,
+ float z_far);
/**
* cogl_setup_viewport:
*/
void cogl_setup_viewport (guint width,
guint height,
- CoglFixed fovy,
- CoglFixed aspect,
- CoglFixed z_near,
- CoglFixed z_far);
+ float fovy,
+ float aspect,
+ float z_near,
+ float z_far);
/**
* cogl_viewport:
* Multiplies the current model-view matrix by one that scales the x
* and y axes by the given values.
*/
-void cogl_scale (CoglFixed x,
- CoglFixed y);
+void cogl_scale (float x,
+ float y);
/**
* 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_translatex (CoglFixed x,
- CoglFixed y,
- CoglFixed z);
+void cogl_translatex (float x,
+ float y,
+ float z);
/**
* cogl_translate:
* degrees about the vertex (0, 0, 1) causes a small counter-clockwise
* rotation.
*/
-void cogl_rotatex (CoglFixed angle,
+void cogl_rotatex (float angle,
gint x,
gint y,
gint z);
/**
* 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
* column-major order.
*/
-void cogl_get_modelview_matrix (CoglFixed m[16]);
+void cogl_get_modelview_matrix (float m[16]);
/**
* 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
* column-major order.
*/
-void cogl_get_projection_matrix (CoglFixed m[16]);
+void cogl_get_projection_matrix (float m[16]);
/**
* 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.
*
* Stores the current viewport in @v. @v[0] and @v[1] get the x and y
* position of the viewport and @v[2] and @v[3] get the width and
* height.
*/
-void cogl_get_viewport (CoglFixed v[4]);
+void cogl_get_viewport (float v[4]);
/**
* cogl_clip_set:
* The rectangle is intersected with the current clip region. To undo
* the effect of this function, call cogl_clip_unset().
*/
-void cogl_clip_set (CoglFixed x_offset,
- CoglFixed y_offset,
- CoglFixed width,
- CoglFixed height);
+void cogl_clip_set (float x_offset,
+ float y_offset,
+ float width,
+ float height);
/**
* cogl_clip_set_from_path:
* initial reference value is 1.0.
*/
void cogl_alpha_func (COGLenum func,
- CoglFixed ref);
+ float ref);
/**
* cogl_fog_set:
* cogl_paint_init().
*/
void cogl_fog_set (const CoglColor *fog_color,
- CoglFixed density,
- CoglFixed z_near,
- CoglFixed z_far);
+ float density,
+ float z_near,
+ float z_far);
/**
* cogl_paint_init:
/* These are defined in the particular backend (float in GL vs fixed
in GL ES) */
-void _cogl_set_clip_planes (CoglFixed x,
- CoglFixed y,
- CoglFixed width,
- CoglFixed height);
-void _cogl_add_stencil_clip (CoglFixed x,
- CoglFixed y,
- CoglFixed width,
- CoglFixed height,
+void _cogl_set_clip_planes (float x,
+ float y,
+ float width,
+ float height);
+void _cogl_add_stencil_clip (float x,
+ float y,
+ float width,
+ float height,
gboolean first);
-void _cogl_add_path_to_stencil_buffer (CoglFixedVec2 nodes_min,
- CoglFixedVec2 nodes_max,
+void _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
+ floatVec2 nodes_max,
guint path_size,
CoglPathNode *path,
gboolean merge);
void _cogl_enable_clip_planes (void);
void _cogl_disable_clip_planes (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;
CoglClipStackEntryType type;
/* The rectangle for this clip */
- CoglFixed x_offset;
- CoglFixed y_offset;
- CoglFixed width;
- CoglFixed height;
+ float x_offset;
+ float y_offset;
+ float width;
+ float height;
/* The matrix that was current when the clip was set */
- CoglFixed matrix[16];
+ float matrix[16];
};
struct _CoglClipStackEntryPath
CoglClipStackEntryType type;
/* The matrix that was current when the clip was set */
- CoglFixed matrix[16];
+ float matrix[16];
- CoglFixedVec2 path_nodes_min;
- CoglFixedVec2 path_nodes_max;
+ floatVec2 path_nodes_min;
+ floatVec2 path_nodes_max;
guint path_size;
CoglPathNode path[1];
};
void
-cogl_clip_set (CoglFixed x_offset,
- CoglFixed y_offset,
- CoglFixed width,
- CoglFixed height)
+cogl_clip_set (float x_offset,
+ float y_offset,
+ float width,
+ float height)
{
CoglClipStackEntryRect *entry;
CoglClipStack *stack;
void
cogl_color_set_from_4x (CoglColor *dest,
- CoglFixed red,
- CoglFixed green,
- CoglFixed blue,
- CoglFixed alpha)
+ float red,
+ float green,
+ float blue,
+ float alpha)
{
g_return_if_fail (dest != NULL);
- dest->red = COGL_FIXED_TO_INT (red * 255);
- dest->green = COGL_FIXED_TO_INT (green * 255);
- dest->blue = COGL_FIXED_TO_INT (blue * 255);
- dest->alpha = COGL_FIXED_TO_INT (alpha * 255);
+ dest->red = (red * 255);
+ dest->green = (green * 255);
+ dest->blue = (blue * 255);
+ dest->alpha = (alpha * 255);
}
unsigned char
return (float) color->red / 255.0;
}
-CoglFixed
+float
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
return (float) color->green / 255.0;
}
-CoglFixed
+float
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
return (float) color->blue / 255.0;
}
-CoglFixed
+float
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
return (float) color->alpha / 255.0;
}
-CoglFixed
+float
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
-cogl_set_source_color4x (CoglFixed red,
- CoglFixed green,
- CoglFixed blue,
- CoglFixed alpha)
+cogl_set_source_color4x (float red,
+ float green,
+ float blue,
+ float alpha)
{
CoglColor c = { 0, };
/* these are defined in the particular backend(float in gl vs fixed in gles)*/
void _cogl_path_add_node (gboolean new_sub_path,
- CoglFixed x,
- CoglFixed y);
+ float x,
+ 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 (CoglFixed x,
- CoglFixed y,
- CoglFixed width,
- CoglFixed height);
+void _cogl_rectanglex (float x,
+ float y,
+ float width,
+ float height);
void
cogl_rectangle (gint x,
gint y,
}
void
-cogl_rectanglex (CoglFixed x,
- CoglFixed y,
- CoglFixed width,
- CoglFixed height)
+cogl_rectanglex (float x,
+ float y,
+ float width,
+ float height)
{
cogl_clip_ensure ();
}
void
-cogl_path_move_to (CoglFixed x,
- CoglFixed y)
+cogl_path_move_to (float x,
+ float y)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
}
void
-cogl_path_rel_move_to (CoglFixed x,
- CoglFixed y)
+cogl_path_rel_move_to (float x,
+ float y)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
}
void
-cogl_path_line_to (CoglFixed x,
- CoglFixed y)
+cogl_path_line_to (float x,
+ float y)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
}
void
-cogl_path_rel_line_to (CoglFixed x,
- CoglFixed y)
+cogl_path_rel_line_to (float x,
+ float y)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
}
void
-cogl_path_line (CoglFixed x1,
- CoglFixed y1,
- CoglFixed x2,
- CoglFixed y2)
+cogl_path_line (float x1,
+ float y1,
+ float x2,
+ float y2)
{
cogl_path_move_to (x1, y1);
cogl_path_line_to (x2, y2);
}
void
-cogl_path_polyline (CoglFixed *coords,
+cogl_path_polyline (float *coords,
gint num_points)
{
gint c = 0;
}
void
-cogl_path_polygon (CoglFixed *coords,
+cogl_path_polygon (float *coords,
gint num_points)
{
cogl_path_polyline (coords, num_points);
}
void
-cogl_path_rectangle (CoglFixed x,
- CoglFixed y,
- CoglFixed width,
- CoglFixed height)
+cogl_path_rectangle (float x,
+ float y,
+ float width,
+ float height)
{
cogl_path_move_to (x, y);
cogl_path_line_to (x + width, y);
}
static void
-_cogl_path_arc (CoglFixed center_x,
- CoglFixed center_y,
- CoglFixed radius_x,
- CoglFixed radius_y,
- CoglAngle angle_1,
- CoglAngle angle_2,
- CoglAngle angle_step,
+_cogl_path_arc (float center_x,
+ float center_y,
+ float radius_x,
+ float radius_y,
+ float angle_1,
+ float angle_2,
+ float angle_step,
guint move_first)
{
- CoglAngle a = 0x0;
- CoglFixed cosa = 0x0;
- CoglFixed sina = 0x0;
- CoglFixed px = 0x0;
- CoglFixed py = 0x0;
+ float a = 0x0;
+ float cosa = 0x0;
+ float sina = 0x0;
+ float px = 0x0;
+ float py = 0x0;
/* Fix invalid angles */
a = angle_1;
while (a != angle_2)
{
- cosa = cogl_angle_cos (a);
- sina = cogl_angle_sin (a);
+ cosa = cosf (a * (G_PI/180.0));
+ sina = sinf (a * (G_PI/180.0));
- px = center_x + COGL_FIXED_MUL (cosa, radius_x);
- py = center_y + COGL_FIXED_MUL (sina, radius_y);
+ px = center_x + (cosa * radius_x);
+ py = center_y + (sina * radius_y);
if (a == angle_1 && move_first)
cogl_path_move_to (px, py);
/* Make sure the final point is drawn */
- cosa = cogl_angle_cos (angle_2);
- sina = cogl_angle_sin (angle_2);
+ cosa = cosf (angle_2 * (G_PI/180.0));
+ sina = sinf (angle_2 * (G_PI/180.0));
- px = center_x + COGL_FIXED_MUL (cosa, radius_x);
- py = center_y + COGL_FIXED_MUL (sina, radius_y);
+ px = center_x + (cosa * radius_x);
+ py = center_y + (sina * radius_y);
cogl_path_line_to (px, py);
}
void
-cogl_path_arc (CoglFixed center_x,
- CoglFixed center_y,
- CoglFixed radius_x,
- CoglFixed radius_y,
- CoglAngle angle_1,
- CoglAngle angle_2)
+cogl_path_arc (float center_x,
+ float center_y,
+ float radius_x,
+ float radius_y,
+ float angle_1,
+ float angle_2)
{
- CoglAngle angle_step = 10;
+ float angle_step = 10;
/* it is documented that a move to is needed to create a freestanding
* arc
*/
void
-cogl_path_arc_rel (CoglFixed center_x,
- CoglFixed center_y,
- CoglFixed radius_x,
- CoglFixed radius_y,
- CoglAngle angle_1,
- CoglAngle angle_2,
- CoglAngle angle_step)
+cogl_path_arc_rel (float center_x,
+ float center_y,
+ float radius_x,
+ float radius_y,
+ float angle_1,
+ float angle_2,
+ float angle_step)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
}
void
-cogl_path_ellipse (CoglFixed center_x,
- CoglFixed center_y,
- CoglFixed radius_x,
- CoglFixed radius_y)
+cogl_path_ellipse (float center_x,
+ float center_y,
+ float radius_x,
+ float radius_y)
{
- CoglAngle angle_step = 10;
+ float angle_step = 10;
/* FIXME: if shows to be slow might be optimized
* by mirroring just a quarter of it */
_cogl_path_arc (center_x, center_y,
radius_x, radius_y,
- 0, COGL_ANGLE_FROM_DEG (360),
+ 0, 360,
angle_step, 1 /* move first */);
cogl_path_close();
}
void
-cogl_path_round_rectangle (CoglFixed x,
- CoglFixed y,
- CoglFixed width,
- CoglFixed height,
- CoglFixed radius,
- CoglAngle arc_step)
+cogl_path_round_rectangle (float x,
+ float y,
+ float width,
+ float height,
+ float radius,
+ float arc_step)
{
- CoglFixed inner_width = width - (radius << 1);
- CoglFixed inner_height = height - (radius << 1);
+ float inner_width = width - (radius * 2);
+ float inner_height = height - (radius * 2);
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
cogl_path_move_to (x, y + radius);
cogl_path_arc_rel (radius, 0,
radius, radius,
- COGL_ANGLE_FROM_DEG (180),
- COGL_ANGLE_FROM_DEG (270),
+ 180,
+ 270,
arc_step);
cogl_path_line_to (ctx->path_pen.x + inner_width,
ctx->path_pen.y);
cogl_path_arc_rel (0, radius,
radius, radius,
- COGL_ANGLE_FROM_DEG (-90),
- COGL_ANGLE_FROM_DEG (0),
+ -90,
+ 0,
arc_step);
cogl_path_line_to (ctx->path_pen.x,
cogl_path_arc_rel (-radius, 0,
radius, radius,
- COGL_ANGLE_FROM_DEG (0),
- COGL_ANGLE_FROM_DEG (90),
+ 0,
+ 90,
arc_step);
cogl_path_line_to (ctx->path_pen.x - inner_width,
ctx->path_pen.y);
cogl_path_arc_rel (0, -radius,
radius, radius,
- COGL_ANGLE_FROM_DEG (90),
- COGL_ANGLE_FROM_DEG (180),
+ 90,
+ 180,
arc_step);
cogl_path_close ();
CoglBezCubic *cleft;
CoglBezCubic *cright;
CoglBezCubic *c;
- CoglFixedVec2 dif1;
- CoglFixedVec2 dif2;
- CoglFixedVec2 mm;
- CoglFixedVec2 c1;
- CoglFixedVec2 c2;
- CoglFixedVec2 c3;
- CoglFixedVec2 c4;
- CoglFixedVec2 c5;
+ floatVec2 dif1;
+ floatVec2 dif2;
+ floatVec2 mm;
+ floatVec2 c1;
+ floatVec2 c2;
+ floatVec2 c3;
+ floatVec2 c4;
+ floatVec2 c5;
gint cindex;
/* Put first curve on stack */
{
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
* counterparts on the line between end points */
- dif1.x = CFX_MUL3 (c->p2.x) - CFX_MUL2 (c->p1.x) - c->p4.x;
- dif1.y = CFX_MUL3 (c->p2.y) - CFX_MUL2 (c->p1.y) - c->p4.y;
- dif2.x = CFX_MUL3 (c->p3.x) - CFX_MUL2 (c->p4.x) - c->p1.x;
- dif2.y = CFX_MUL3 (c->p3.y) - CFX_MUL2 (c->p4.y) - c->p1.y;
+ dif1.x = (c->p2.x * 3) - (c->p1.x * 2) - c->p4.x;
+ dif1.y = (c->p2.y * 3) - (c->p1.y * 2) - c->p4.y;
+ dif2.x = (c->p3.x * 3) - (c->p4.x * 2) - c->p1.x;
+ dif2.y = (c->p3.y * 3) - (c->p4.y * 2) - c->p1.y;
if (dif1.x < 0)
dif1.x = -dif1.x;
if (dif2.y < 0)
dif2.y = -dif2.y;
-#undef CFX_MUL2
-#undef CFX_MUL3
-#undef CFX_SQ
/* Pick the greatest of two distances */
if (dif1.x < dif2.x) dif1.x = dif2.x;
if (dif1.y < dif2.y) dif1.y = dif2.y;
/* 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)
{
/* Add subdivision point (skip last) */
cright = c; cleft = &cubics[++cindex];
/* Subdivide into 2 sub-curves */
- c1.x = ((c->p1.x + c->p2.x) >> 1);
- c1.y = ((c->p1.y + c->p2.y) >> 1);
- mm.x = ((c->p2.x + c->p3.x) >> 1);
- mm.y = ((c->p2.y + c->p3.y) >> 1);
- c5.x = ((c->p3.x + c->p4.x) >> 1);
- c5.y = ((c->p3.y + c->p4.y) >> 1);
+ c1.x = ((c->p1.x + c->p2.x) / 2);
+ c1.y = ((c->p1.y + c->p2.y) / 2);
+ mm.x = ((c->p2.x + c->p3.x) / 2);
+ mm.y = ((c->p2.y + c->p3.y) / 2);
+ c5.x = ((c->p3.x + c->p4.x) / 2);
+ c5.y = ((c->p3.y + c->p4.y) / 2);
- c2.x = ((c1.x + mm.x) >> 1);
- c2.y = ((c1.y + mm.y) >> 1);
- c4.x = ((mm.x + c5.x) >> 1);
- c4.y = ((mm.y + c5.y) >> 1);
+ c2.x = ((c1.x + mm.x) / 2);
+ c2.y = ((c1.y + mm.y) / 2);
+ c4.x = ((mm.x + c5.x) / 2);
+ c4.y = ((mm.y + c5.y) / 2);
- c3.x = ((c2.x + c4.x) >> 1);
- c3.y = ((c2.y + c4.y) >> 1);
+ c3.x = ((c2.x + c4.x) / 2);
+ c3.y = ((c2.y + c4.y) / 2);
/* Add left recursion to stack */
cleft->p1 = c->p1;
}
void
-cogl_path_curve_to (CoglFixed x1,
- CoglFixed y1,
- CoglFixed x2,
- CoglFixed y2,
- CoglFixed x3,
- CoglFixed y3)
+cogl_path_curve_to (float x1,
+ float y1,
+ float x2,
+ float y2,
+ float x3,
+ float y3)
{
CoglBezCubic cubic;
}
void
-cogl_path_rel_curve_to (CoglFixed x1,
- CoglFixed y1,
- CoglFixed x2,
- CoglFixed y2,
- CoglFixed x3,
- CoglFixed y3)
+cogl_path_rel_curve_to (float x1,
+ float y1,
+ float x2,
+ float y2,
+ float x3,
+ float y3)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
CoglBezQuad *qleft;
CoglBezQuad *qright;
CoglBezQuad *q;
- CoglFixedVec2 mid;
- CoglFixedVec2 dif;
- CoglFixedVec2 c1;
- CoglFixedVec2 c2;
- CoglFixedVec2 c3;
+ floatVec2 mid;
+ floatVec2 dif;
+ floatVec2 c1;
+ floatVec2 c2;
+ floatVec2 c3;
gint qindex;
/* Put first curve on stack */
/* Calculate distance of control point from its
* counterpart on the line between end points */
- mid.x = ((q->p1.x + q->p3.x) >> 1);
- mid.y = ((q->p1.y + q->p3.y) >> 1);
+ mid.x = ((q->p1.x + q->p3.x) / 2);
+ mid.y = ((q->p1.y + q->p3.y) / 2);
dif.x = (q->p2.x - mid.x);
dif.y = (q->p2.y - mid.y);
if (dif.x < 0) dif.x = -dif.x;
if (dif.y < 0) dif.y = -dif.y;
/* 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)
{
/* Add subdivision point (skip last) */
qright = q; qleft = &quads[++qindex];
/* Subdivide into 2 sub-curves */
- c1.x = ((q->p1.x + q->p2.x) >> 1);
- c1.y = ((q->p1.y + q->p2.y) >> 1);
- c3.x = ((q->p2.x + q->p3.x) >> 1);
- c3.y = ((q->p2.y + q->p3.y) >> 1);
- c2.x = ((c1.x + c3.x) >> 1);
- c2.y = ((c1.y + c3.y) >> 1);
+ c1.x = ((q->p1.x + q->p2.x) / 2);
+ c1.y = ((q->p1.y + q->p2.y) / 2);
+ c3.x = ((q->p2.x + q->p3.x) / 2);
+ c3.y = ((q->p2.y + q->p3.y) / 2);
+ c2.x = ((c1.x + c3.x) / 2);
+ c2.y = ((c1.y + c3.y) / 2);
/* Add left recursion onto stack */
qleft->p1 = q->p1;
}
void
-cogl_path_curve2_to (CoglFixed x1,
- CoglFixed y1,
- CoglFixed x2,
- CoglFixed y2)
+cogl_path_curve2_to (float x1,
+ float y1,
+ float x2,
+ float y2)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
}
void
-cogl_rel_curve2_to (CoglFixed x1,
- CoglFixed y1,
- CoglFixed x2,
- CoglFixed y2)
+cogl_rel_curve2_to (float x1,
+ float y1,
+ float x2,
+ float y2)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
#ifndef __COGL_PRIMITIVES_H
#define __COGL_PRIMITIVES_H
-typedef struct _CoglFixedVec2 CoglFixedVec2;
+typedef struct _floatVec2 floatVec2;
typedef struct _CoglBezQuad CoglBezQuad;
typedef struct _CoglBezCubic CoglBezCubic;
typedef struct _CoglPathNode CoglPathNode;
-struct _CoglFixedVec2
+struct _floatVec2
{
- CoglFixed x;
- CoglFixed y;
+ float x;
+ float y;
};
#ifdef CLUTTER_COGL_HAS_GL
struct _CoglBezQuad
{
- CoglFixedVec2 p1;
- CoglFixedVec2 p2;
- CoglFixedVec2 p3;
+ floatVec2 p1;
+ floatVec2 p2;
+ floatVec2 p3;
};
struct _CoglBezCubic
{
- CoglFixedVec2 p1;
- CoglFixedVec2 p2;
- CoglFixedVec2 p3;
- CoglFixedVec2 p4;
+ floatVec2 p1;
+ floatVec2 p2;
+ floatVec2 p3;
+ floatVec2 p4;
};
#endif /* __COGL_PRIMITIVES_H */
gboolean enable_backface_culling;
/* Primitives */
- CoglFixedVec2 path_start;
- CoglFixedVec2 path_pen;
+ floatVec2 path_start;
+ floatVec2 path_pen;
GArray *path_nodes;
guint last_path;
- CoglFixedVec2 path_nodes_min;
- CoglFixedVec2 path_nodes_max;
+ floatVec2 path_nodes_min;
+ floatVec2 path_nodes_max;
/* Cache of inverse projection matrix */
GLfloat inverse_projection[16];
void
-_cogl_rectanglex (CoglFixed x,
- CoglFixed y,
- CoglFixed width,
- CoglFixed height)
+_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 (COGL_FIXED_TO_FLOAT (x),
- COGL_FIXED_TO_FLOAT (y),
- COGL_FIXED_TO_FLOAT (x + width),
- COGL_FIXED_TO_FLOAT (y + height)) );
+ GE( glRectf ( (x),
+ (y),
+ (x + width),
+ (y + height)) );
}
void
_cogl_path_add_node (gboolean new_sub_path,
- CoglFixed x,
- CoglFixed y)
+ float x,
+ float y)
{
CoglPathNode new_node;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
- new_node.x = COGL_FIXED_TO_FLOAT (x);
- new_node.y = COGL_FIXED_TO_FLOAT (y);
+ new_node.x = (x);
+ new_node.y = (y);
new_node.path_size = 0;
if (new_sub_path || ctx->path_nodes->len == 0)
}
static void
-_cogl_path_get_bounds (CoglFixedVec2 nodes_min,
- CoglFixedVec2 nodes_max,
+_cogl_path_get_bounds (floatVec2 nodes_min,
+ floatVec2 nodes_max,
gint *bounds_x,
gint *bounds_y,
guint *bounds_w,
guint *bounds_h)
{
- *bounds_x = COGL_FIXED_FLOOR (nodes_min.x);
- *bounds_y = COGL_FIXED_FLOOR (nodes_min.y);
- *bounds_w = COGL_FIXED_CEIL (nodes_max.x
- - COGL_FIXED_FROM_INT (*bounds_x));
- *bounds_h = COGL_FIXED_CEIL (nodes_max.y
- - COGL_FIXED_FROM_INT (*bounds_y));
+ *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));
}
void
-_cogl_add_path_to_stencil_buffer (CoglFixedVec2 nodes_min,
- CoglFixedVec2 nodes_max,
+_cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
+ floatVec2 nodes_max,
guint path_size,
CoglPathNode *path,
gboolean merge)
gint index;
GArray *array;
CoglTexSliceSpan *span;
- CoglFixed pos;
- CoglFixed next_pos;
- CoglFixed origin;
- CoglFixed cover_start;
- CoglFixed cover_end;
- CoglFixed intersect_start;
- CoglFixed intersect_end;
- CoglFixed intersect_start_local;
- CoglFixed intersect_end_local;
+ float pos;
+ float next_pos;
+ float origin;
+ float cover_start;
+ float cover_end;
+ float intersect_start;
+ float intersect_end;
+ float intersect_start_local;
+ float intersect_end_local;
gboolean intersects;
};
/* Offset next position by span size */
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 */
if (iter->next_pos <= iter->cover_start ||
static void
_cogl_span_iter_begin (CoglSpanIter *iter,
GArray *array,
- CoglFixed origin,
- CoglFixed cover_start,
- CoglFixed cover_end)
+ float origin,
+ float cover_start,
+ float cover_end)
{
/* Copy info */
iter->index = 0;
/* Iterate vertical spans */
for (source_y = src_y,
_cogl_span_iter_begin (&y_iter, tex->slice_y_spans,
- 0, COGL_FIXED_FROM_INT (dst_y),
- COGL_FIXED_FROM_INT (dst_y + height));
+ 0, (float)(dst_y),
+ (float)(dst_y + height));
!_cogl_span_iter_end (&y_iter);
/* Iterate horizontal spans */
for (source_x = src_x,
_cogl_span_iter_begin (&x_iter, tex->slice_x_spans,
- 0, COGL_FIXED_FROM_INT (dst_x),
- COGL_FIXED_FROM_INT (dst_x + width));
+ 0, (float)(dst_x),
+ (float)(dst_x + width));
!_cogl_span_iter_end (&x_iter);
x_iter.index);
/* 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);
- inter_h = COGL_FIXED_TO_INT (y_iter.intersect_end -
+ inter_h = (y_iter.intersect_end -
y_iter.intersect_start);
/* 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);
- local_y = COGL_FIXED_TO_INT (y_iter.intersect_start -
+ local_y = (y_iter.intersect_start -
y_iter.pos);
/* Pick slice GL handle */
guint wx, wy;
src = source_bmp->data
- + (src_y + COGL_FIXED_TO_INT (y_iter.intersect_start)
+ + (src_y + (y_iter.intersect_start)
- dst_y)
* source_bmp->rowstride
+ (src_x + x_span->start + x_span->size - x_span->waste
guint copy_width;
src = source_bmp->data
- + (src_x + COGL_FIXED_TO_INT (x_iter.intersect_start)
+ + (src_x + (x_iter.intersect_start)
- dst_x)
* bpp
+ (src_y + y_span->start + y_span->size - y_span->waste
static void
_cogl_texture_quad_sw (CoglTexture *tex,
- CoglFixed x1,
- CoglFixed y1,
- CoglFixed x2,
- CoglFixed y2,
- CoglFixed tx1,
- CoglFixed ty1,
- CoglFixed tx2,
- CoglFixed ty2)
+ float x1,
+ float y1,
+ float x2,
+ float y2,
+ float tx1,
+ float ty1,
+ float tx2,
+ float ty2)
{
CoglSpanIter iter_x , iter_y;
- CoglFixed tw , th;
- CoglFixed tqx , tqy;
- CoglFixed first_tx , first_ty;
- CoglFixed first_qx , first_qy;
- CoglFixed slice_tx1 , slice_ty1;
- CoglFixed slice_tx2 , slice_ty2;
- CoglFixed slice_qx1 , slice_qy1;
- CoglFixed slice_qx2 , slice_qy2;
+ float tw , th;
+ float tqx , tqy;
+ float first_tx , first_ty;
+ float first_qx , first_qy;
+ float slice_tx1 , slice_ty1;
+ float slice_tx2 , slice_ty2;
+ float slice_qx1 , slice_qy1;
+ float slice_qx2 , slice_qy2;
GLuint gl_handle;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
slices */
if (tx2 < tx1)
{
- CoglFixed temp = x1;
+ float temp = x1;
x1 = x2;
x2 = temp;
temp = tx1;
}
if (ty2 < ty1)
{
- CoglFixed temp = y1;
+ float temp = y1;
y1 = y2;
y2 = temp;
temp = ty1;
}
/* Scale ratio from texture to quad widths */
- tw = COGL_FIXED_FROM_INT (tex->bitmap.width);
- th = COGL_FIXED_FROM_INT (tex->bitmap.height);
+ tw = (float)(tex->bitmap.width);
+ th = (float)(tex->bitmap.height);
- tqx = COGL_FIXED_DIV (x2 - x1, COGL_FIXED_MUL (tw, (tx2 - tx1)));
- tqy = COGL_FIXED_DIV (y2 - y1, COGL_FIXED_MUL (th, (ty2 - ty1)));
+ tqx = (x2 - x1 / (tw * (tx2 - tx1)));
+ tqy = (y2 - y1 / (th * (ty2 - ty1)));
/* Integral texture coordinate for first tile */
- first_tx = COGL_FIXED_FROM_INT (COGL_FIXED_FLOOR (tx1));
- first_ty = COGL_FIXED_FROM_INT (COGL_FIXED_FLOOR (ty1));
+ first_tx = (float)(floorf (tx1));
+ first_ty = (float)(floorf (ty1));
/* Denormalize texture coordinates */
- first_tx = COGL_FIXED_MUL (first_tx, tw);
- first_ty = COGL_FIXED_MUL (first_ty, th);
- tx1 = COGL_FIXED_MUL (tx1, tw);
- ty1 = COGL_FIXED_MUL (ty1, th);
- tx2 = COGL_FIXED_MUL (tx2, tw);
- ty2 = COGL_FIXED_MUL (ty2, th);
+ first_tx = (first_tx * tw);
+ first_ty = (first_ty * th);
+ tx1 = (tx1 * tw);
+ ty1 = (ty1 * th);
+ tx2 = (tx2 * tw);
+ ty2 = (ty2 * th);
/* Quad coordinate of the first tile */
- first_qx = x1 - COGL_FIXED_MUL (tx1 - first_tx, tqx);
- first_qy = y1 - COGL_FIXED_MUL (ty1 - first_ty, tqy);
+ first_qx = x1 - (tx1 - first_tx * tqx);
+ first_qy = y1 - (ty1 - first_ty * tqy);
/* Iterate until whole quad height covered */
/* Span-quad intersection in quad coordinates */
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 +
- COGL_FIXED_MUL (iter_y.intersect_end - first_ty, tqy);
+ (iter_y.intersect_end - first_ty * tqy);
/* Localize slice texture coordinates */
slice_ty1 = iter_y.intersect_start - iter_y.pos;
/* Span-quad intersection in quad coordinates */
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 +
- COGL_FIXED_MUL (iter_x.intersect_end - first_tx, tqx);
+ (iter_x.intersect_end - first_tx * tqx);
/* Localize slice texture coordinates */
slice_tx1 = iter_x.intersect_start - iter_x.pos;
#if COGL_DEBUG
printf("~~~~~ slice (%d,%d)\n", iter_x.index, iter_y.index);
- printf("qx1: %f\n", COGL_FIXED_TO_FLOAT (slice_qx1));
- printf("qy1: %f\n", COGL_FIXED_TO_FLOAT (slice_qy1));
- printf("qx2: %f\n", COGL_FIXED_TO_FLOAT (slice_qx2));
- printf("qy2: %f\n", COGL_FIXED_TO_FLOAT (slice_qy2));
- printf("tx1: %f\n", COGL_FIXED_TO_FLOAT (slice_tx1));
- printf("ty1: %f\n", COGL_FIXED_TO_FLOAT (slice_ty1));
- printf("tx2: %f\n", COGL_FIXED_TO_FLOAT (slice_tx2));
- printf("ty2: %f\n", COGL_FIXED_TO_FLOAT (slice_ty2));
+ printf("qx1: %f\n", (slice_qx1));
+ printf("qy1: %f\n", (slice_qy1));
+ printf("qx2: %f\n", (slice_qx2));
+ printf("qy2: %f\n", (slice_qy2));
+ printf("tx1: %f\n", (slice_tx1));
+ printf("ty1: %f\n", (slice_ty1));
+ printf("tx2: %f\n", (slice_tx2));
+ printf("ty2: %f\n", (slice_ty2));
#endif
/* Pick and bind opengl texture object */
ctx->texture_target = tex->gl_target;
ctx->texture_current = gl_handle;
- _cogl_texture_add_quad_vertices (COGL_FIXED_TO_FLOAT (slice_qx1),
- COGL_FIXED_TO_FLOAT (slice_qy1),
- COGL_FIXED_TO_FLOAT (slice_qx2),
- COGL_FIXED_TO_FLOAT (slice_qy2),
- COGL_FIXED_TO_FLOAT (slice_tx1),
- COGL_FIXED_TO_FLOAT (slice_ty1),
- COGL_FIXED_TO_FLOAT (slice_tx2),
- COGL_FIXED_TO_FLOAT (slice_ty2));
+ _cogl_texture_add_quad_vertices ( (slice_qx1),
+ (slice_qy1),
+ (slice_qx2),
+ (slice_qy2),
+ (slice_tx1),
+ (slice_ty1),
+ (slice_tx2),
+ (slice_ty2));
}
}
}
static void
_cogl_texture_quad_hw (CoglTexture *tex,
- CoglFixed x1,
- CoglFixed y1,
- CoglFixed x2,
- CoglFixed y2,
- CoglFixed tx1,
- CoglFixed ty1,
- CoglFixed tx2,
- CoglFixed ty2)
+ float x1,
+ float y1,
+ float x2,
+ float y2,
+ float tx1,
+ float ty1,
+ float tx2,
+ float ty2)
{
GLuint gl_handle;
CoglTexSliceSpan *x_span;
/* 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
from the wrong side when scaled */
- if (tx1 >= 0 && tx1 <= COGL_FIXED_1
- && tx2 >= 0 && tx2 <= COGL_FIXED_1
- && ty1 >= 0 && ty1 <= COGL_FIXED_1
- && ty2 >= 0 && ty2 <= COGL_FIXED_1)
+ if (tx1 >= 0 && tx1 <= 1.0
+ && tx2 >= 0 && tx2 <= 1.0
+ && ty1 >= 0 && ty1 <= 1.0
+ && ty2 >= 0 && ty2 <= 1.0)
wrap_mode = GL_CLAMP_TO_EDGE;
else
wrap_mode = GL_REPEAT;
ty2 *= y_span->size;
}
- _cogl_texture_add_quad_vertices (COGL_FIXED_TO_FLOAT (x1),
- COGL_FIXED_TO_FLOAT (y1),
- COGL_FIXED_TO_FLOAT (x2),
- COGL_FIXED_TO_FLOAT (y2),
- COGL_FIXED_TO_FLOAT (tx1),
- COGL_FIXED_TO_FLOAT (ty1),
- COGL_FIXED_TO_FLOAT (tx2),
- COGL_FIXED_TO_FLOAT (ty2));
+ _cogl_texture_add_quad_vertices ( (x1),
+ (y1),
+ (x2),
+ (y2),
+ (tx1),
+ (ty1),
+ (tx2),
+ (ty2));
}
void
cogl_texture_multiple_rectangles (CoglHandle handle,
- const CoglFixed *verts,
+ const float *verts,
guint n_rects)
{
CoglTexture *tex;
if (tex->slice_gl_handles->len == 1
&& ((cogl_features_available (COGL_FEATURE_TEXTURE_NPOT)
&& tex->gl_target == GL_TEXTURE_2D)
- || (verts[4] >= 0 && verts[4] <= COGL_FIXED_1
- && verts[6] >= 0 && verts[6] <= COGL_FIXED_1
- && verts[5] >= 0 && verts[5] <= COGL_FIXED_1
- && verts[7] >= 0 && verts[7] <= COGL_FIXED_1)))
+ || (verts[4] >= 0 && verts[4] <= 1.0
+ && verts[6] >= 0 && verts[6] <= 1.0
+ && verts[5] >= 0 && verts[5] <= 1.0
+ && verts[7] >= 0 && verts[7] <= 1.0)))
_cogl_texture_quad_hw (tex, verts[0],verts[1], verts[2],verts[3],
verts[4],verts[5], verts[6],verts[7]);
else
void
cogl_texture_rectangle (CoglHandle handle,
- CoglFixed x1,
- CoglFixed y1,
- CoglFixed x2,
- CoglFixed y2,
- CoglFixed tx1,
- CoglFixed ty1,
- CoglFixed tx2,
- CoglFixed ty2)
+ float x1,
+ float y1,
+ float x2,
+ float y2,
+ float tx1,
+ float ty1,
+ float tx2,
+ float ty2)
{
- CoglFixed verts[8];
+ float verts[8];
verts[0] = x1;
verts[1] = y1;
OpenGL */
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
- - (COGL_FIXED_FROM_INT (x_span->start)
+ - ((float)(x_span->start)
/ tex->bitmap.width))
* tex->bitmap.width / x_span->size);
ty = ((vertices[i].ty
- - (COGL_FIXED_FROM_INT (y_span->start)
+ - ((float)(y_span->start)
/ tex->bitmap.height))
* tex->bitmap.height / y_span->size);
}
void
-cogl_scale (CoglFixed x, CoglFixed y)
+cogl_scale (float x, float y)
{
- glScaled (COGL_FIXED_TO_DOUBLE (x),
- COGL_FIXED_TO_DOUBLE (y),
+ glScaled ((double)(x),
+ (double)(y),
1.0);
}
void
-cogl_translatex (CoglFixed x, CoglFixed y, CoglFixed z)
+cogl_translatex (float x, float y, float z)
{
- glTranslated (COGL_FIXED_TO_DOUBLE (x),
- COGL_FIXED_TO_DOUBLE (y),
- COGL_FIXED_TO_DOUBLE (z));
+ glTranslated ((double)(x),
+ (double)(y),
+ (double)(z));
}
void
}
void
-cogl_rotatex (CoglFixed angle, gint x, gint y, gint z)
+cogl_rotatex (float 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));
+ glRotated ((double)(angle),
+ (double)(x),
+ (double)(y),
+ (double)(z));
}
void
}
void
-_cogl_set_clip_planes (CoglFixed x_offset,
- CoglFixed y_offset,
- CoglFixed width,
- CoglFixed height)
+_cogl_set_clip_planes (float x_offset,
+ float y_offset,
+ float width,
+ float height)
{
GLfloat modelview[16], projection[16];
- GLfloat vertex_tl[4] = { COGL_FIXED_TO_FLOAT (x_offset),
- COGL_FIXED_TO_FLOAT (y_offset),
+ GLfloat vertex_tl[4] = { (x_offset),
+ (y_offset),
0.0f, 1.0f };
- GLfloat vertex_tr[4] = { COGL_FIXED_TO_FLOAT (x_offset + width),
- COGL_FIXED_TO_FLOAT (y_offset),
+ GLfloat vertex_tr[4] = { (x_offset + width),
+ (y_offset),
0.0f, 1.0f };
- GLfloat vertex_bl[4] = { COGL_FIXED_TO_FLOAT (x_offset),
- COGL_FIXED_TO_FLOAT (y_offset + height),
+ GLfloat vertex_bl[4] = { (x_offset),
+ (y_offset + height),
0.0f, 1.0f };
- GLfloat vertex_br[4] = { COGL_FIXED_TO_FLOAT (x_offset + width),
- COGL_FIXED_TO_FLOAT (y_offset + height),
+ GLfloat vertex_br[4] = { (x_offset + width),
+ (y_offset + height),
0.0f, 1.0f };
GE( glGetFloatv (GL_MODELVIEW_MATRIX, modelview) );
}
void
-_cogl_add_stencil_clip (CoglFixed x_offset,
- CoglFixed y_offset,
- CoglFixed width,
- CoglFixed height,
+_cogl_add_stencil_clip (float x_offset,
+ float y_offset,
+ float width,
+ float height,
gboolean first)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
/* Punch out a hole to allow the rectangle */
GE( glStencilFunc (GL_NEVER, 0x1, 0x1) );
GE( glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE) );
- GE( glRectf (COGL_FIXED_TO_FLOAT (x_offset),
- COGL_FIXED_TO_FLOAT (y_offset),
- COGL_FIXED_TO_FLOAT (x_offset + width),
- COGL_FIXED_TO_FLOAT (y_offset + height)) );
+ GE( glRectf ( (x_offset),
+ (y_offset),
+ (x_offset + width),
+ (y_offset + height)) );
}
else
{
rectangle */
GE( glStencilFunc (GL_NEVER, 0x1, 0x3) );
GE( glStencilOp (GL_INCR, GL_INCR, GL_INCR) );
- GE( glRectf (COGL_FIXED_TO_FLOAT (x_offset),
- COGL_FIXED_TO_FLOAT (y_offset),
- COGL_FIXED_TO_FLOAT (x_offset + width),
- COGL_FIXED_TO_FLOAT (y_offset + height)) );
+ GE( glRectf ( (x_offset),
+ (y_offset),
+ (x_offset + width),
+ (y_offset + height)) );
/* Subtract one from all pixels in the stencil buffer so that
only pixels where both the original stencil buffer and the
}
void
-_cogl_set_matrix (const CoglFixed *matrix)
+_cogl_set_matrix (const float *matrix)
{
float float_matrix[16];
int i;
for (i = 0; i < 16; i++)
- float_matrix[i] = COGL_FIXED_TO_FLOAT (matrix[i]);
+ float_matrix[i] = (matrix[i]);
GE( glLoadIdentity () );
GE( glMultMatrixf (float_matrix) );
void
cogl_alpha_func (COGLenum func,
- CoglFixed ref)
+ float ref)
{
- GE( glAlphaFunc (func, COGL_FIXED_TO_FLOAT(ref)) );
+ GE( glAlphaFunc (func, (ref)) );
}
void
-cogl_perspective (CoglFixed fovy,
- CoglFixed aspect,
- CoglFixed zNear,
- CoglFixed zFar)
+cogl_perspective (float fovy,
+ float aspect,
+ float zNear,
+ float zFar)
{
- CoglFixed xmax, ymax;
- CoglFixed x, y, c, d;
- CoglFixed fovy_rad_half = COGL_FIXED_MUL (fovy, COGL_FIXED_PI) / 360;
+ float xmax, ymax;
+ float x, y, c, d;
+ float fovy_rad_half = (fovy * G_PI) / 360;
GLfloat m[16];
* precision
*/
ymax =
- COGL_FIXED_MUL (zNear,
- COGL_FIXED_FAST_DIV (cogl_fixed_sin (fovy_rad_half),
- cogl_fixed_cos (fovy_rad_half)));
+ (zNear *
+ (sinf (fovy_rad_half) /
+ cosf (fovy_rad_half)));
- xmax = COGL_FIXED_MUL (ymax, aspect);
+ xmax = (ymax * aspect);
- x = COGL_FIXED_FAST_DIV (zNear, xmax);
- y = COGL_FIXED_FAST_DIV (zNear, ymax);
- c = COGL_FIXED_FAST_DIV (-(zFar + zNear), ( zFar - zNear));
+ x = (zNear / xmax);
+ y = (zNear / ymax);
+ c = (-(zFar + zNear) / ( zFar - zNear));
d = cogl_fixed_mul_div (-(2 * zFar), zNear, (zFar - zNear));
#define M(row,col) m[col*4+row]
- M(0,0) = COGL_FIXED_TO_FLOAT (x);
- M(1,1) = COGL_FIXED_TO_FLOAT (y);
- M(2,2) = COGL_FIXED_TO_FLOAT (c);
- M(2,3) = COGL_FIXED_TO_FLOAT (d);
+ M(0,0) = (x);
+ M(1,1) = (y);
+ M(2,2) = (c);
+ M(2,3) = (d);
M(3,2) = -1.0F;
GE( glMultMatrixf (m) );
memset (ctx->inverse_projection, 0, sizeof (GLfloat) * 16);
#define m ctx->inverse_projection
- M(0, 0) = 1.0f / COGL_FIXED_TO_FLOAT (x);
- M(1, 1) = 1.0f / COGL_FIXED_TO_FLOAT (y);
+ M(0, 0) = 1.0f / (x);
+ M(1, 1) = 1.0f / (y);
M(2, 3) = -1.0f;
- M(3, 2) = 1.0f / COGL_FIXED_TO_FLOAT (d);
- M(3, 3) = COGL_FIXED_TO_FLOAT (c) / COGL_FIXED_TO_FLOAT (d);
+ M(3, 2) = 1.0f / (d);
+ M(3, 3) = (c) / (d);
#undef m
#undef M
}
void
-cogl_frustum (CoglFixed left,
- CoglFixed right,
- CoglFixed bottom,
- CoglFixed top,
- CoglFixed z_near,
- CoglFixed z_far)
+cogl_frustum (float left,
+ float right,
+ float bottom,
+ float top,
+ float z_near,
+ float z_far)
{
GLfloat c, d;
GE( glMatrixMode (GL_PROJECTION) );
GE( glLoadIdentity () );
- GE( glFrustum (COGL_FIXED_TO_DOUBLE (left),
- COGL_FIXED_TO_DOUBLE (right),
- COGL_FIXED_TO_DOUBLE (bottom),
- COGL_FIXED_TO_DOUBLE (top),
- COGL_FIXED_TO_DOUBLE (z_near),
- COGL_FIXED_TO_DOUBLE (z_far)) );
+ GE( glFrustum ((double)(left),
+ (double)(right),
+ (double)(bottom),
+ (double)(top),
+ (double)(z_near),
+ (double)(z_far)) );
GE( glMatrixMode (GL_MODELVIEW) );
/* Calculate and store the inverse of the matrix */
memset (ctx->inverse_projection, 0, sizeof (GLfloat) * 16);
- c = -COGL_FIXED_TO_FLOAT (z_far + z_near)
- / COGL_FIXED_TO_FLOAT (z_far - z_near);
- d = -COGL_FIXED_TO_FLOAT (2 * COGL_FIXED_MUL (z_far, z_near))
- / COGL_FIXED_TO_FLOAT (z_far - z_near);
+ c = - (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]
- M(0,0) = COGL_FIXED_TO_FLOAT (right - left)
- / COGL_FIXED_TO_FLOAT (2 * z_near);
- M(0,3) = COGL_FIXED_TO_FLOAT (right + left)
- / COGL_FIXED_TO_FLOAT (2 * z_near);
- M(1,1) = COGL_FIXED_TO_FLOAT (top - bottom)
- / COGL_FIXED_TO_FLOAT (2 * z_near);
- M(1,3) = COGL_FIXED_TO_FLOAT (top + bottom)
- / COGL_FIXED_TO_FLOAT (2 * z_near);
+ M(0,0) = (right - left)
+ / (2 * z_near);
+ M(0,3) = (right + left)
+ / (2 * z_near);
+ M(1,1) = (top - bottom)
+ / (2 * z_near);
+ M(1,3) = (top + bottom)
+ / (2 * z_near);
M(2,3) = -1.0f;
M(3,2) = 1.0f / d;
M(3,3) = c / d;
void
cogl_setup_viewport (guint width,
guint height,
- CoglFixed fovy,
- CoglFixed aspect,
- CoglFixed z_near,
- CoglFixed z_far)
+ float fovy,
+ float aspect,
+ float z_near,
+ float z_far)
{
GLfloat 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_TO_FLOAT (COGL_FIXED_DIV (cogl_fixed_sin (fovy_rad),
- cogl_fixed_cos (fovy_rad)) >> 1);
+ ((sinf (fovy_rad) /
+ cosf (fovy_rad)) >> 1);
}
GE( glTranslatef (-0.5f, -0.5f, -z_camera) );
}
void
-cogl_get_modelview_matrix (CoglFixed m[16])
+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) = 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));
+ 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
}
void
-cogl_get_projection_matrix (CoglFixed m[16])
+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) = 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));
+ 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
}
void
-cogl_get_viewport (CoglFixed v[4])
+cogl_get_viewport (float v[4])
{
GLdouble vd[4];
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]);
+ v[0] = (vd[0]);
+ v[1] = (vd[1]);
+ v[2] = (vd[2]);
+ v[3] = (vd[3]);
}
void
void
cogl_fog_set (const CoglColor *fog_color,
- CoglFixed density,
- CoglFixed start,
- CoglFixed stop)
+ float density,
+ float start,
+ float stop)
{
GLfloat fogColor[4];
glFogi (GL_FOG_MODE, GL_LINEAR);
glHint (GL_FOG_HINT, GL_NICEST);
- glFogf (GL_FOG_DENSITY, COGL_FIXED_TO_FLOAT (density));
- glFogf (GL_FOG_START, COGL_FIXED_TO_FLOAT (start));
- glFogf (GL_FOG_END, COGL_FIXED_TO_FLOAT (stop));
+ glFogf (GL_FOG_DENSITY, (density));
+ glFogf (GL_FOG_START, (start));
+ glFogf (GL_FOG_END, (stop));
}
#endif
/* 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( glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) );
cogl_enable (0);
gboolean enable_backface_culling;
/* Primitives */
- CoglFixedVec2 path_start;
- CoglFixedVec2 path_pen;
+ floatVec2 path_start;
+ floatVec2 path_pen;
GArray *path_nodes;
guint last_path;
- CoglFixedVec2 path_nodes_min;
- CoglFixedVec2 path_nodes_max;
+ floatVec2 path_nodes_min;
+ floatVec2 path_nodes_max;
/* Cache of inverse projection matrix */
- CoglFixed inverse_projection[16];
+ float inverse_projection[16];
/* Textures */
GArray *texture_handles;
/* Setup new viewport and matrices */
GE( glViewport (0, 0, fbo->width, fbo->height) );
- GE( cogl_wrap_glTranslatex (-COGL_FIXED_1, -COGL_FIXED_1, 0) );
- GE( cogl_wrap_glScalex (COGL_FIXED_DIV (COGL_FIXED_FROM_INT (2),
- COGL_FIXED_FROM_INT (fbo->width)),
- COGL_FIXED_DIV (COGL_FIXED_FROM_INT (2),
- COGL_FIXED_FROM_INT (fbo->height)),
- COGL_FIXED_1) );
+ GE( cogl_wrap_glTranslatef (-1.0, -1.0, 0) );
+ GE( cogl_wrap_glScalef (((float)(2) /
+ (float)(fbo->width)),
+ ((float)(2) /
+ (float)(fbo->height)),
+ 1.0) );
/* Bind offscreen framebuffer object */
GE( glBindFramebuffer (GL_FRAMEBUFFER, fbo->gl_handle) );
void
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));
/* Initialize the fogging options */
cogl_wrap_glDisable (GL_FOG);
- cogl_wrap_glFogx (GL_FOG_MODE, GL_LINEAR);
- cogl_wrap_glFogx (GL_FOG_DENSITY, COGL_FIXED_1);
- cogl_wrap_glFogx (GL_FOG_START, 0);
- cogl_wrap_glFogx (GL_FOG_END, 1);
- cogl_wrap_glFogxv (GL_FOG_COLOR, default_fog_color);
+ cogl_wrap_glFogf (GL_FOG_MODE, GL_LINEAR);
+ cogl_wrap_glFogf (GL_FOG_DENSITY, 1.0);
+ cogl_wrap_glFogf (GL_FOG_START, 0);
+ cogl_wrap_glFogf (GL_FOG_END, 1);
+ cogl_wrap_glFogfv (GL_FOG_COLOR, default_fog_color);
/* Initialize alpha testing */
cogl_wrap_glDisable (GL_ALPHA_TEST);
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));
+ glClearColor ( (r),
+ (g),
+ (b),
+ (a));
}
void
}
void
-cogl_wrap_glMultMatrixx (const GLfixed *m)
+cogl_wrap_glMultMatrixf (const GLfloat *m)
{
float new_matrix[16];
int 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);
}
void
-cogl_wrap_glFrustumx (GLfixed left, GLfixed right,
- GLfixed bottom, GLfixed top,
- GLfixed z_near, GLfixed z_far)
+cogl_wrap_glFrustumf (GLfloat left, GLfloat right,
+ GLfloat bottom, GLfloat top,
+ GLfloat z_near, GLfloat z_far)
{
float matrix[16];
- float two_near = COGL_FIXED_TO_FLOAT (2 * z_near);
+ float two_near = (2 * z_near);
memset (matrix, 0, sizeof (matrix));
- matrix[0] = two_near / COGL_FIXED_TO_FLOAT (right - left);
- matrix[5] = two_near / COGL_FIXED_TO_FLOAT (top - bottom);
- matrix[8] = COGL_FIXED_TO_FLOAT (right + left)
- / COGL_FIXED_TO_FLOAT (right - left);
- matrix[9] = COGL_FIXED_TO_FLOAT (top + bottom)
- / COGL_FIXED_TO_FLOAT (top - bottom);
- matrix[10] = -COGL_FIXED_TO_FLOAT (z_far + z_near)
- / COGL_FIXED_TO_FLOAT (z_far - z_near);
+ matrix[0] = two_near / (right - left);
+ matrix[5] = two_near / (top - bottom);
+ matrix[8] = (right + left)
+ / (right - left);
+ matrix[9] = (top + bottom)
+ / (top - bottom);
+ matrix[10] = - (z_far + z_near)
+ / (z_far - z_near);
matrix[11] = -1.0f;
- matrix[14] = -two_near * COGL_FIXED_TO_FLOAT (z_far)
- / COGL_FIXED_TO_FLOAT (z_far - z_near);
+ matrix[14] = -two_near * (z_far)
+ / (z_far - z_near);
cogl_wrap_glMultMatrix (matrix);
}
void
-cogl_wrap_glScalex (GLfixed x, GLfixed y, GLfixed z)
+cogl_wrap_glScalef (GLfloat x, GLfloat y, GLfloat z)
{
float matrix[16];
memset (matrix, 0, sizeof (matrix));
- matrix[0] = COGL_FIXED_TO_FLOAT (x);
- matrix[5] = COGL_FIXED_TO_FLOAT (y);
- matrix[10] = COGL_FIXED_TO_FLOAT (z);
+ matrix[0] = (x);
+ matrix[5] = (y);
+ matrix[10] = (z);
matrix[15] = 1.0f;
cogl_wrap_glMultMatrix (matrix);
}
void
-cogl_wrap_glTranslatex (GLfixed x, GLfixed y, GLfixed z)
+cogl_wrap_glTranslatef (GLfloat x, GLfloat y, GLfloat z)
{
float matrix[16];
matrix[0] = 1.0f;
matrix[5] = 1.0f;
matrix[10] = 1.0f;
- matrix[12] = COGL_FIXED_TO_FLOAT (x);
- matrix[13] = COGL_FIXED_TO_FLOAT (y);
- matrix[14] = COGL_FIXED_TO_FLOAT (z);
+ matrix[12] = (x);
+ matrix[13] = (y);
+ matrix[14] = (z);
matrix[15] = 1.0f;
cogl_wrap_glMultMatrix (matrix);
}
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 xf = COGL_FIXED_TO_FLOAT (x);
- float yf = COGL_FIXED_TO_FLOAT (y);
- float zf = COGL_FIXED_TO_FLOAT (z);
- float anglef = COGL_FIXED_TO_FLOAT (angle) * G_PI / 180.0f;
+ float xf = (x);
+ float yf = (y);
+ float zf = (z);
+ float anglef = (angle) * G_PI / 180.0f;
float c = cosf (anglef);
float s = sinf (anglef);
}
void
-cogl_wrap_glOrthox (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top,
- GLfixed near, GLfixed far)
+cogl_wrap_glOrthof (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
+ GLfloat near, GLfloat far)
{
float matrix[16];
- float xrange = COGL_FIXED_TO_FLOAT (right - left);
- float yrange = COGL_FIXED_TO_FLOAT (top - bottom);
- float zrange = COGL_FIXED_TO_FLOAT (far - near);
+ float xrange = (right - left);
+ float yrange = (top - bottom);
+ float zrange = (far - near);
memset (matrix, 0, sizeof (matrix));
matrix[0] = 2.0f / xrange;
matrix[5] = 2.0f / yrange;
matrix[10] = 2.0f / zrange;
- matrix[12] = COGL_FIXED_TO_FLOAT (right + left) / xrange;
- matrix[13] = COGL_FIXED_TO_FLOAT (top + bottom) / yrange;
- matrix[14] = COGL_FIXED_TO_FLOAT (far + near) / zrange;
+ matrix[12] = (right + left) / xrange;
+ matrix[13] = (top + bottom) / yrange;
+ matrix[14] = (far + near) / zrange;
matrix[15] = 1.0f;
cogl_wrap_glMultMatrix (matrix);
}
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
GL_MODULATE. The shader is hard-coded to modulate the texture so
}
void
-cogl_wrap_glColor4x (GLclampx r, GLclampx g, GLclampx b, GLclampx a)
+cogl_wrap_glColor4f (GLclampx r, GLclampx g, GLclampx b, GLclampx a)
{
glVertexAttrib4f (COGL_GLES2_WRAPPER_COLOR_ATTRIB,
- COGL_FIXED_TO_FLOAT (r),
- COGL_FIXED_TO_FLOAT (g),
- COGL_FIXED_TO_FLOAT (b),
- COGL_FIXED_TO_FLOAT (a));
+ (r),
+ (g),
+ (b),
+ (a));
}
void
-cogl_wrap_glClipPlanex (GLenum plane, GLfixed *equation)
+cogl_wrap_glClipPlanef (GLenum plane, GLfloat *equation)
{
/* FIXME */
}
static void
cogl_gles2_float_array_to_fixed (int size,
const GLfloat *floats,
- GLfixed *fixeds)
+ GLfloat *fixeds)
{
while (size-- > 0)
- *(fixeds++) = COGL_FIXED_FROM_FLOAT (*(floats++));
+ *(fixeds++) = (*(floats++));
}
void
}
void
-cogl_wrap_glGetFixedv (GLenum pname, GLfixed *params)
+cogl_wrap_glGetFixedv (GLenum pname, GLfloat *params)
{
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
}
void
-cogl_wrap_glFogx (GLenum pname, GLfixed param)
+cogl_wrap_glFogf (GLenum pname, GLfloat param)
{
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
case GL_FOG_DENSITY:
_COGL_GLES2_CHANGE_UNIFORM (w, FOG_DENSITY, fog_density,
- COGL_FIXED_TO_FLOAT (param));
+ (param));
break;
case GL_FOG_START:
_COGL_GLES2_CHANGE_UNIFORM (w, FOG_START, fog_start,
- COGL_FIXED_TO_FLOAT (param));
+ (param));
break;
case GL_FOG_END:
_COGL_GLES2_CHANGE_UNIFORM (w, FOG_END, fog_end,
- COGL_FIXED_TO_FLOAT (param));
+ (param));
break;
}
}
void
-cogl_wrap_glFogxv (GLenum pname, const GLfixed *params)
+cogl_wrap_glFogfv (GLenum pname, const GLfloat *params)
{
int i;
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
if (pname == GL_FOG_COLOR)
{
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;
}
void cogl_wrap_glPopMatrix ();
void cogl_wrap_glMatrixMode (GLenum mode);
void cogl_wrap_glLoadIdentity ();
-void cogl_wrap_glMultMatrixx (const GLfixed *m);
-void cogl_wrap_glFrustumx (GLfixed left, GLfixed right,
- GLfixed bottom, GLfixed top,
- GLfixed z_near, GLfixed z_far);
-void cogl_wrap_glScalex (GLfixed x, GLfixed y, GLfixed z);
-void cogl_wrap_glTranslatex (GLfixed x, GLfixed y, GLfixed z);
-void cogl_wrap_glRotatex (GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
-void cogl_wrap_glOrthox (GLfixed left, GLfixed right,
- GLfixed bottom, GLfixed top,
- GLfixed near, GLfixed far);
+void cogl_wrap_glMultMatrixf (const GLfloat *m);
+void cogl_wrap_glFrustumf (GLfloat left, GLfloat right,
+ GLfloat bottom, GLfloat top,
+ GLfloat z_near, GLfloat z_far);
+void cogl_wrap_glScalef (GLfloat x, GLfloat y, GLfloat z);
+void cogl_wrap_glTranslatef (GLfloat x, GLfloat y, GLfloat z);
+void cogl_wrap_glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+void cogl_wrap_glOrthof (GLfloat left, GLfloat right,
+ GLfloat bottom, GLfloat top,
+ GLfloat near, GLfloat far);
void cogl_wrap_glEnable (GLenum cap);
void cogl_wrap_glDisable (GLenum cap);
void cogl_wrap_glNormalPointer (GLenum type, GLsizei stride,
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_glDisableClientState (GLenum array);
void cogl_wrap_glAlphaFunc (GLenum func, GLclampf ref);
-void cogl_wrap_glColor4x (GLclampx r, GLclampx g, GLclampx b, GLclampx a);
+void cogl_wrap_glColor4f (GLclampx r, GLclampx g, GLclampx b, GLclampx 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_glGetFixedv (GLenum pname, GLfixed *params);
+void cogl_wrap_glGetFixedv (GLenum pname, GLfloat *params);
-void cogl_wrap_glFogx (GLenum pname, GLfixed param);
-void cogl_wrap_glFogxv (GLenum pname, const GLfixed *params);
+void cogl_wrap_glFogf (GLenum pname, GLfloat param);
+void cogl_wrap_glFogfv (GLenum pname, const GLfloat *params);
void cogl_wrap_glDrawArrays (GLenum mode, GLint first, GLsizei count);
void cogl_wrap_glDrawElements (GLenum mode, GLsizei count, GLenum type,
#define cogl_wrap_glPopMatrix glPopMatrix
#define cogl_wrap_glMatrixMode glMatrixMode
#define cogl_wrap_glLoadIdentity glLoadIdentity
-#define cogl_wrap_glMultMatrixx glMultMatrixx
-#define cogl_wrap_glFrustumx glFrustumx
-#define cogl_wrap_glScalex glScalex
-#define cogl_wrap_glTranslatex glTranslatex
-#define cogl_wrap_glRotatex glRotatex
-#define cogl_wrap_glOrthox glOrthox
+#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_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_glTexEnvx glTexEnvx
+#define cogl_wrap_glTexEnvf glTexEnvx
#define cogl_wrap_glEnableClientState glEnableClientState
#define cogl_wrap_glDisableClientState glDisableClientState
#define cogl_wrap_glAlphaFunc glAlphaFunc
-#define cogl_wrap_glColor4x glColor4x
-#define cogl_wrap_glClipPlanex glClipPlanex
+#define cogl_wrap_glColor4f glColor4x
+#define cogl_wrap_glClipPlanef glClipPlanex
#define cogl_wrap_glGetIntegerv glGetIntegerv
#define cogl_wrap_glGetFixedv glGetFixedv
-#define cogl_wrap_glFogx glFogx
-#define cogl_wrap_glFogxv glFogxv
+#define cogl_wrap_glFogf glFogx
+#define cogl_wrap_glFogfv glFogxv
#define cogl_wrap_glTexParameteri glTexParameteri
/* The extra third parameter of the bind texture wrapper isn't needed
void
-_cogl_rectanglex (CoglFixed x,
- CoglFixed y,
- CoglFixed width,
- CoglFixed height)
+_cogl_rectanglex (float x,
+ float y,
+ float width,
+ float height)
{
- GLfixed rect_verts[8] = {
+ GLfloat rect_verts[8] = {
x, y,
x + width, y,
x, y + height,
void
_cogl_path_add_node (gboolean new_sub_path,
- CoglFixed x,
- CoglFixed y)
+ float x,
+ float y)
{
CoglPathNode new_node;
}
static void
-_cogl_path_get_bounds (CoglFixedVec2 nodes_min,
- CoglFixedVec2 nodes_max,
+_cogl_path_get_bounds (floatVec2 nodes_min,
+ floatVec2 nodes_max,
gint *bounds_x,
gint *bounds_y,
guint *bounds_w,
guint *bounds_h)
{
- *bounds_x = COGL_FIXED_FLOOR (nodes_min.x);
- *bounds_y = COGL_FIXED_FLOOR (nodes_min.y);
- *bounds_w = COGL_FIXED_CEIL (nodes_max.x
- - COGL_FIXED_FROM_INT (*bounds_x));
- *bounds_h = COGL_FIXED_CEIL (nodes_max.y
- - COGL_FIXED_FROM_INT (*bounds_y));
+ *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));
}
static gint compare_ints (gconstpointer a,
}
void
-_cogl_add_path_to_stencil_buffer (CoglFixedVec2 nodes_min,
- CoglFixedVec2 nodes_max,
+_cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
+ floatVec2 nodes_max,
guint path_size,
CoglPathNode *path,
gboolean merge)
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () );
- cogl_rectanglex (-COGL_FIXED_1, -COGL_FIXED_1,
- COGL_FIXED_FROM_INT (2),
- COGL_FIXED_FROM_INT (2));
- cogl_rectanglex (-COGL_FIXED_1, -COGL_FIXED_1,
- COGL_FIXED_FROM_INT (2),
- COGL_FIXED_FROM_INT (2));
+ cogl_rectanglex (-1.0, -1.0,
+ (float)(2),
+ (float)(2));
+ cogl_rectanglex (-1.0, -1.0,
+ (float)(2),
+ (float)(2));
GE( cogl_wrap_glPopMatrix () );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPopMatrix () );
for (i=0; i < bounds_h; i++)
scanlines[i]=NULL;
- first_x = prev_x = COGL_FIXED_TO_INT (path->x);
- first_y = prev_y = COGL_FIXED_TO_INT (path->y);
+ first_x = prev_x = (path->x);
+ first_y = prev_y = (path->y);
/* create scanline intersection list */
for (i=1; i < path_size; i++)
{
- gint dest_x = COGL_FIXED_TO_INT (path[i].x);
- gint dest_y = COGL_FIXED_TO_INT (path[i].y);
+ gint dest_x = (path[i].x);
+ gint dest_y = (path[i].y);
gint ydir;
gint dx;
gint dy;
{
gint spans = 0;
gint span_no;
- GLfixed *coords;
+ GLfloat *coords;
/* count number of spans */
for (i=0; i < bounds_h; i++)
iter = next->next;
}
}
- coords = g_malloc0 (spans * sizeof (GLfixed) * 3 * 2 * 2);
+ coords = g_malloc0 (spans * sizeof (GLfloat) * 3 * 2 * 2);
span_no = 0;
/* build list of triangles */
while (iter)
{
GSList *next = iter->next;
- GLfixed x0, x1;
- GLfixed y0, y1;
+ GLfloat x0, x1;
+ GLfloat y0, y1;
if (!next)
break;
- x0 = COGL_FIXED_FROM_INT (GPOINTER_TO_INT (iter->data));
- x1 = COGL_FIXED_FROM_INT (GPOINTER_TO_INT (next->data));
- y0 = COGL_FIXED_FROM_INT (bounds_y + i);
- y1 = COGL_FIXED_FROM_INT (bounds_y + i + 1) + 2048;
+ x0 = (float)(GPOINTER_TO_INT (iter->data));
+ x1 = (float)(GPOINTER_TO_INT (next->data));
+ y0 = (float)(bounds_y + i);
+ y1 = (float)(bounds_y + i + 1) + 2048;
/* render scanlines 1.0625 high to avoid gaps when
transformed */
gint index;
GArray *array;
CoglTexSliceSpan *span;
- CoglFixed pos;
- CoglFixed next_pos;
- CoglFixed origin;
- CoglFixed cover_start;
- CoglFixed cover_end;
- CoglFixed intersect_start;
- CoglFixed intersect_end;
- CoglFixed intersect_start_local;
- CoglFixed intersect_end_local;
+ float pos;
+ float next_pos;
+ float origin;
+ float cover_start;
+ float cover_end;
+ float intersect_start;
+ float intersect_end;
+ float intersect_start_local;
+ float intersect_end_local;
gboolean intersects;
};
/* Offset next position by span size */
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 */
if (iter->next_pos <= iter->cover_start ||
static void
_cogl_span_iter_begin (CoglSpanIter *iter,
GArray *array,
- CoglFixed origin,
- CoglFixed cover_start,
- CoglFixed cover_end)
+ float origin,
+ float cover_start,
+ float cover_end)
{
/* Copy info */
iter->index = 0;
GLint *viewport)
{
gint bpp;
- CoglFixed rx1, ry1;
- CoglFixed rx2, ry2;
- CoglFixed tx1, ty1;
- CoglFixed tx2, ty2;
+ float rx1, ry1;
+ float rx2, ry2;
+ float tx1, ty1;
+ float tx2, ty2;
int bw, bh;
CoglBitmap rect_bmp;
CoglHandle handle;
/* Draw the texture image */
cogl_texture_rectangle (handle,
0, 0,
- COGL_FIXED_FROM_INT (tex->bitmap.width),
- COGL_FIXED_FROM_INT (tex->bitmap.height),
- 0, 0, COGL_FIXED_1, COGL_FIXED_1);
+ (float)(tex->bitmap.width),
+ (float)(tex->bitmap.height),
+ 0, 0, 1.0, 1.0);
/* Read into target bitmap */
prep_for_gl_pixels_download (tex->bitmap.rowstride);
ry1 = 0; ry2 = 0;
ty1 = 0; ty2 = 0;
-#define CFIX COGL_FIXED_FROM_INT
+#define CFIX (float)
/* Walk Y axis until whole bitmap height consumed */
for (bh = tex->bitmap.height; bh > 0; bh -= viewport[3])
/* Normalized texture Y coords */
ty1 = ty2;
- ty2 = COGL_FIXED_DIV (CFIX (ry2), CFIX (tex->bitmap.height));
+ ty2 = (CFIX (ry2) / CFIX (tex->bitmap.height));
rx1 = 0; rx2 = 0;
tx1 = 0; tx2 = 0;
/* Normalized texture X coords */
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
for direct copy to framebuffer */
GE( cogl_wrap_glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () );
- GE( cogl_wrap_glOrthox (0, COGL_FIXED_FROM_INT (viewport[2]),
- 0, COGL_FIXED_FROM_INT (viewport[3]),
- COGL_FIXED_FROM_INT (0),
- COGL_FIXED_FROM_INT (100)) );
+ GE( cogl_wrap_glOrthof (0, (float)(viewport[2]),
+ 0, (float)(viewport[3]),
+ (float)(0),
+ (float)(100)) );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPushMatrix () );
/* Iterate vertical spans */
for (source_y = src_y,
_cogl_span_iter_begin (&y_iter, tex->slice_y_spans,
- 0, COGL_FIXED_FROM_INT (dst_y),
- COGL_FIXED_FROM_INT (dst_y + height));
+ 0, (float)(dst_y),
+ (float)(dst_y + height));
!_cogl_span_iter_end (&y_iter);
/* Iterate horizontal spans */
for (source_x = src_x,
_cogl_span_iter_begin (&x_iter, tex->slice_x_spans,
- 0, COGL_FIXED_FROM_INT (dst_x),
- COGL_FIXED_FROM_INT (dst_x + width));
+ 0, (float)(dst_x),
+ (float)(dst_x + width));
!_cogl_span_iter_end (&x_iter);
x_iter.index);
/* 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);
- inter_h = COGL_FIXED_TO_INT (y_iter.intersect_end -
+ inter_h = (y_iter.intersect_end -
y_iter.intersect_start);
/* 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);
- local_y = COGL_FIXED_TO_INT (y_iter.intersect_start -
+ local_y = (y_iter.intersect_start -
y_iter.pos);
/* Pick slice GL handle */
guint wx, wy;
src = source_bmp->data
- + (src_y + COGL_FIXED_TO_INT (y_iter.intersect_start)
+ + (src_y + (y_iter.intersect_start)
- dst_y)
* source_bmp->rowstride
+ (src_x + x_span->start + x_span->size - x_span->waste
guint copy_width;
src = source_bmp->data
- + (src_x + COGL_FIXED_TO_INT (x_iter.intersect_start)
+ + (src_x + (x_iter.intersect_start)
- dst_x)
* bpp
+ (src_y + y_span->start + y_span->size - y_span->waste
static void
_cogl_texture_quad_sw (CoglTexture *tex,
- CoglFixed x1,
- CoglFixed y1,
- CoglFixed x2,
- CoglFixed y2,
- CoglFixed tx1,
- CoglFixed ty1,
- CoglFixed tx2,
- CoglFixed ty2)
+ float x1,
+ float y1,
+ float x2,
+ float y2,
+ float tx1,
+ float ty1,
+ float tx2,
+ float ty2)
{
CoglSpanIter iter_x , iter_y;
- CoglFixed tw , th;
- CoglFixed tqx , tqy;
- CoglFixed first_tx , first_ty;
- CoglFixed first_qx , first_qy;
- CoglFixed slice_tx1 , slice_ty1;
- CoglFixed slice_tx2 , slice_ty2;
- CoglFixed slice_qx1 , slice_qy1;
- CoglFixed slice_qx2 , slice_qy2;
+ float tw , th;
+ float tqx , tqy;
+ float first_tx , first_ty;
+ float first_qx , first_qy;
+ float slice_tx1 , slice_ty1;
+ float slice_tx2 , slice_ty2;
+ float slice_qx1 , slice_qy1;
+ float slice_qx2 , slice_qy2;
GLuint gl_handle;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
slices */
if (tx2 < tx1)
{
- CoglFixed temp = x1;
+ float temp = x1;
x1 = x2;
x2 = temp;
temp = tx1;
}
if (ty2 < ty1)
{
- CoglFixed temp = y1;
+ float temp = y1;
y1 = y2;
y2 = temp;
temp = ty1;
}
/* Scale ratio from texture to quad widths */
- tw = COGL_FIXED_FROM_INT (tex->bitmap.width);
- th = COGL_FIXED_FROM_INT (tex->bitmap.height);
+ tw = (float)(tex->bitmap.width);
+ th = (float)(tex->bitmap.height);
- tqx = COGL_FIXED_DIV (x2 - x1, COGL_FIXED_MUL (tw, (tx2 - tx1)));
- tqy = COGL_FIXED_DIV (y2 - y1, COGL_FIXED_MUL (th, (ty2 - ty1)));
+ tqx = (x2 - x1 / (tw * (tx2 - tx1)));
+ tqy = (y2 - y1 / (th * (ty2 - ty1)));
/* Integral texture coordinate for first tile */
- first_tx = COGL_FIXED_FROM_INT (COGL_FIXED_FLOOR (tx1));
- first_ty = COGL_FIXED_FROM_INT (COGL_FIXED_FLOOR (ty1));
+ first_tx = (float)(floorf (tx1));
+ first_ty = (float)(floorf (ty1));
/* Denormalize texture coordinates */
- first_tx = COGL_FIXED_MUL (first_tx, tw);
- first_ty = COGL_FIXED_MUL (first_ty, th);
- tx1 = COGL_FIXED_MUL (tx1, tw);
- ty1 = COGL_FIXED_MUL (ty1, th);
- tx2 = COGL_FIXED_MUL (tx2, tw);
- ty2 = COGL_FIXED_MUL (ty2, th);
+ first_tx = (first_tx * tw);
+ first_ty = (first_ty * th);
+ tx1 = (tx1 * tw);
+ ty1 = (ty1 * th);
+ tx2 = (tx2 * tw);
+ ty2 = (ty2 * th);
/* Quad coordinate of the first tile */
- first_qx = x1 - COGL_FIXED_MUL (tx1 - first_tx, tqx);
- first_qy = y1 - COGL_FIXED_MUL (ty1 - first_ty, tqy);
+ first_qx = x1 - (tx1 - first_tx * tqx);
+ first_qy = y1 - (ty1 - first_ty * tqy);
/* Iterate until whole quad height covered */
/* Span-quad intersection in quad coordinates */
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 +
- COGL_FIXED_MUL (iter_y.intersect_end - first_ty, tqy);
+ (iter_y.intersect_end - first_ty * tqy);
/* Localize slice texture coordinates */
slice_ty1 = iter_y.intersect_start - iter_y.pos;
/* Span-quad intersection in quad coordinates */
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 +
- COGL_FIXED_MUL (iter_x.intersect_end - first_tx, tqx);
+ (iter_x.intersect_end - first_tx * tqx);
/* Localize slice texture coordinates */
slice_tx1 = iter_x.intersect_start - iter_x.pos;
#if COGL_DEBUG
printf("~~~~~ slice (%d,%d)\n", iter_x.index, iter_y.index);
- printf("qx1: %f\n", COGL_FIXED_TO_FLOAT (slice_qx1));
- printf("qy1: %f\n", COGL_FIXED_TO_FLOAT (slice_qy1));
- printf("qx2: %f\n", COGL_FIXED_TO_FLOAT (slice_qx2));
- printf("qy2: %f\n", COGL_FIXED_TO_FLOAT (slice_qy2));
- printf("tx1: %f\n", COGL_FIXED_TO_FLOAT (slice_tx1));
- printf("ty1: %f\n", COGL_FIXED_TO_FLOAT (slice_ty1));
- printf("tx2: %f\n", COGL_FIXED_TO_FLOAT (slice_tx2));
- printf("ty2: %f\n", COGL_FIXED_TO_FLOAT (slice_ty2));
+ printf("qx1: %f\n", (slice_qx1));
+ printf("qy1: %f\n", (slice_qy1));
+ printf("qx2: %f\n", (slice_qx2));
+ printf("qy2: %f\n", (slice_qy2));
+ printf("tx1: %f\n", (slice_tx1));
+ printf("ty1: %f\n", (slice_ty1));
+ printf("tx2: %f\n", (slice_tx2));
+ printf("ty2: %f\n", (slice_ty2));
#endif
/* Pick and bind opengl texture object */
ctx->texture_current = gl_handle;
ctx->texture_format = tex->gl_intformat;
- _cogl_texture_add_quad_vertices (COGL_FIXED_TO_FLOAT (slice_qx1),
- COGL_FIXED_TO_FLOAT (slice_qy1),
- COGL_FIXED_TO_FLOAT (slice_qx2),
- COGL_FIXED_TO_FLOAT (slice_qy2),
- COGL_FIXED_TO_FLOAT (slice_tx1),
- COGL_FIXED_TO_FLOAT (slice_ty1),
- COGL_FIXED_TO_FLOAT (slice_tx2),
- COGL_FIXED_TO_FLOAT (slice_ty2));
+ _cogl_texture_add_quad_vertices ( (slice_qx1),
+ (slice_qy1),
+ (slice_qx2),
+ (slice_qy2),
+ (slice_tx1),
+ (slice_ty1),
+ (slice_tx2),
+ (slice_ty2));
}
}
}
static void
_cogl_texture_quad_hw (CoglTexture *tex,
- CoglFixed x1,
- CoglFixed y1,
- CoglFixed x2,
- CoglFixed y2,
- CoglFixed tx1,
- CoglFixed ty1,
- CoglFixed tx2,
- CoglFixed ty2)
+ float x1,
+ float y1,
+ float x2,
+ float y2,
+ float tx1,
+ float ty1,
+ float tx2,
+ float ty2)
{
GLuint gl_handle;
CoglTexSliceSpan *x_span;
ty1 = ty1 * (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_FIXED_TO_FLOAT (y1),
- COGL_FIXED_TO_FLOAT (x2),
- COGL_FIXED_TO_FLOAT (y2),
- COGL_FIXED_TO_FLOAT (tx1),
- COGL_FIXED_TO_FLOAT (ty1),
- COGL_FIXED_TO_FLOAT (tx2),
- COGL_FIXED_TO_FLOAT (ty2));
+ _cogl_texture_add_quad_vertices ( (x1),
+ (y1),
+ (x2),
+ (y2),
+ (tx1),
+ (ty1),
+ (tx2),
+ (ty2));
}
void
cogl_texture_multiple_rectangles (CoglHandle handle,
- const CoglFixed *verts,
+ const float *verts,
guint n_rects)
{
CoglTexture *tex;
if (tex->slice_gl_handles->len == 1
&& ((cogl_features_available (COGL_FEATURE_TEXTURE_NPOT)
&& tex->gl_target == GL_TEXTURE_2D)
- || (verts[4] >= 0 && verts[4] <= COGL_FIXED_1
- && verts[6] >= 0 && verts[6] <= COGL_FIXED_1
- && verts[5] >= 0 && verts[5] <= COGL_FIXED_1
- && verts[7] >= 0 && verts[7] <= COGL_FIXED_1)))
+ || (verts[4] >= 0 && verts[4] <= 1.0
+ && verts[6] >= 0 && verts[6] <= 1.0
+ && verts[5] >= 0 && verts[5] <= 1.0
+ && verts[7] >= 0 && verts[7] <= 1.0)))
_cogl_texture_quad_hw (tex, verts[0],verts[1], verts[2],verts[3],
verts[4],verts[5], verts[6],verts[7]);
else
void
cogl_texture_rectangle (CoglHandle handle,
- CoglFixed x1,
- CoglFixed y1,
- CoglFixed x2,
- CoglFixed y2,
- CoglFixed tx1,
- CoglFixed ty1,
- CoglFixed tx2,
- CoglFixed ty2)
+ float x1,
+ float y1,
+ float x2,
+ float y2,
+ float tx1,
+ float ty1,
+ float tx2,
+ float ty2)
{
- CoglFixed verts[8];
+ float verts[8];
verts[0] = x1;
verts[1] = y1;
OpenGL */
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[1] = CFX_F(vertices[i].y);
}
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
-cogl_translatex (CoglFixed x, CoglFixed y, CoglFixed z)
+cogl_translatex (float x, float y, float z)
{
- GE( cogl_wrap_glTranslatex (x, y, z) );
+ GE( cogl_wrap_glTranslatef (x, y, z) );
}
void
cogl_translate (gint x, gint y, gint z)
{
- GE( cogl_wrap_glTranslatex (COGL_FIXED_FROM_INT(x),
- COGL_FIXED_FROM_INT(y),
- COGL_FIXED_FROM_INT(z)) );
+ GE( cogl_wrap_glTranslatef ((float)(x),
+ (float)(y),
+ (float)(z)) );
}
void
-cogl_rotatex (CoglFixed angle,
- CoglFixed x,
- CoglFixed y,
- CoglFixed z)
+cogl_rotatex (float angle,
+ float x,
+ float y,
+ float z)
{
- GE( cogl_wrap_glRotatex (angle,x,y,z) );
+ GE( cogl_wrap_glRotatef (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)) );
+ GE( cogl_wrap_glRotatef ((float)(angle),
+ (float)(x),
+ (float)(y),
+ (float)(z)) );
}
static inline gboolean
#else
/* 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_blue (color),
cogl_color_get_alpha (color)) );
}
static void
-apply_matrix (const CoglFixed *matrix, CoglFixed *vertex)
+apply_matrix (const float *matrix, float *vertex)
{
int x, y;
- CoglFixed vertex_out[4] = { 0 };
+ float vertex_out[4] = { 0 };
for (y = 0; y < 4; y++)
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));
}
static void
-project_vertex (CoglFixed *modelview,
- CoglFixed *project,
- CoglFixed *vertex)
+project_vertex (float *modelview,
+ float *project,
+ float *vertex)
{
int i;
apply_matrix (project, vertex);
/* Convert from homogenized coordinates */
for (i = 0; i < 4; i++)
- vertex[i] = cogl_fixed_div (vertex[i], vertex[3]);
+ vertex[i] = (vertex[i] / vertex[3]);
}
static void
set_clip_plane (GLint plane_num,
- const CoglFixed *vertex_a,
- const CoglFixed *vertex_b)
+ const float *vertex_a,
+ const float *vertex_b)
{
- GLfixed plane[4];
- GLfixed angle;
+ GLfloat plane[4];
+ GLfloat angle;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
/* Calculate the angle between the axes and the line crossing the
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]),
COGL_RADIANS_TO_DEGREES);
projection matrix so we can specify the plane in screen
coordinates */
GE( cogl_wrap_glLoadIdentity () );
- GE( cogl_wrap_glMultMatrixx ((GLfixed *) ctx->inverse_projection) );
+ GE( cogl_wrap_glMultMatrixf ((GLfloat *) ctx->inverse_projection) );
/* 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
the two points */
- GE( cogl_wrap_glRotatex (angle, 0.0f, 0.0f, 1.0f) );
- GE( cogl_wrap_glTranslatex (-vertex_a[0], -vertex_a[1], -vertex_a[2]) );
+ GE( cogl_wrap_glRotatef (angle, 0.0f, 0.0f, 1.0f) );
+ GE( cogl_wrap_glTranslatef (-vertex_a[0], -vertex_a[1], -vertex_a[2]) );
plane[0] = 0;
- plane[1] = -COGL_FIXED_1;
+ plane[1] = -1.0;
plane[2] = 0;
plane[3] = vertex_a[1];
- GE( cogl_wrap_glClipPlanex (plane_num, plane) );
+ GE( cogl_wrap_glClipPlanef (plane_num, plane) );
GE( cogl_wrap_glPopMatrix () );
}
void
-_cogl_set_clip_planes (CoglFixed x_offset,
- CoglFixed y_offset,
- CoglFixed width,
- CoglFixed height)
+_cogl_set_clip_planes (float x_offset,
+ float y_offset,
+ float width,
+ float height)
{
- GLfixed modelview[16], projection[16];
+ GLfloat modelview[16], projection[16];
- CoglFixed vertex_tl[4] = { x_offset, y_offset, 0, COGL_FIXED_1 };
- CoglFixed vertex_tr[4] = { x_offset + width, y_offset, 0, COGL_FIXED_1 };
- CoglFixed vertex_bl[4] = { x_offset, y_offset + height, 0, COGL_FIXED_1 };
- CoglFixed vertex_br[4] = { x_offset + width, y_offset + height,
- 0, COGL_FIXED_1 };
+ float vertex_tl[4] = { x_offset, y_offset, 0, 1.0 };
+ float vertex_tr[4] = { x_offset + width, y_offset, 0, 1.0 };
+ float vertex_bl[4] = { x_offset, y_offset + height, 0, 1.0 };
+ 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) );
if ((vertex_tl[0] < vertex_tr[0] ? 1 : 0)
!= (vertex_bl[1] < vertex_tl[1] ? 1 : 0))
{
- CoglFixed temp[4];
+ float temp[4];
memcpy (temp, vertex_tl, sizeof (temp));
memcpy (vertex_tl, vertex_tr, sizeof (temp));
memcpy (vertex_tr, temp, sizeof (temp));
}
void
-_cogl_add_stencil_clip (CoglFixed x_offset,
- CoglFixed y_offset,
- CoglFixed width,
- CoglFixed height,
+_cogl_add_stencil_clip (float x_offset,
+ float y_offset,
+ float width,
+ float height,
gboolean first)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () );
- cogl_rectanglex (-COGL_FIXED_1, -COGL_FIXED_1,
- COGL_FIXED_FROM_INT (2),
- COGL_FIXED_FROM_INT (2));
+ cogl_rectanglex (-1.0, -1.0,
+ (float)(2),
+ (float)(2));
GE( cogl_wrap_glPopMatrix () );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPopMatrix () );
}
void
-_cogl_set_matrix (const CoglFixed *matrix)
+_cogl_set_matrix (const float *matrix)
{
GE( cogl_wrap_glLoadIdentity () );
- GE( cogl_wrap_glMultMatrixx (matrix) );
+ GE( cogl_wrap_glMultMatrixf (matrix) );
}
void
void
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
*/
void
-cogl_perspective (CoglFixed fovy,
- CoglFixed aspect,
- CoglFixed zNear,
- CoglFixed zFar)
+cogl_perspective (float fovy,
+ float aspect,
+ float zNear,
+ float zFar)
{
- CoglFixed xmax, ymax;
- CoglFixed x, y, c, d;
- CoglFixed fovy_rad_half = cogl_fixed_mul (fovy, COGL_FIXED_PI) / 360;
+ float xmax, ymax;
+ float x, y, c, d;
+ float fovy_rad_half = (fovy * G_PI) / 360;
- GLfixed m[16];
+ GLfloat m[16];
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
* 2) When working with small numbers, we can are loosing significant
* precision
*/
- ymax = cogl_fixed_mul (zNear,
- cogl_fixed_div (cogl_fixed_sin (fovy_rad_half),
- cogl_fixed_cos (fovy_rad_half)));
- xmax = cogl_fixed_mul (ymax, aspect);
+ ymax = (zNear *
+ (sinf (fovy_rad_half) /
+ cosf (fovy_rad_half)));
+ xmax = (ymax * aspect);
- x = cogl_fixed_div (zNear, xmax);
- y = cogl_fixed_div (zNear, ymax);
- c = cogl_fixed_div (-(zFar + zNear), ( zFar - zNear));
- d = cogl_fixed_div (-(cogl_fixed_mul (2 * zFar, zNear)), (zFar - zNear));
+ x = (zNear / xmax);
+ y = (zNear / ymax);
+ c = (-(zFar + zNear) / ( zFar - zNear));
+ d = (-((2 * zFar * zNear)) / (zFar - zNear));
#define M(row,col) m[col*4+row]
M(0,0) = x;
M(1,1) = y;
M(2,2) = c;
M(2,3) = d;
- M(3,2) = -COGL_FIXED_1;
+ M(3,2) = -1.0;
- GE( cogl_wrap_glMultMatrixx (m) );
+ GE( cogl_wrap_glMultMatrixf (m) );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
/* 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
- M(0, 0) = cogl_fixed_div (COGL_FIXED_1, x);
- M(1, 1) = cogl_fixed_div (COGL_FIXED_1, y);
- M(2, 3) = -COGL_FIXED_1;
- M(3, 2) = cogl_fixed_div (COGL_FIXED_1, d);
- M(3, 3) = cogl_fixed_div (c, d);
+ M(0, 0) = (1.0 / x);
+ M(1, 1) = (1.0 / y);
+ M(2, 3) = -1.0;
+ M(3, 2) = (1.0 / d);
+ M(3, 3) = (c / d);
#undef m
#undef M
}
void
-cogl_frustum (CoglFixed left,
- CoglFixed right,
- CoglFixed bottom,
- CoglFixed top,
- CoglFixed z_near,
- CoglFixed z_far)
+cogl_frustum (float left,
+ float right,
+ float bottom,
+ float top,
+ float z_near,
+ float z_far)
{
- CoglFixed c, d;
+ float c, d;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glLoadIdentity () );
- GE( cogl_wrap_glFrustumx (left, right,
+ GE( cogl_wrap_glFrustumf (left, right,
bottom, top,
z_near, z_far) );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
/* 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);
- d = -cogl_fixed_div (2 * cogl_fixed_mul (z_far, z_near), z_far - z_near);
+ c = -(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]
- M(0,0) = cogl_fixed_div (right - left, 2 * z_near);
- M(0,3) = cogl_fixed_div (right + left, 2 * z_near);
- M(1,1) = cogl_fixed_div (top - bottom, 2 * z_near);
- M(1,3) = cogl_fixed_div (top + bottom, 2 * z_near);
- M(2,3) = -COGL_FIXED_1;
- M(3,2) = cogl_fixed_div (COGL_FIXED_1, d);
- M(3,3) = cogl_fixed_div (c, d);
+ M(0,0) = (right - left / 2 * z_near);
+ M(0,3) = (right + left / 2 * z_near);
+ M(1,1) = (top - bottom / 2 * z_near);
+ M(1,3) = (top + bottom / 2 * z_near);
+ M(2,3) = -1.0;
+ M(3,2) = (1.0 / d);
+ M(3,3) = (c / d);
#undef M
}
void
cogl_setup_viewport (guint w,
guint h,
- CoglFixed fovy,
- CoglFixed aspect,
- CoglFixed z_near,
- CoglFixed z_far)
+ float fovy,
+ float aspect,
+ float z_near,
+ float z_far)
{
gint width = (gint) w;
gint height = (gint) h;
- CoglFixed z_camera;
+ float z_camera;
GE( glViewport (0, 0, width, height) );
/* 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);
* See comments in ../gl/cogl.c
*/
#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),
- cogl_fixed_cos (fovy_rad)) >> 1;
+ z_camera = (sinf (fovy_rad) /
+ cosf (fovy_rad)) >> 1;
}
- GE( cogl_wrap_glTranslatex (-1 << 15, -1 << 15, -z_camera) );
+ GE( cogl_wrap_glTranslatef (-1 << 15, -1 << 15, -z_camera) );
- GE( cogl_wrap_glScalex ( COGL_FIXED_1 / width,
- -COGL_FIXED_1 / height,
- COGL_FIXED_1 / width) );
+ GE( cogl_wrap_glScalef ( 1.0 / width,
+ -1.0 / height,
+ 1.0 / width) );
- GE( cogl_wrap_glTranslatex (0, -COGL_FIXED_1 * height, 0) );
+ GE( cogl_wrap_glTranslatef (0, -1.0 * height, 0) );
}
static void
}
void
-cogl_get_modelview_matrix (CoglFixed m[16])
+cogl_get_modelview_matrix (float m[16])
{
cogl_wrap_glGetFixedv(GL_MODELVIEW_MATRIX, &m[0]);
}
void
-cogl_get_projection_matrix (CoglFixed m[16])
+cogl_get_projection_matrix (float m[16])
{
cogl_wrap_glGetFixedv(GL_PROJECTION_MATRIX, &m[0]);
}
void
-cogl_get_viewport (CoglFixed v[4])
+cogl_get_viewport (float v[4])
{
GLint viewport[4];
int i;
cogl_wrap_glGetIntegerv (GL_VIEWPORT, viewport);
for (i = 0; i < 4; i++)
- v[i] = COGL_FIXED_FROM_INT (viewport[i]);
+ v[i] = (float)(viewport[i]);
}
void
void
cogl_fog_set (const CoglColor *fog_color,
- CoglFixed density,
- CoglFixed z_near,
- CoglFixed z_far)
+ float density,
+ float z_near,
+ float z_far)
{
- GLfixed fogColor[4];
+ GLfloat fogColor[4];
fogColor[0] = cogl_color_get_red (fog_color);
fogColor[1] = cogl_color_get_green (fog_color);
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);
- cogl_wrap_glFogx (GL_FOG_DENSITY, (GLfixed) density);
- cogl_wrap_glFogx (GL_FOG_START, (GLfixed) z_near);
- cogl_wrap_glFogx (GL_FOG_END, (GLfixed) z_far);
+ cogl_wrap_glFogf (GL_FOG_DENSITY, (GLfloat) density);
+ cogl_wrap_glFogf (GL_FOG_START, (GLfloat) z_near);
+ cogl_wrap_glFogf (GL_FOG_END, (GLfloat) z_far);
}
value = g_slice_new (CoglPangoGlyphCacheValue);
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;
- value->tx2 = COGL_FIXED_FROM_INT (band->space_remaining + width)
+ value->tx2 = (float)(band->space_remaining + width)
/ band->texture_size;
- value->ty1 = COGL_FIXED_FROM_INT (band->top)
+ value->ty1 = (float)(band->top)
/ band->texture_size;
- value->ty2 = COGL_FIXED_FROM_INT (band->top + height)
+ value->ty2 = (float)(band->top + height)
/ band->texture_size;
value->draw_x = draw_x;
value->draw_y = draw_y;
{
CoglHandle texture;
- CoglFixed tx1;
- CoglFixed ty1;
- CoglFixed tx2;
- CoglFixed ty2;
+ float tx1;
+ float ty1;
+ float tx2;
+ float ty2;
int draw_x;
int draw_y;
{
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,
priv->glyph_rectangles->len / 8);
g_array_set_size (priv->glyph_rectangles, 0);
static void
cogl_pango_renderer_draw_glyph (CoglPangoRenderer *priv,
CoglPangoGlyphCacheValue *cache_value,
- CoglFixed x1,
- CoglFixed y1)
+ float x1,
+ float y1)
{
- CoglFixed x2, y2;
- CoglFixed *p;
+ float x2, y2;
+ float *p;
if (priv->glyph_rectangles->len > 0
&& priv->glyph_texture != cache_value->texture)
y2 = y1 + CLUTTER_INT_TO_FIXED (cache_value->draw_height);
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);
*(p++) = x1; *(p++) = y1;
priv->glyph_cache = cogl_pango_glyph_cache_new (FALSE);
priv->mipmapped_glyph_cache = cogl_pango_glyph_cache_new (TRUE);
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
cogl_pango_renderer_draw_box (int x, int y,
int width, int height)
{
- cogl_path_rectangle (COGL_FIXED_FROM_INT (x),
- COGL_FIXED_FROM_INT (y - height),
- COGL_FIXED_FROM_INT (width),
- COGL_FIXED_FROM_INT (height));
+ cogl_path_rectangle ((float)(x),
+ (float)(y - height),
+ (float)(width),
+ (float)(height));
cogl_path_stroke ();
}
cogl_pango_renderer_get_device_units (PangoRenderer *renderer,
int xin,
int yin,
- CoglFixed *xout,
- CoglFixed *yout)
+ float *xout,
+ float *yout)
{
const PangoMatrix *matrix;
if ((matrix = pango_renderer_get_matrix (renderer)))
{
/* 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);
- *yout = COGL_FIXED_FROM_FLOAT ((yin * matrix->yy + xin * matrix->yx)
+ *yout = ((yin * matrix->yy + xin * matrix->yx)
/ PANGO_SCALE + matrix->y0);
}
else
int width,
int height)
{
- CoglFixed x1, x2, y1, y2;
+ float x1, x2, y1, y2;
cogl_pango_renderer_set_color_for_part (renderer, part);
double x12,
double x22)
{
- CoglFixed points[8];
+ float points[8];
- points[0] = COGL_FIXED_FROM_FLOAT (x11);
- points[1] = COGL_FIXED_FROM_FLOAT (y1);
- points[2] = COGL_FIXED_FROM_FLOAT (x12);
- points[3] = COGL_FIXED_FROM_FLOAT (y2);
- points[4] = COGL_FIXED_FROM_FLOAT (x22);
+ points[0] = (x11);
+ points[1] = (y1);
+ points[2] = (x12);
+ points[3] = (y2);
+ points[4] = (x22);
points[5] = points[3];
- points[6] = COGL_FIXED_FROM_FLOAT (x21);
+ points[6] = (x21);
points[7] = points[1];
cogl_pango_renderer_set_color_for_part (renderer, part);
for (i = 0; i < glyphs->num_glyphs; i++)
{
PangoGlyphInfo *gi = glyphs->glyphs + i;
- CoglFixed x, y;
+ float x, y;
cogl_pango_renderer_get_device_units (renderer,
xi + gi->geometry.x_offset,
if (font == NULL ||
(metrics = pango_font_get_metrics (font, NULL)) == NULL)
{
- cogl_pango_renderer_draw_box (COGL_FIXED_TO_INT (x),
- COGL_FIXED_TO_INT (y),
+ cogl_pango_renderer_draw_box ( (x),
+ (y),
PANGO_UNKNOWN_GLYPH_WIDTH,
PANGO_UNKNOWN_GLYPH_HEIGHT);
}
else
{
- cogl_pango_renderer_draw_box (COGL_FIXED_TO_INT (x),
- COGL_FIXED_TO_INT (y),
+ cogl_pango_renderer_draw_box ( (x),
+ (y),
metrics->approximate_char_width
/ PANGO_SCALE,
metrics->ascent / PANGO_SCALE);
{
cogl_pango_renderer_glyphs_end (priv);
- cogl_pango_renderer_draw_box (COGL_FIXED_TO_INT (x),
- COGL_FIXED_TO_INT (y),
+ cogl_pango_renderer_draw_box ( (x),
+ (y),
PANGO_UNKNOWN_GLYPH_WIDTH,
PANGO_UNKNOWN_GLYPH_HEIGHT);
}
else
{
- CoglFixed width, height;
+ float width, height;
- x += COGL_FIXED_FROM_INT (cache_value->draw_x);
- y += COGL_FIXED_FROM_INT (cache_value->draw_y);
+ x += (float)(cache_value->draw_x);
+ y += (float)(cache_value->draw_y);
- width = x + COGL_FIXED_FROM_INT (cache_value->draw_width);
- height = y + COGL_FIXED_FROM_INT (cache_value->draw_height);
+ width = x + (float)(cache_value->draw_width);
+ height = y + (float)(cache_value->draw_height);
cogl_pango_renderer_draw_glyph (priv, cache_value, x, y);
}
the first */
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];
memset (verts, 0, sizeof (verts));
/* Set the color to white so that all the textures will be drawn
at their own color */
- cogl_set_source_color4x (COGL_FIXED_1, COGL_FIXED_1,
- COGL_FIXED_1, COGL_FIXED_1);
+ cogl_set_source_color4x (1.0, 1.0,
+ 1.0, 1.0);
- x2 = x1 + COGL_FIXED_FROM_INT (TEXTURE_SIZE);
+ x2 = x1 + (float)(TEXTURE_SIZE);
/* Draw a front-facing texture */
cogl_texture_rectangle (state->texture,
x1, y1, x2, y2,
- 0, 0, COGL_FIXED_1, COGL_FIXED_1);
+ 0, 0, 1.0, 1.0);
x1 = x2;
- x2 = x1 + COGL_FIXED_FROM_INT (TEXTURE_SIZE);
+ x2 = x1 + (float)(TEXTURE_SIZE);
/* Draw a back-facing texture */
cogl_texture_rectangle (state->texture,
x2, y1, x1, y2,
- 0, 0, COGL_FIXED_1, COGL_FIXED_1);
+ 0, 0, 1.0, 1.0);
x1 = x2;
- x2 = x1 + COGL_FIXED_FROM_INT (TEXTURE_SIZE);
+ x2 = x1 + (float)(TEXTURE_SIZE);
/* Draw a front-facing texture polygon */
verts[0].x = x1; verts[0].y = y2;
verts[2].x = x2; verts[2].y = y1;
verts[3].x = x1; verts[3].y = y1;
verts[0].tx = 0; verts[0].ty = 0;
- verts[1].tx = COGL_FIXED_1; verts[1].ty = 0;
- verts[2].tx = COGL_FIXED_1; verts[2].ty = COGL_FIXED_1;
- verts[3].tx = 0; verts[3].ty = COGL_FIXED_1;
+ verts[1].tx = 1.0; verts[1].ty = 0;
+ verts[2].tx = 1.0; verts[2].ty = 1.0;
+ verts[3].tx = 0; verts[3].ty = 1.0;
cogl_texture_polygon (state->texture, 4,
verts, FALSE);
x1 = x2;
- x2 = x1 + COGL_FIXED_FROM_INT (TEXTURE_SIZE);
+ x2 = x1 + (float)(TEXTURE_SIZE);
/* Draw a back-facing texture polygon */
verts[0].x = x1; verts[0].y = y1;
verts[2].x = x2; verts[2].y = y2;
verts[3].x = x1; verts[3].y = y2;
verts[0].tx = 0; verts[0].ty = 0;
- verts[1].tx = COGL_FIXED_1; verts[1].ty = 0;
- verts[2].tx = COGL_FIXED_1; verts[2].ty = COGL_FIXED_1;
- verts[3].tx = 0; verts[3].ty = COGL_FIXED_1;
+ verts[1].tx = 1.0; verts[1].ty = 0;
+ verts[2].tx = 1.0; verts[2].ty = 1.0;
+ verts[3].tx = 0; verts[3].ty = 1.0;
cogl_texture_polygon (state->texture, 4,
verts, FALSE);
x1 = x2;
- x2 = x1 + COGL_FIXED_FROM_INT (TEXTURE_SIZE);
+ x2 = x1 + (float)(TEXTURE_SIZE);
/* Draw a regular rectangle (this should always show) */
- cogl_set_source_color4x (COGL_FIXED_1, 0, 0, COGL_FIXED_1);
- cogl_rectangle (COGL_FIXED_TO_INT (x1), COGL_FIXED_TO_INT (y1),
- COGL_FIXED_TO_INT (x2 - x1), COGL_FIXED_TO_INT (y2 - y1));
+ cogl_set_source_color4x (1.0, 0, 0, 1.0);
+ cogl_rectangle ( (x1), (y1),
+ (x2 - x1), (y2 - y1));
/* The second time round draw beneath the first with backface
culling disabled */
cos_frame = clutter_cosi (CLUTTER_ANGLE_FROM_DEG (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));
- frac_frame += (COGL_FIXED_1 >> 1);
+ frac_frame += (1.0 >> 1);
frac_frame <<= 1;
for (t=0; t<4; t+=2)
texcoords[t] += cos_frame;
texcoords[t+1] += sin_frame;
- texcoords[t] = COGL_FIXED_MUL (texcoords[t], frac_frame);
- texcoords[t+1] = COGL_FIXED_MUL (texcoords[t+1], frac_frame);
+ texcoords[t] = (texcoords[t] * frac_frame);
+ texcoords[t+1] = (texcoords[t+1] * frac_frame);
}
priv = TEST_COGLBOX_GET_PRIVATE (self);
cogl_path_round_rectangle (0, 0,
CLUTTER_UNITS_TO_FIXED (width),
CLUTTER_UNITS_TO_FIXED (height),
- COGL_FIXED_FROM_INT (4),
+ (float)(4),
COGL_ANGLE_FROM_DEG (1.0));
cogl_path_stroke ();
}
projects / profile / ivi / clutter.git / commitdiff