isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-24 12:02:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

[Automatic fixed-to-float.sh change] Applies a number fixed to float patches

Browse Source 
To deal with all the corner cases that couldn't be scripted a number of patches
were written for the remaining 10% of the effort.

Note: again no API changes were made in Clutter, only in Cogl.
This commit is contained in:
Robert Bragg 2009-01-20 16:20:54 +00:00
parent e82f656590
commit a2cf7e4a19
27 changed files with 355 additions and 584 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
clutter/clutter-actor.c
View File

@ -806,7 +806,7 @@ static inline void
mtx_transform (const ClutterFixed m[], mtx_transform (const ClutterFixed m[],
fixed_vertex_t *vertex) fixed_vertex_t *vertex)
{ {
ClutterFixed _x, _y, _z, _w; float _x, _y, _z, _w;
_x = vertex->x; _x = vertex->x;
_y = vertex->y; _y = vertex->y;
@ -846,8 +846,11 @@ mtx_transform (const ClutterFixed m[],
/* Help macros to scale from OpenGL <-1,1> coordinates system to our /* Help macros to scale from OpenGL <-1,1> coordinates system to our
* X-window based <0,window-size> coordinates * X-window based <0,window-size> coordinates
*/ */
#define MTX_GL_SCALE_X(x,w,v1,v2) (CLUTTER_FIXED_MUL (((CLUTTER_FIXED_DIV ((x), (w)) + 1.0) >> 1), (v1)) + (v2)) #define MTX_GL_SCALE_X(x,w,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)) (CLUTTER_FIXED_MUL (((CLUTTER_FIXED_DIV ((x), (w)) + 1.0) / 2), (v1)) + (v2))
#define MTX_GL_SCALE_Y(y,w,v1,v2) \
((v1) - CLUTTER_FIXED_MUL (((CLUTTER_FIXED_DIV ((y), (w)) + 1.0) / 2), \
(v1)) + (v2))
#define MTX_GL_SCALE_Z(z,w,v1,v2) (MTX_GL_SCALE_X ((z), (w), (v1), (v2))) #define MTX_GL_SCALE_Z(z,w,v1,v2) (MTX_GL_SCALE_X ((z), (w), (v1), (v2)))
/* transforms a 4-tuple of coordinates using @matrix and /* transforms a 4-tuple of coordinates using @matrix and
@ -1345,8 +1348,8 @@ _clutter_actor_apply_modelview_transform (ClutterActor *self)
gboolean is_stage = CLUTTER_IS_STAGE (self); gboolean is_stage = CLUTTER_IS_STAGE (self);
if (!is_stage) if (!is_stage)
cogl_translatex (CLUTTER_UNITS_TO_FIXED (priv->allocation.x1), cogl_translate (CLUTTER_UNITS_TO_FLOAT (priv->allocation.x1),
CLUTTER_UNITS_TO_FIXED (priv->allocation.y1), CLUTTER_UNITS_TO_FLOAT (priv->allocation.y1),
0); 0);
/* /*
@ -1360,50 +1363,50 @@ _clutter_actor_apply_modelview_transform (ClutterActor *self)
if (priv->rzang) if (priv->rzang)
{ {
cogl_translatex (CLUTTER_UNITS_TO_FIXED (priv->rzx), cogl_translate (CLUTTER_UNITS_TO_FLOAT (priv->rzx),
CLUTTER_UNITS_TO_FIXED (priv->rzy), CLUTTER_UNITS_TO_FLOAT (priv->rzy),
0); 0);
cogl_rotatex (priv->rzang, 0, 0, 1.0); cogl_rotate (priv->rzang, 0, 0, 1.0);
cogl_translatex (CLUTTER_UNITS_TO_FIXED (-priv->rzx), cogl_translate (CLUTTER_UNITS_TO_FLOAT (-priv->rzx),
CLUTTER_UNITS_TO_FIXED (-priv->rzy), CLUTTER_UNITS_TO_FLOAT (-priv->rzy),
0); 0);
} }
if (priv->ryang) if (priv->ryang)
{ {
cogl_translatex (CLUTTER_UNITS_TO_FIXED (priv->ryx), cogl_translate (CLUTTER_UNITS_TO_FLOAT (priv->ryx),
0, 0,
CLUTTER_UNITS_TO_FIXED (priv->z + priv->ryz)); CLUTTER_UNITS_TO_FLOAT (priv->z + priv->ryz));
cogl_rotatex (priv->ryang, 0, 1.0, 0); cogl_rotate (priv->ryang, 0, 1.0, 0);
cogl_translatex (CLUTTER_UNITS_TO_FIXED (-priv->ryx), cogl_translate (CLUTTER_UNITS_TO_FLOAT (-priv->ryx),
0, 0,
CLUTTER_UNITS_TO_FIXED (-(priv->z + priv->ryz))); CLUTTER_UNITS_TO_FLOAT (-(priv->z + priv->ryz)));
} }
if (priv->rxang) if (priv->rxang)
{ {
cogl_translatex (0, cogl_translate (0,
CLUTTER_UNITS_TO_FIXED (priv->rxy), CLUTTER_UNITS_TO_FLOAT (priv->rxy),
CLUTTER_UNITS_TO_FIXED (priv->z + priv->rxz)); CLUTTER_UNITS_TO_FLOAT (priv->z + priv->rxz));
cogl_rotatex (priv->rxang, 1.0, 0, 0); cogl_rotate (priv->rxang, 1.0, 0, 0);
cogl_translatex (0, cogl_translate (0,
CLUTTER_UNITS_TO_FIXED (-priv->rxy), CLUTTER_UNITS_TO_FLOAT (-priv->rxy),
CLUTTER_UNITS_TO_FIXED (-(priv->z + priv->rxz))); CLUTTER_UNITS_TO_FLOAT (-(priv->z + priv->rxz)));
} }
if (!is_stage && (priv->anchor_x || priv->anchor_y)) if (!is_stage && (priv->anchor_x || priv->anchor_y))
cogl_translatex (CLUTTER_UNITS_TO_FIXED (-priv->anchor_x), cogl_translate (CLUTTER_UNITS_TO_FLOAT (-priv->anchor_x),
CLUTTER_UNITS_TO_FIXED (-priv->anchor_y), CLUTTER_UNITS_TO_FLOAT (-priv->anchor_y),
0); 0);
if (priv->z) if (priv->z)
cogl_translatex (0, 0, priv->z); cogl_translate (0, 0, priv->z);
} }
/* Recursively applies the transforms associated with this actor and /* Recursively applies the transforms associated with this actor and

139
clutter/clutter-alpha.c
View File

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

2
clutter/clutter-alpha.h
View File

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

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

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

2
clutter/clutter-bezier.c
View File

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

4
clutter/clutter-fixed.c
View File

@ -251,8 +251,8 @@ param_fixed_init (GParamSpec *pspec)
{ {
ClutterParamSpecFixed *fspec = CLUTTER_PARAM_SPEC_FIXED (pspec); ClutterParamSpecFixed *fspec = CLUTTER_PARAM_SPEC_FIXED (pspec);
fspec->minimum = COGL_FIXED_MIN; fspec->minimum = CLUTTER_MAXFIXED;
fspec->maximum = COGL_FIXED_MAX; fspec->maximum = CLUTTER_MINFIXED;
fspec->default_value = 0; fspec->default_value = 0;
} }

4
clutter/clutter-path.c
View File

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

2
clutter/clutter-texture.c
View File

@ -474,7 +474,7 @@ clutter_texture_set_fbo_projection (ClutterActor *self)
/* Set up a projection matrix so that the actor will be projected as /* Set up a projection matrix so that the actor will be projected as
if it was drawn at its original location */ if it was drawn at its original location */
tan_angle = tanf (COGL_ANGLE_FROM_DEGX (perspective.fovy / 2 * (G_PI/180.0))); tan_angle = tanf ((perspective.fovy / 2) * (G_PI/180.0));
near_size = CLUTTER_FIXED_MUL (perspective.z_near, tan_angle); near_size = CLUTTER_FIXED_MUL (perspective.z_near, tan_angle);
cogl_frustum (CLUTTER_FIXED_MUL (tx_min, near_size), cogl_frustum (CLUTTER_FIXED_MUL (tx_min, near_size),

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

@ -68,7 +68,7 @@ void cogl_color_set_from_4d (CoglColor *dest,
gdouble alpha); gdouble alpha);
/** /**
* cogl_color_set_from_4x: * cogl_color_set_from_4f:
* @dest: return location for a #CoglColor * @dest: return location for a #CoglColor
* @red: value of the red channel, between 0 and %1.0 * @red: value of the red channel, between 0 and %1.0
* @green: value of the green channel, between 0 and %1.0 * @green: value of the green channel, between 0 and %1.0
@ -79,7 +79,7 @@ void cogl_color_set_from_4d (CoglColor *dest,
* *
* Since: 1.0 * Since: 1.0
*/ */
void cogl_color_set_from_4x (CoglColor *dest, void cogl_color_set_from_4f (CoglColor *dest,
float red, float red,
float green, float green,
float blue, float blue,
@ -248,7 +248,7 @@ float cogl_color_get_alpha (const CoglColor *color);
* Sets the source color using normalized values for each component. * Sets the source color using normalized values for each component.
* This color will be used for any subsequent drawing operation. * This color will be used for any subsequent drawing operation.
* *
* See also cogl_set_source_color4ub() and cogl_set_source_color4x() * See also cogl_set_source_color4ub() and cogl_set_source_color4f()
* if you already have the color components. * if you already have the color components.
* *
* Since: 1.0 * Since: 1.0
@ -276,7 +276,7 @@ void cogl_set_source_color4ub (guint8 red,
guint8 alpha); guint8 alpha);
/** /**
* cogl_set_source_color4x: * cogl_set_source_color4f:
* @red: value of the red channel, between 0 and %1.0 * @red: value of the red channel, between 0 and %1.0
* @green: value of the green 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 * @blue: value of the blue channel, between 0 and %1.0
@ -291,7 +291,7 @@ void cogl_set_source_color4ub (guint8 red,
* *
* Since: 1.0 * Since: 1.0
*/ */
void cogl_set_source_color4x (float red, void cogl_set_source_color4f (float red,
float green, float green,
float blue, float blue,
float alpha); float alpha);

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

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

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

@ -60,21 +60,7 @@ G_BEGIN_DECLS
* Fills a rectangle at the given coordinates with the current * Fills a rectangle at the given coordinates with the current
* drawing color in a highly optimizied fashion. * drawing color in a highly optimizied fashion.
**/ **/
void cogl_rectangle (gint x, void cogl_rectangle (float x,
gint y,
guint width,
guint height);
/**
* cogl_rectanglex:
* @x: X coordinate of the top-left corner
* @y: Y coordinate of the top-left corner
* @width: Width of the rectangle
* @height: Height of the rectangle
*
* A fixed-point version of cogl_fast_fill_rectangle.
**/
void cogl_rectanglex (float x,
float y, float y,
float width, float width,
float height); float height);

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

@ -231,7 +231,7 @@ void cogl_scale (float x,
float y); float y);
/** /**
* cogl_translatex: * cogl_translate:
* @x: Distance to translate along the x-axis * @x: Distance to translate along the x-axis
* @y: Distance to translate along the y-axis * @y: Distance to translate along the y-axis
* @z: Distance to translate along the z-axis * @z: Distance to translate along the z-axis
@ -239,26 +239,12 @@ void cogl_scale (float x,
* Multiplies the current model-view matrix by one that translates the * Multiplies the current model-view matrix by one that translates the
* model along all three axes according to the given values. * model along all three axes according to the given values.
*/ */
void cogl_translatex (float x, void cogl_translate (float x,
float y, float y,
float z); float z);
/** /**
* cogl_translate: * cogl_rotate:
* @x: Distance to translate along the x-axis
* @y: Distance to translate along the y-axis
* @z: Distance to translate along the z-axis
*
* Integer version of cogl_translatex(). Multiplies the current
* model-view matrix by one that translates the model along all three
* axes according to the given values.
*/
void cogl_translate (gint x,
gint y,
gint z);
/**
* cogl_rotatex:
* @angle: Angle in degrees to rotate. * @angle: Angle in degrees to rotate.
* @x: X-component of vertex to rotate around. * @x: X-component of vertex to rotate around.
* @y: Y-component of vertex to rotate around. * @y: Y-component of vertex to rotate around.
@ -270,26 +256,10 @@ void cogl_translate (gint x,
* degrees about the vertex (0, 0, 1) causes a small counter-clockwise * degrees about the vertex (0, 0, 1) causes a small counter-clockwise
* rotation. * rotation.
*/ */
void cogl_rotatex (float angle, void cogl_rotate (float angle,
gint x, float x,
gint y, float y,
gint z); float z);
/**
* cogl_rotate:
* @angle: Angle in degrees to rotate.
* @x: X-component of vertex to rotate around.
* @y: Y-component of vertex to rotate around.
* @z: Z-component of vertex to rotate around.
*
* Integer version of cogl_rotatex(). Multiplies the current
* model-view matrix by one that rotates the model around the vertex
* specified by @x, @y and @z.
*/
void cogl_rotate (gint angle,
gint x,
gint y,
gint z);
/** /**
* cogl_get_modelview_matrix: * cogl_get_modelview_matrix:

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

@ -58,7 +58,7 @@ cogl_color_set_from_4d (CoglColor *dest,
} }
void void
cogl_color_set_from_4x (CoglColor *dest, cogl_color_set_from_4f (CoglColor *dest,
float red, float red,
float green, float green,
float blue, float blue,
@ -157,13 +157,13 @@ cogl_set_source_color4ub (guint8 red,
} }
void void
cogl_set_source_color4x (float red, cogl_set_source_color4f (float red,
float green, float green,
float blue, float blue,
float alpha) float alpha)
{ {
CoglColor c = { 0, }; CoglColor c = { 0, };
cogl_color_set_from_4x (&c, red, green, blue, alpha); cogl_color_set_from_4f (&c, red, green, blue, alpha);
cogl_set_source_color (&c); cogl_set_source_color (&c);
} }

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

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

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

@ -33,6 +33,7 @@
#include <string.h> #include <string.h>
#include <gmodule.h> #include <gmodule.h>
#include <math.h>
#define _COGL_MAX_BEZ_RECURSE_DEPTH 16 #define _COGL_MAX_BEZ_RECURSE_DEPTH 16
@ -42,37 +43,21 @@ void _cogl_path_add_node (gboolean new_sub_path,
float y); float y);
void _cogl_path_fill_nodes (); void _cogl_path_fill_nodes ();
void _cogl_path_stroke_nodes (); void _cogl_path_stroke_nodes ();
void _cogl_rectangle (gint x, void _cogl_rectangle (float x,
gint y,
guint width,
guint height);
void _cogl_rectanglex (float x,
float y, float y,
float width, float width,
float height); float height);
void void
cogl_rectangle (gint x, cogl_rectangle (float x,
gint y,
guint width,
guint height)
{
cogl_clip_ensure ();
_cogl_rectangle (x, y, width, height);
}
void
cogl_rectanglex (float x,
float y, float y,
float width, float width,
float height) float height)
{ {
cogl_clip_ensure (); cogl_clip_ensure ();
_cogl_rectanglex (x, y, width, height); _cogl_rectangle (x, y, width, height);
} }
void void
cogl_path_fill (void) cogl_path_fill (void)
{ {

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

@ -34,26 +34,12 @@
#include <string.h> #include <string.h>
#include <gmodule.h> #include <gmodule.h>
#include <math.h>
#define _COGL_MAX_BEZ_RECURSE_DEPTH 16 #define _COGL_MAX_BEZ_RECURSE_DEPTH 16
void void
_cogl_rectangle (gint x, _cogl_rectangle (float x,
gint y,
guint width,
guint height)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
cogl_enable (ctx->color_alpha < 255
? COGL_ENABLE_BLEND : 0);
GE( glRecti (x, y, x + width, y + height) );
}
void
_cogl_rectanglex (float x,
float y, float y,
float width, float width,
float height) float height)
@ -63,10 +49,7 @@ _cogl_rectanglex (float x,
cogl_enable (ctx->color_alpha < 255 cogl_enable (ctx->color_alpha < 255
? COGL_ENABLE_BLEND : 0); ? COGL_ENABLE_BLEND : 0);
GE( glRectf ( (x), GE( glRectf (x, y, x + width, y + height) );
(y),
(x + width),
(y + height)) );
} }
void void
@ -131,17 +114,15 @@ _cogl_path_stroke_nodes ()
static void static void
_cogl_path_get_bounds (floatVec2 nodes_min, _cogl_path_get_bounds (floatVec2 nodes_min,
floatVec2 nodes_max, floatVec2 nodes_max,
gint *bounds_x, float *bounds_x,
gint *bounds_y, float *bounds_y,
guint *bounds_w, float *bounds_w,
guint *bounds_h) float *bounds_h)
{ {
*bounds_x = floorf (nodes_min.x); *bounds_x = nodes_min.x;
*bounds_y = floorf (nodes_min.y); *bounds_y = nodes_min.y;
*bounds_w = ceilf (nodes_max.x *bounds_w = nodes_max.x - *bounds_x;
- (float)(*bounds_x)); *bounds_h = nodes_max.y - *bounds_y;
*bounds_h = ceilf (nodes_max.y
- (float)(*bounds_y));
} }
void void
@ -153,10 +134,10 @@ _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
{ {
guint path_start = 0; guint path_start = 0;
guint sub_path_num = 0; guint sub_path_num = 0;
gint bounds_x; float bounds_x;
gint bounds_y; float bounds_y;
guint bounds_w; float bounds_w;
guint bounds_h; float bounds_h;
_cogl_path_get_bounds (nodes_min, nodes_max, _cogl_path_get_bounds (nodes_min, nodes_max,
&bounds_x, &bounds_y, &bounds_w, &bounds_h); &bounds_x, &bounds_y, &bounds_w, &bounds_h);
@ -238,10 +219,10 @@ _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
void void
_cogl_path_fill_nodes () _cogl_path_fill_nodes ()
{ {
gint bounds_x; float bounds_x;
gint bounds_y; float bounds_y;
guint bounds_w; float bounds_w;
guint bounds_h; float bounds_h;
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);

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

@ -37,6 +37,7 @@
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h>
/* /*
#define COGL_DEBUG 1 #define COGL_DEBUG 1
@ -555,7 +556,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
guint wx, wy; guint wx, wy;
src = source_bmp->data src = source_bmp->data
+ (src_y + (y_iter.intersect_start) + (src_y + ((int)y_iter.intersect_start)
- dst_y) - dst_y)
* source_bmp->rowstride * source_bmp->rowstride
+ (src_x + x_span->start + x_span->size - x_span->waste + (src_x + x_span->start + x_span->size - x_span->waste
@ -600,7 +601,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
guint copy_width; guint copy_width;
src = source_bmp->data src = source_bmp->data
+ (src_x + (x_iter.intersect_start) + (src_x + ((int)x_iter.intersect_start)
- dst_x) - dst_x)
* bpp * bpp
+ (src_y + y_span->start + y_span->size - y_span->waste + (src_y + y_span->start + y_span->size - y_span->waste

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

@ -211,38 +211,21 @@ cogl_pop_matrix (void)
void void
cogl_scale (float x, float y) cogl_scale (float x, float y)
{ {
glScaled ((double)(x), glScalef ((float)(x),
(double)(y), (float)(y),
1.0); 1.0);
} }
void void
cogl_translatex (float x, float y, float z) cogl_translate (float x, float y, float z)
{ {
glTranslated ((double)(x), glTranslatef (x, y, z);
(double)(y),
(double)(z));
} }
void void
cogl_translate (gint x, gint y, gint z) cogl_rotate (float angle, float x, float y, float z)
{ {
glTranslatef ((float)x, (float)y, (float)z); glRotatef (angle, x, y, z);
}
void
cogl_rotatex (float angle, gint x, gint y, gint z)
{
glRotated ((double)(angle),
(double)(x),
(double)(y),
(double)(z));
}
void
cogl_rotate (gint angle, gint x, gint y, gint z)
{
glRotatef ((float)angle, (float)x, (float)y, (float)z);
} }
static inline gboolean static inline gboolean
@ -645,17 +628,13 @@ cogl_perspective (float fovy,
* 2) When working with small numbers, we are loosing significant * 2) When working with small numbers, we are loosing significant
* precision * precision
*/ */
ymax = ymax = (zNear * (sinf (fovy_rad_half) / cosf (fovy_rad_half)));
(zNear *
(sinf (fovy_rad_half) /
cosf (fovy_rad_half)));
xmax = (ymax * aspect); xmax = (ymax * aspect);
x = (zNear / xmax); x = (zNear / xmax);
y = (zNear / ymax); y = (zNear / ymax);
c = (-(zFar + zNear) / ( zFar - zNear)); c = (-(zFar + zNear) / ( zFar - zNear));
d = cogl_fixed_mul_div (-(2 * zFar), zNear, (zFar - zNear)); d = (-(2 * zFar) * zNear) / (zFar - zNear);
#define M(row,col) m[col*4+row] #define M(row,col) m[col*4+row]
M(0,0) = (x); M(0,0) = (x);
@ -696,12 +675,12 @@ cogl_frustum (float left,
GE( glMatrixMode (GL_PROJECTION) ); GE( glMatrixMode (GL_PROJECTION) );
GE( glLoadIdentity () ); GE( glLoadIdentity () );
GE( glFrustum ((double)(left), GE( glFrustum ((GLdouble)(left),
(double)(right), (GLdouble)(right),
(double)(bottom), (GLdouble)(bottom),
(double)(top), (GLdouble)(top),
(double)(z_near), (GLdouble)(z_near),
(double)(z_far)) ); (GLdouble)(z_far)) );
GE( glMatrixMode (GL_MODELVIEW) ); GE( glMatrixMode (GL_MODELVIEW) );
@ -773,9 +752,7 @@ cogl_setup_viewport (guint width,
{ {
float fovy_rad = (fovy * G_PI) / 180; float fovy_rad = (fovy * G_PI) / 180;
z_camera = z_camera = ((sinf (fovy_rad) / cosf (fovy_rad)) / 2);
((sinf (fovy_rad) /
cosf (fovy_rad)) >> 1);
} }
GE( glTranslatef (-0.5f, -0.5f, -z_camera) ); GE( glTranslatef (-0.5f, -0.5f, -z_camera) );
@ -1166,73 +1143,19 @@ cogl_features_available (CoglFeatureFlags features)
void void
cogl_get_modelview_matrix (float m[16]) cogl_get_modelview_matrix (float m[16])
{ {
GLdouble md[16]; glGetFloatv (GL_MODELVIEW_MATRIX, m);
glGetDoublev(GL_MODELVIEW_MATRIX, &md[0]);
#define M(m,row,col) m[col*4+row]
M(m,0,0) = (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 void
cogl_get_projection_matrix (float m[16]) cogl_get_projection_matrix (float m[16])
{ {
GLdouble md[16]; glGetFloatv (GL_PROJECTION_MATRIX, m);
glGetDoublev(GL_PROJECTION_MATRIX, &md[0]);
#define M(m,row,col) m[col*4+row]
M(m,0,0) = (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 void
cogl_get_viewport (float v[4]) cogl_get_viewport (float v[4])
{ {
GLdouble vd[4]; glGetFloatv (GL_VIEWPORT, v);
glGetDoublev(GL_VIEWPORT, &vd[0]);
v[0] = (vd[0]);
v[1] = (vd[1]);
v[2] = (vd[2]);
v[3] = (vd[3]);
} }
void void

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

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

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

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

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

@ -34,59 +34,31 @@
#include <string.h> #include <string.h>
#include <gmodule.h> #include <gmodule.h>
#include <math.h>
#define _COGL_MAX_BEZ_RECURSE_DEPTH 16 #define _COGL_MAX_BEZ_RECURSE_DEPTH 16
void void
_cogl_rectangle (gint x, _cogl_rectangle (float x,
gint y, float y,
guint width, float width,
guint height) float height)
{ {
/* 32-bit integers are not supported as coord types GLfloat rect_verts[8] = {
in GLES . Fixed type has got 16 bits left of the (GLfloat) x, (GLfloat) y,
point which is equal to short anyway. */ (GLfloat) (x + width), (GLfloat) y,
(GLfloat) x, (GLfloat) (y + height),
GLshort rect_verts[8] = { (GLfloat) (x + width), (GLfloat) (y + height)
(GLshort) x, (GLshort) y,
(GLshort) (x + width), (GLshort) y,
(GLshort) x, (GLshort) (y + height),
(GLshort) (x + width), (GLshort) (y + height)
}; };
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
cogl_enable (COGL_ENABLE_VERTEX_ARRAY cogl_enable (COGL_ENABLE_VERTEX_ARRAY
| (ctx->color_alpha < 255 ? COGL_ENABLE_BLEND : 0)); | (ctx->color_alpha < 255 ? COGL_ENABLE_BLEND : 0));
GE ( cogl_wrap_glVertexPointer (2, GL_SHORT, 0, rect_verts ) ); GE ( cogl_wrap_glVertexPointer (2, GL_FLOAT, 0, rect_verts ) );
GE ( cogl_wrap_glDrawArrays (GL_TRIANGLE_STRIP, 0, 4) ); GE ( cogl_wrap_glDrawArrays (GL_TRIANGLE_STRIP, 0, 4) );
} }
void
_cogl_rectanglex (float x,
float y,
float width,
float height)
{
GLfloat rect_verts[8] = {
x, y,
x + width, y,
x, y + height,
x + width, y + height
};
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
cogl_enable (COGL_ENABLE_VERTEX_ARRAY
| (ctx->color_alpha < 255
? COGL_ENABLE_BLEND : 0));
GE( cogl_wrap_glVertexPointer (2, GL_FIXED, 0, rect_verts) );
GE( cogl_wrap_glDrawArrays (GL_TRIANGLE_STRIP, 0, 4) );
}
void void
_cogl_path_add_node (gboolean new_sub_path, _cogl_path_add_node (gboolean new_sub_path,
float x, float x,
@ -149,17 +121,15 @@ _cogl_path_stroke_nodes ()
static void static void
_cogl_path_get_bounds (floatVec2 nodes_min, _cogl_path_get_bounds (floatVec2 nodes_min,
floatVec2 nodes_max, floatVec2 nodes_max,
gint *bounds_x, float *bounds_x,
gint *bounds_y, float *bounds_y,
guint *bounds_w, float *bounds_w,
guint *bounds_h) float *bounds_h)
{ {
*bounds_x = floorf (nodes_min.x); *bounds_x = nodes_min.x;
*bounds_y = floorf (nodes_min.y); *bounds_y = nodes_min.y;
*bounds_w = ceilf (nodes_max.x *bounds_w = nodes_max.x - *bounds_x;
- (float)(*bounds_x)); *bounds_h = nodes_max.y - *bounds_y;
*bounds_h = ceilf (nodes_max.y
- (float)(*bounds_y));
} }
static gint compare_ints (gconstpointer a, static gint compare_ints (gconstpointer a,
@ -177,10 +147,10 @@ _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
{ {
guint path_start = 0; guint path_start = 0;
guint sub_path_num = 0; guint sub_path_num = 0;
gint bounds_x; float bounds_x;
gint bounds_y; float bounds_y;
guint bounds_w; float bounds_w;
guint bounds_h; float bounds_h;
_cogl_path_get_bounds (nodes_min, nodes_max, _cogl_path_get_bounds (nodes_min, nodes_max,
&bounds_x, &bounds_y, &bounds_w, &bounds_h); &bounds_x, &bounds_y, &bounds_w, &bounds_h);
@ -244,12 +214,8 @@ _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) ); GE( cogl_wrap_glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glPushMatrix () ); GE( cogl_wrap_glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () ); GE( cogl_wrap_glLoadIdentity () );
cogl_rectanglex (-1.0, -1.0, cogl_rectangle (-1.0, -1.0, 2, 2);
(float)(2), cogl_rectangle (-1.0, -1.0, 2, 2);
(float)(2));
cogl_rectanglex (-1.0, -1.0,
(float)(2),
(float)(2));
GE( cogl_wrap_glPopMatrix () ); GE( cogl_wrap_glPopMatrix () );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) ); GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPopMatrix () ); GE( cogl_wrap_glPopMatrix () );
@ -435,10 +401,10 @@ _cogl_path_fill_nodes_scanlines (CoglPathNode *path,
void void
_cogl_path_fill_nodes () _cogl_path_fill_nodes ()
{ {
gint bounds_x; float bounds_x;
gint bounds_y; float bounds_y;
guint bounds_w; float bounds_w;
guint bounds_h; float bounds_h;
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);

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

@ -39,6 +39,7 @@
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h>
#define glVertexPointer cogl_wrap_glVertexPointer #define glVertexPointer cogl_wrap_glVertexPointer
#define glTexCoordPointer cogl_wrap_glTexCoordPointer #define glTexCoordPointer cogl_wrap_glTexCoordPointer
@ -768,7 +769,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
guint wx, wy; guint wx, wy;
src = source_bmp->data src = source_bmp->data
+ (src_y + (y_iter.intersect_start) + (src_y + ((int)y_iter.intersect_start)
- dst_y) - dst_y)
* source_bmp->rowstride * source_bmp->rowstride
+ (src_x + x_span->start + x_span->size - x_span->waste + (src_x + x_span->start + x_span->size - x_span->waste
@ -813,7 +814,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
guint copy_width; guint copy_width;
src = source_bmp->data src = source_bmp->data
+ (src_x + (x_iter.intersect_start) + (src_x + ((int)x_iter.intersect_start)
- dst_x) - dst_x)
* bpp * bpp
+ (src_y + y_span->start + y_span->size - y_span->waste + (src_y + y_span->start + y_span->size - y_span->waste

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

@ -37,6 +37,7 @@
#include "cogl-context.h" #include "cogl-context.h"
#include "cogl-gles2-wrapper.h" #include "cogl-gles2-wrapper.h"
#include <math.h>
/* GL error to string conversion */ /* GL error to string conversion */
#if COGL_DEBUG #if COGL_DEBUG
@ -92,7 +93,7 @@ cogl_paint_init (const CoglColor *color)
fprintf(stderr, "\n ============== Paint Start ================ \n"); fprintf(stderr, "\n ============== Paint Start ================ \n");
#endif #endif
cogl_wrap_glClearColorx (cogl_color_get_red (color), glClearColor (cogl_color_get_red (color),
cogl_color_get_green (color), cogl_color_get_green (color),
cogl_color_get_blue (color), cogl_color_get_blue (color),
0); 0);
@ -122,37 +123,17 @@ cogl_scale (float x, float y)
} }
void void
cogl_translatex (float x, float y, float z) cogl_translate (float x, float y, float z)
{ {
GE( cogl_wrap_glTranslatef (x, y, z) ); GE( cogl_wrap_glTranslatef (x, y, z) );
} }
void void
cogl_translate (gint x, gint y, gint z) cogl_rotate (float angle, float x, float y, float z)
{
GE( cogl_wrap_glTranslatef ((float)(x),
(float)(y),
(float)(z)) );
}
void
cogl_rotatex (float angle,
float x,
float y,
float z)
{ {
GE( cogl_wrap_glRotatef (angle, x, y, z) ); GE( cogl_wrap_glRotatef (angle, x, y, z) );
} }
void
cogl_rotate (gint angle, gint x, gint y, gint z)
{
GE( cogl_wrap_glRotatef ((float)(angle),
(float)(x),
(float)(y),
(float)(z)) );
}
static inline gboolean static inline gboolean
cogl_toggle_flag (CoglContext *ctx, cogl_toggle_flag (CoglContext *ctx,
gulong new_flags, gulong new_flags,
@ -365,9 +346,8 @@ set_clip_plane (GLint plane_num,
/* Calculate the angle between the axes and the line crossing the /* Calculate the angle between the axes and the line crossing the
two points */ two points */
angle = (atan2f (vertex_b[1] - vertex_a[1] * angle = atan2f (vertex_b[1] - vertex_a[1],
vertex_b[0] - vertex_a[0]), vertex_b[0] - vertex_a[0]) * (180.0/G_PI);
COGL_RADIANS_TO_DEGREES);
GE( cogl_wrap_glPushMatrix () ); GE( cogl_wrap_glPushMatrix () );
/* Load the identity matrix and multiply by the reverse of the /* Load the identity matrix and multiply by the reverse of the
@ -405,8 +385,8 @@ _cogl_set_clip_planes (float x_offset,
float vertex_br[4] = { x_offset + width, y_offset + height, float vertex_br[4] = { x_offset + width, y_offset + height,
0, 1.0 }; 0, 1.0 };
GE( cogl_wrap_glGetFixedv (GL_MODELVIEW_MATRIX, modelview) ); GE( cogl_wrap_glGetFloatv (GL_MODELVIEW_MATRIX, modelview) );
GE( cogl_wrap_glGetFixedv (GL_PROJECTION_MATRIX, projection) ); GE( cogl_wrap_glGetFloatv (GL_PROJECTION_MATRIX, projection) );
project_vertex (modelview, projection, vertex_tl); project_vertex (modelview, projection, vertex_tl);
project_vertex (modelview, projection, vertex_tr); project_vertex (modelview, projection, vertex_tr);
@ -457,7 +437,7 @@ _cogl_add_stencil_clip (float x_offset,
GE( glStencilFunc (GL_NEVER, 0x1, 0x1) ); GE( glStencilFunc (GL_NEVER, 0x1, 0x1) );
GE( glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE) ); GE( glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE) );
cogl_rectanglex (x_offset, y_offset, width, height); cogl_rectangle (x_offset, y_offset, width, height);
} }
else else
{ {
@ -465,7 +445,7 @@ _cogl_add_stencil_clip (float x_offset,
rectangle */ rectangle */
GE( glStencilFunc (GL_NEVER, 0x1, 0x3) ); GE( glStencilFunc (GL_NEVER, 0x1, 0x3) );
GE( glStencilOp (GL_INCR, GL_INCR, GL_INCR) ); GE( glStencilOp (GL_INCR, GL_INCR, GL_INCR) );
cogl_rectanglex (x_offset, y_offset, width, height); cogl_rectangle (x_offset, y_offset, width, height);
/* Subtract one from all pixels in the stencil buffer so that /* Subtract one from all pixels in the stencil buffer so that
only pixels where both the original stencil buffer and the only pixels where both the original stencil buffer and the
@ -476,9 +456,7 @@ _cogl_add_stencil_clip (float x_offset,
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) ); GE( cogl_wrap_glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glPushMatrix () ); GE( cogl_wrap_glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () ); GE( cogl_wrap_glLoadIdentity () );
cogl_rectanglex (-1.0, -1.0, cogl_rectangle (-1.0, -1.0, 2, 2);
(float)(2),
(float)(2));
GE( cogl_wrap_glPopMatrix () ); GE( cogl_wrap_glPopMatrix () );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) ); GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPopMatrix () ); GE( cogl_wrap_glPopMatrix () );
@ -558,15 +536,13 @@ cogl_perspective (float fovy,
* 2) When working with small numbers, we can are loosing significant * 2) When working with small numbers, we can are loosing significant
* precision * precision
*/ */
ymax = (zNear * ymax = (zNear * (sinf (fovy_rad_half) / cosf (fovy_rad_half)));
(sinf (fovy_rad_half) /
cosf (fovy_rad_half)));
xmax = (ymax * aspect); xmax = (ymax * aspect);
x = (zNear / xmax); x = (zNear / xmax);
y = (zNear / ymax); y = (zNear / ymax);
c = (-(zFar + zNear) / ( zFar - zNear)); c = (-(zFar + zNear) / ( zFar - zNear));
d = (-((2 * zFar * zNear)) / (zFar - zNear)); d = (-(2 * zFar) * zNear) / (zFar - zNear);
#define M(row,col) m[col*4+row] #define M(row,col) m[col*4+row]
M(0,0) = x; M(0,0) = x;
@ -672,12 +648,12 @@ cogl_setup_viewport (guint w,
{ {
float fovy_rad = (fovy * G_PI) / 180; float fovy_rad = (fovy * G_PI) / 180;
z_camera = (sinf (fovy_rad) / z_camera = (sinf (fovy_rad) / cosf (fovy_rad)) / 2;
cosf (fovy_rad)) >> 1;
} }
GE( cogl_wrap_glTranslatef (-1 << 15, -1 << 15, -z_camera) );
GE( cogl_wrap_glTranslatef (-0.5f, -0.5f, -z_camera) );
GE( cogl_wrap_glScalef ( 1.0 / width, GE( cogl_wrap_glScalef ( 1.0 / width,
-1.0 / height, -1.0 / height,
@ -737,13 +713,13 @@ cogl_features_available (CoglFeatureFlags features)
void void
cogl_get_modelview_matrix (float m[16]) cogl_get_modelview_matrix (float m[16])
{ {
cogl_wrap_glGetFixedv(GL_MODELVIEW_MATRIX, &m[0]); cogl_wrap_glGetFloatv (GL_MODELVIEW_MATRIX, m);
} }
void void
cogl_get_projection_matrix (float m[16]) cogl_get_projection_matrix (float m[16])
{ {
cogl_wrap_glGetFixedv(GL_PROJECTION_MATRIX, &m[0]); cogl_wrap_glGetFloatv (GL_PROJECTION_MATRIX, m);
} }
void void

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

@ -102,8 +102,6 @@ cogl_pango_renderer_draw_glyph (CoglPangoRenderer *priv,
*(p++) = cache_value->tx2; *(p++) = cache_value->ty2; *(p++) = cache_value->tx2; *(p++) = cache_value->ty2;
} }
#define COGL_PANGO_UNIT_TO_FIXED(x) ((x) << (COGL_FIXED_Q - 10))
static void cogl_pango_renderer_finalize (GObject *object); static void cogl_pango_renderer_finalize (GObject *object);
static void cogl_pango_renderer_draw_glyphs (PangoRenderer *renderer, static void cogl_pango_renderer_draw_glyphs (PangoRenderer *renderer,
PangoFont *font, PangoFont *font,
@ -439,8 +437,8 @@ cogl_pango_renderer_get_device_units (PangoRenderer *renderer,
} }
else else
{ {
*xout = COGL_PANGO_UNIT_TO_FIXED (xin); *xout = PANGO_PIXELS (xin);
*yout = COGL_PANGO_UNIT_TO_FIXED (yin); *yout = PANGO_PIXELS (yin);
} }
} }
@ -463,7 +461,7 @@ cogl_pango_renderer_draw_rectangle (PangoRenderer *renderer,
x + width, y + height, x + width, y + height,
&x2, &y2); &x2, &y2);
cogl_rectanglex (x1, y1, x2 - x1, y2 - y1); cogl_rectangle (x1, y1, x2 - x1, y2 - y1);
} }
static void static void

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

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

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

@ -121,7 +121,7 @@ on_paint (ClutterActor *actor, TestState *state)
/* Set the color to white so that all the textures will be drawn /* Set the color to white so that all the textures will be drawn
at their own color */ at their own color */
cogl_set_source_color4x (1.0, 1.0, cogl_set_source_color4f (1.0, 1.0,
1.0, 1.0); 1.0, 1.0);
x2 = x1 + (float)(TEXTURE_SIZE); x2 = x1 + (float)(TEXTURE_SIZE);
@ -173,7 +173,7 @@ on_paint (ClutterActor *actor, TestState *state)
x2 = x1 + (float)(TEXTURE_SIZE); x2 = x1 + (float)(TEXTURE_SIZE);
/* Draw a regular rectangle (this should always show) */ /* Draw a regular rectangle (this should always show) */
cogl_set_source_color4x (1.0, 0, 0, 1.0); cogl_set_source_color4f (1.0, 0, 0, 1.0);
cogl_rectangle ( (x1), (y1), cogl_rectangle ( (x1), (y1),
(x2 - x1), (y2 - y1)); (x2 - x1), (y2 - y1));

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

@ -90,14 +90,14 @@ test_coglbox_paint(ClutterActor *self)
ClutterFixed sin_frame, cos_frame; ClutterFixed sin_frame, cos_frame;
ClutterFixed frac_frame; ClutterFixed frac_frame;
gint t; gint t;
sin_frame = clutter_sini (CLUTTER_ANGLE_FROM_DEG (priv->frame)); sin_frame = clutter_sinx (priv->frame);
cos_frame = clutter_cosi (CLUTTER_ANGLE_FROM_DEG (priv->frame)); cos_frame = clutter_cosx (priv->frame);
pingpong_frame = (priv->frame <= 180 ? priv->frame : 360 - priv->frame); pingpong_frame = (priv->frame <= 180 ? priv->frame : 360 - priv->frame);
frac_frame = (CLUTTER_INT_TO_FIXED (pingpong_frame) / frac_frame = (CLUTTER_INT_TO_FIXED (pingpong_frame) /
CLUTTER_INT_TO_FIXED (180)); CLUTTER_INT_TO_FIXED (180));
frac_frame += (1.0 >> 1); frac_frame += 0.5;
frac_frame <<= 1; frac_frame *= 2;
for (t=0; t<4; t+=2) for (t=0; t<4; t+=2)
{ {