diff --git a/cogl-color.h b/cogl-color.h index fbc49d5bb..6cdf52bd9 100644 --- a/cogl-color.h +++ b/cogl-color.h @@ -70,20 +70,20 @@ void cogl_color_set_from_4d (CoglColor *dest, /** * 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: @@ -194,52 +194,52 @@ float cogl_color_get_alpha_float (const CoglColor *color); * @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: @@ -277,24 +277,24 @@ void cogl_set_source_color4ub (guint8 red, /** * 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 diff --git a/cogl-path.h b/cogl-path.h index 20632da37..0d2982923 100644 --- a/cogl-path.h +++ b/cogl-path.h @@ -74,10 +74,10 @@ void cogl_rectangle (gint x, * * 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: @@ -136,8 +136,8 @@ void cogl_path_new (void); * 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); /** @@ -149,8 +149,8 @@ void cogl_path_move_to (CoglFixed x, * 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: @@ -160,8 +160,8 @@ void cogl_path_rel_move_to (CoglFixed x, * 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: @@ -171,8 +171,8 @@ void cogl_path_line_to (CoglFixed x, * Adds a straight line segment to the current path that ends at the * given coordinates relative to the current pen location. **/ -void cogl_path_rel_line_to (CoglFixed x, - CoglFixed y); +void cogl_path_rel_line_to (float x, + float y); /** @@ -189,12 +189,12 @@ void cogl_path_rel_line_to (CoglFixed x, * of the arc. If you perform a move_to to the arcs start just before * drawing it you create a free standing arc. **/ -void cogl_path_arc (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); @@ -211,12 +211,12 @@ void cogl_path_arc (CoglFixed center_x, * 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: @@ -232,12 +232,12 @@ void cogl_path_curve_to (CoglFixed x1, * 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: @@ -258,10 +258,10 @@ void cogl_path_close (void); * 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: @@ -281,7 +281,7 @@ void cogl_path_line (CoglFixed x1, * 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); @@ -299,7 +299,7 @@ void cogl_path_polyline (CoglFixed *coords, * 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); @@ -313,10 +313,10 @@ void cogl_path_polygon (CoglFixed *coords, * 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: @@ -328,10 +328,10 @@ void cogl_path_rectangle (CoglFixed x, * 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: @@ -346,12 +346,12 @@ void cogl_path_ellipse (CoglFixed center_x, * 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 diff --git a/cogl-texture.h b/cogl-texture.h index cee2f439e..5ae3e2839 100644 --- a/cogl-texture.h +++ b/cogl-texture.h @@ -368,14 +368,14 @@ void cogl_texture_unref (CoglHandle handle); * texture pass in @tx1=0.0 @ty1=0.0 @tx2=1.0 @ty2=1.0. */ 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: @@ -455,7 +455,7 @@ void cogl_bitmap_free (CoglBitmap *bmp); * significant performance boost to use this function rather than * calling cogl_texture_rectangle() separately for each rectangle. * - * @verts should point to an array of #CoglFixeds with + * @verts should point to an array of #floats 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(). @@ -464,7 +464,7 @@ void cogl_bitmap_free (CoglBitmap *bmp); */ void cogl_texture_multiple_rectangles (CoglHandle handle, - const CoglFixed *verts, + const float *verts, guint n_rects); G_END_DECLS diff --git a/cogl-types.h b/cogl-types.h index ece3270b7..b11091a95 100644 --- a/cogl-types.h +++ b/cogl-types.h @@ -264,8 +264,8 @@ struct _CoglColor */ struct _CoglTextureVertex { - CoglFixed x, y, z; - CoglFixed tx, ty; + float x, y, z; + float tx, ty; CoglColor color; }; diff --git a/cogl.h.in b/cogl.h.in index ea81c7b2c..cc26f882f 100644 --- a/cogl.h.in +++ b/cogl.h.in @@ -143,10 +143,10 @@ void cogl_get_bitmasks (gint *red, * 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: @@ -162,12 +162,12 @@ void cogl_perspective (CoglFixed fovy, * * 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: @@ -187,10 +187,10 @@ void cogl_frustum (CoglFixed left, */ 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: @@ -227,8 +227,8 @@ void cogl_pop_matrix (void); * Multiplies the current model-view matrix by one that scales the x * and y axes by the given values. */ -void cogl_scale (CoglFixed x, - CoglFixed y); +void cogl_scale (float x, + float y); /** * cogl_translatex: @@ -239,9 +239,9 @@ void cogl_scale (CoglFixed x, * Multiplies the current model-view matrix by one that translates the * model along all three axes according to the given values. */ -void cogl_translatex (CoglFixed x, - CoglFixed y, - CoglFixed z); +void cogl_translatex (float x, + float y, + float z); /** * cogl_translate: @@ -270,7 +270,7 @@ void cogl_translate (gint x, * 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); @@ -293,32 +293,32 @@ void cogl_rotate (gint angle, /** * cogl_get_modelview_matrix: - * @m: pointer to a 4x4 array of #CoglFixeds to receive the matrix + * @m: pointer to a 4x4 array of #floats 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 #CoglFixeds to receive the matrix + * @m: pointer to a 4x4 array of #floats 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 #CoglFixeds to + * @v: pointer to a 4 element array of #floats 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: @@ -336,10 +336,10 @@ void cogl_get_viewport (CoglFixed v[4]); * 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: @@ -443,7 +443,7 @@ void cogl_enable_backface_culling (gboolean setting); * initial reference value is 1.0. */ void cogl_alpha_func (COGLenum func, - CoglFixed ref); + float ref); /** * cogl_fog_set: @@ -460,9 +460,9 @@ void cogl_alpha_func (COGLenum func, * 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: diff --git a/common/cogl-clip-stack.c b/common/cogl-clip-stack.c index c533b0b4c..9d8a623e9 100644 --- a/common/cogl-clip-stack.c +++ b/common/cogl-clip-stack.c @@ -35,24 +35,24 @@ /* 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; @@ -75,13 +75,13 @@ struct _CoglClipStackEntryRect 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 @@ -89,20 +89,20 @@ 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; diff --git a/common/cogl-color.c b/common/cogl-color.c index a248b95c9..dac35849d 100644 --- a/common/cogl-color.c +++ b/common/cogl-color.c @@ -59,17 +59,17 @@ cogl_color_set_from_4d (CoglColor *dest, 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 @@ -84,10 +84,10 @@ cogl_color_get_red_float (const CoglColor *color) 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 @@ -102,10 +102,10 @@ cogl_color_get_green_float (const CoglColor *color) 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 @@ -120,10 +120,10 @@ cogl_color_get_blue_float (const CoglColor *color) 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 @@ -138,10 +138,10 @@ cogl_color_get_alpha_float (const CoglColor *color) 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 @@ -157,10 +157,10 @@ cogl_set_source_color4ub (guint8 red, } 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, }; diff --git a/common/cogl-primitives.c b/common/cogl-primitives.c index a063331f2..27e0e36a7 100644 --- a/common/cogl-primitives.c +++ b/common/cogl-primitives.c @@ -38,18 +38,18 @@ /* 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, @@ -62,10 +62,10 @@ cogl_rectangle (gint x, } void -cogl_rectanglex (CoglFixed x, - CoglFixed y, - CoglFixed width, - CoglFixed height) +cogl_rectanglex (float x, + float y, + float width, + float height) { cogl_clip_ensure (); @@ -116,8 +116,8 @@ cogl_path_stroke_preserve (void) } void -cogl_path_move_to (CoglFixed x, - CoglFixed y) +cogl_path_move_to (float x, + float y) { _COGL_GET_CONTEXT (ctx, NO_RETVAL); @@ -132,8 +132,8 @@ cogl_path_move_to (CoglFixed x, } 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); @@ -142,8 +142,8 @@ cogl_path_rel_move_to (CoglFixed x, } void -cogl_path_line_to (CoglFixed x, - CoglFixed y) +cogl_path_line_to (float x, + float y) { _COGL_GET_CONTEXT (ctx, NO_RETVAL); @@ -154,8 +154,8 @@ cogl_path_line_to (CoglFixed x, } 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); @@ -181,17 +181,17 @@ cogl_path_new (void) } 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; @@ -203,7 +203,7 @@ cogl_path_polyline (CoglFixed *coords, } void -cogl_path_polygon (CoglFixed *coords, +cogl_path_polygon (float *coords, gint num_points) { cogl_path_polyline (coords, num_points); @@ -211,10 +211,10 @@ cogl_path_polygon (CoglFixed *coords, } 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); @@ -224,20 +224,20 @@ cogl_path_rectangle (CoglFixed x, } 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 */ @@ -252,11 +252,11 @@ _cogl_path_arc (CoglFixed center_x, 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); @@ -279,24 +279,24 @@ _cogl_path_arc (CoglFixed center_x, /* 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 */ @@ -308,13 +308,13 @@ cogl_path_arc (CoglFixed center_x, 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); @@ -326,50 +326,50 @@ cogl_path_arc_rel (CoglFixed center_x, } 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, @@ -377,16 +377,16 @@ cogl_path_round_rectangle (CoglFixed 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 (); @@ -400,14 +400,14 @@ _cogl_path_bezier3_sub (CoglBezCubic *cubic) 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 */ @@ -418,16 +418,13 @@ _cogl_path_bezier3_sub (CoglBezCubic *cubic) { 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; @@ -438,16 +435,13 @@ _cogl_path_bezier3_sub (CoglBezCubic *cubic) 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) */ @@ -465,20 +459,20 @@ _cogl_path_bezier3_sub (CoglBezCubic *cubic) 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; @@ -495,12 +489,12 @@ _cogl_path_bezier3_sub (CoglBezCubic *cubic) } 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; @@ -524,12 +518,12 @@ cogl_path_curve_to (CoglFixed x1, } 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); @@ -554,11 +548,11 @@ _cogl_path_bezier2_sub (CoglBezQuad *quad) 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 */ @@ -573,15 +567,15 @@ _cogl_path_bezier2_sub (CoglBezQuad *quad) /* 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) */ @@ -594,12 +588,12 @@ _cogl_path_bezier2_sub (CoglBezQuad *quad) 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; @@ -614,10 +608,10 @@ _cogl_path_bezier2_sub (CoglBezQuad *quad) } 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); @@ -639,10 +633,10 @@ cogl_path_curve2_to (CoglFixed x1, } 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); diff --git a/common/cogl-primitives.h b/common/cogl-primitives.h index 01905d611..0a54ec145 100644 --- a/common/cogl-primitives.h +++ b/common/cogl-primitives.h @@ -26,15 +26,15 @@ #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 @@ -67,17 +67,17 @@ struct _CoglPathNode 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 */ diff --git a/gl/cogl-context.h b/gl/cogl-context.h index d49330763..ec8d85e03 100644 --- a/gl/cogl-context.h +++ b/gl/cogl-context.h @@ -51,12 +51,12 @@ typedef struct 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]; diff --git a/gl/cogl-primitives.c b/gl/cogl-primitives.c index ca46d85ac..dc5c5c62a 100644 --- a/gl/cogl-primitives.c +++ b/gl/cogl-primitives.c @@ -53,33 +53,33 @@ _cogl_rectangle (gint x, 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) @@ -129,24 +129,24 @@ _cogl_path_stroke_nodes () } 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) diff --git a/gl/cogl-texture.c b/gl/cogl-texture.c index 4c30639a9..5b7326cc7 100644 --- a/gl/cogl-texture.c +++ b/gl/cogl-texture.c @@ -54,15 +54,15 @@ struct _CoglSpanIter 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; }; @@ -102,7 +102,7 @@ _cogl_span_iter_update (CoglSpanIter *iter) /* 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 || @@ -131,9 +131,9 @@ _cogl_span_iter_update (CoglSpanIter *iter) 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; @@ -471,8 +471,8 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex, /* Iterate vertical spans */ for (source_y = src_y, _cogl_span_iter_begin (&y_iter, tex->slice_y_spans, - 0, 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); @@ -492,8 +492,8 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex, /* Iterate horizontal spans */ for (source_x = src_x, _cogl_span_iter_begin (&x_iter, tex->slice_x_spans, - 0, 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); @@ -511,15 +511,15 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex, 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 */ @@ -555,7 +555,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex, 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 @@ -600,7 +600,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex, 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 @@ -2010,24 +2010,24 @@ _cogl_texture_add_quad_vertices (GLfloat x1, GLfloat y1, 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); @@ -2050,7 +2050,7 @@ _cogl_texture_quad_sw (CoglTexture *tex, slices */ if (tx2 < tx1) { - CoglFixed temp = x1; + float temp = x1; x1 = x2; x2 = temp; temp = tx1; @@ -2059,7 +2059,7 @@ _cogl_texture_quad_sw (CoglTexture *tex, } if (ty2 < ty1) { - CoglFixed temp = y1; + float temp = y1; y1 = y2; y2 = temp; temp = ty1; @@ -2068,27 +2068,27 @@ _cogl_texture_quad_sw (CoglTexture *tex, } /* 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 */ @@ -2102,10 +2102,10 @@ _cogl_texture_quad_sw (CoglTexture *tex, /* 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; @@ -2130,10 +2130,10 @@ _cogl_texture_quad_sw (CoglTexture *tex, /* 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; @@ -2149,14 +2149,14 @@ _cogl_texture_quad_sw (CoglTexture *tex, #if COGL_DEBUG printf("~~~~~ slice (%d,%d)\n", iter_x.index, iter_y.index); - printf("qx1: %f\n", 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 */ @@ -2172,28 +2172,28 @@ _cogl_texture_quad_sw (CoglTexture *tex, 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; @@ -2209,10 +2209,10 @@ _cogl_texture_quad_hw (CoglTexture *tex, /* 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; @@ -2251,19 +2251,19 @@ _cogl_texture_quad_hw (CoglTexture *tex, 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; @@ -2314,10 +2314,10 @@ cogl_texture_multiple_rectangles (CoglHandle handle, 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 @@ -2333,16 +2333,16 @@ cogl_texture_multiple_rectangles (CoglHandle handle, 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; @@ -2455,16 +2455,16 @@ cogl_texture_polygon (CoglHandle handle, 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); diff --git a/gl/cogl.c b/gl/cogl.c index 411cd8adc..7b61b6353 100644 --- a/gl/cogl.c +++ b/gl/cogl.c @@ -209,19 +209,19 @@ cogl_pop_matrix (void) } 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 @@ -231,12 +231,12 @@ cogl_translate (gint x, gint y, gint z) } 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 @@ -466,24 +466,24 @@ set_clip_plane (GLint plane_num, } 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) ); @@ -518,10 +518,10 @@ _cogl_set_clip_planes (CoglFixed x_offset, } 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); @@ -537,10 +537,10 @@ _cogl_add_stencil_clip (CoglFixed x_offset, /* Punch out a hole to allow the rectangle */ GE( glStencilFunc (GL_NEVER, 0x1, 0x1) ); GE( glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE) ); - GE( glRectf (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 { @@ -548,10 +548,10 @@ _cogl_add_stencil_clip (CoglFixed x_offset, 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 @@ -574,13 +574,13 @@ _cogl_add_stencil_clip (CoglFixed x_offset, } 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) ); @@ -612,20 +612,20 @@ _cogl_disable_clip_planes (void) 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]; @@ -646,22 +646,22 @@ cogl_perspective (CoglFixed fovy, * 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) ); @@ -672,22 +672,22 @@ cogl_perspective (CoglFixed fovy, 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; @@ -696,32 +696,32 @@ cogl_frustum (CoglFixed left, 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; @@ -738,10 +738,10 @@ cogl_viewport (guint width, 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; @@ -769,13 +769,13 @@ cogl_setup_viewport (guint width, 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) ); @@ -1164,75 +1164,75 @@ cogl_features_available (CoglFeatureFlags features) } 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,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) = 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,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) = 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,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) = 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,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,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) = 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,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) = 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,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) = 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,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 @@ -1263,9 +1263,9 @@ cogl_get_bitmasks (gint *red, gint *green, gint *blue, gint *alpha) void cogl_fog_set (const CoglColor *fog_color, - CoglFixed density, - CoglFixed start, - CoglFixed stop) + float density, + float start, + float stop) { GLfloat fogColor[4]; @@ -1281,8 +1281,8 @@ cogl_fog_set (const CoglColor *fog_color, 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)); } diff --git a/gles/cogl-context.c b/gles/cogl-context.c index b09568de4..e5c017e80 100644 --- a/gles/cogl-context.c +++ b/gles/cogl-context.c @@ -80,7 +80,7 @@ cogl_create_context () #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); diff --git a/gles/cogl-context.h b/gles/cogl-context.h index 92b8b96a2..d941aaa57 100644 --- a/gles/cogl-context.h +++ b/gles/cogl-context.h @@ -53,15 +53,15 @@ typedef struct 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; diff --git a/gles/cogl-fbo.c b/gles/cogl-fbo.c index d5b02818b..3b1099e26 100644 --- a/gles/cogl-fbo.c +++ b/gles/cogl-fbo.c @@ -227,12 +227,12 @@ cogl_draw_buffer (CoglBufferTarget target, CoglHandle offscreen) /* Setup new viewport and matrices */ GE( glViewport (0, 0, fbo->width, fbo->height) ); - GE( cogl_wrap_glTranslatex (-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) ); diff --git a/gles/cogl-gles2-wrapper.c b/gles/cogl-gles2-wrapper.c index d43ad21da..4be0a55ba 100644 --- a/gles/cogl-gles2-wrapper.c +++ b/gles/cogl-gles2-wrapper.c @@ -104,7 +104,7 @@ cogl_gles2_wrapper_create_shader (GLenum type, const char *source) 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)); @@ -118,11 +118,11 @@ cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper) /* Initialize the fogging options */ cogl_wrap_glDisable (GL_FOG); - cogl_wrap_glFogx (GL_FOG_MODE, GL_LINEAR); - cogl_wrap_glFogx (GL_FOG_DENSITY, 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); @@ -517,10 +517,10 @@ cogl_gles2_wrapper_update_matrix (CoglGles2Wrapper *wrapper, GLenum matrix_num) void cogl_wrap_glClearColorx (GLclampx r, GLclampx g, GLclampx b, GLclampx a) { - glClearColor (COGL_FIXED_TO_FLOAT (r), - COGL_FIXED_TO_FLOAT (g), - COGL_FIXED_TO_FLOAT (b), - COGL_FIXED_TO_FLOAT (a)); + glClearColor ( (r), + (g), + (b), + (a)); } void @@ -666,58 +666,58 @@ cogl_wrap_glMultMatrix (const float *m) } 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]; @@ -725,22 +725,22 @@ cogl_wrap_glTranslatex (GLfixed x, GLfixed y, GLfixed z) 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); @@ -768,21 +768,21 @@ 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) +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); @@ -1033,7 +1033,7 @@ cogl_gles2_wrapper_bind_texture (GLenum target, GLuint texture, } 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 @@ -1143,17 +1143,17 @@ cogl_wrap_glAlphaFunc (GLenum func, GLclampf ref) } 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 */ } @@ -1161,10 +1161,10 @@ cogl_wrap_glClipPlanex (GLenum plane, GLfixed *equation) 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 @@ -1185,7 +1185,7 @@ cogl_wrap_glGetIntegerv (GLenum pname, GLint *params) } void -cogl_wrap_glGetFixedv (GLenum pname, GLfixed *params) +cogl_wrap_glGetFixedv (GLenum pname, GLfloat *params) { _COGL_GET_GLES2_WRAPPER (w, NO_RETVAL); @@ -1215,7 +1215,7 @@ cogl_wrap_glGetFixedv (GLenum pname, GLfixed *params) } void -cogl_wrap_glFogx (GLenum pname, GLfixed param) +cogl_wrap_glFogf (GLenum pname, GLfloat param) { _COGL_GET_GLES2_WRAPPER (w, NO_RETVAL); @@ -1227,23 +1227,23 @@ cogl_wrap_glFogx (GLenum pname, GLfixed param) 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); @@ -1251,7 +1251,7 @@ cogl_wrap_glFogxv (GLenum pname, const GLfixed *params) 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; } diff --git a/gles/cogl-gles2-wrapper.h b/gles/cogl-gles2-wrapper.h index 7e7472c58..cb700cc3a 100644 --- a/gles/cogl-gles2-wrapper.h +++ b/gles/cogl-gles2-wrapper.h @@ -209,16 +209,16 @@ void cogl_wrap_glPushMatrix (); 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); @@ -232,22 +232,22 @@ void cogl_wrap_glColorPointer (GLint size, GLenum type, GLsizei stride, 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, @@ -280,28 +280,28 @@ void _cogl_gles2_clear_cache_for_program (CoglHandle program); #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 diff --git a/gles/cogl-primitives.c b/gles/cogl-primitives.c index f6248ea9e..901fa5d09 100644 --- a/gles/cogl-primitives.c +++ b/gles/cogl-primitives.c @@ -64,12 +64,12 @@ _cogl_rectangle (gint x, 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, @@ -89,8 +89,8 @@ _cogl_rectanglex (CoglFixed x, void _cogl_path_add_node (gboolean new_sub_path, - CoglFixed x, - CoglFixed y) + float x, + float y) { CoglPathNode new_node; @@ -147,19 +147,19 @@ _cogl_path_stroke_nodes () } 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, @@ -169,8 +169,8 @@ 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) @@ -244,12 +244,12 @@ _cogl_add_path_to_stencil_buffer (CoglFixedVec2 nodes_min, 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 () ); @@ -292,14 +292,14 @@ _cogl_path_fill_nodes_scanlines (CoglPathNode *path, 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; @@ -362,7 +362,7 @@ _cogl_path_fill_nodes_scanlines (CoglPathNode *path, { gint spans = 0; gint span_no; - GLfixed *coords; + GLfloat *coords; /* count number of spans */ for (i=0; i < bounds_h; i++) @@ -380,7 +380,7 @@ _cogl_path_fill_nodes_scanlines (CoglPathNode *path, 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 */ @@ -390,15 +390,15 @@ _cogl_path_fill_nodes_scanlines (CoglPathNode *path, 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 */ diff --git a/gles/cogl-texture.c b/gles/cogl-texture.c index 7de709507..9f99ef3b8 100644 --- a/gles/cogl-texture.c +++ b/gles/cogl-texture.c @@ -63,15 +63,15 @@ struct _CoglSpanIter 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; }; @@ -116,7 +116,7 @@ _cogl_span_iter_update (CoglSpanIter *iter) /* 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 || @@ -145,9 +145,9 @@ _cogl_span_iter_update (CoglSpanIter *iter) 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; @@ -398,10 +398,10 @@ _cogl_texture_draw_and_read (CoglTexture *tex, 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; @@ -422,9 +422,9 @@ _cogl_texture_draw_and_read (CoglTexture *tex, /* 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); @@ -439,7 +439,7 @@ _cogl_texture_draw_and_read (CoglTexture *tex, 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]) @@ -450,7 +450,7 @@ _cogl_texture_draw_and_read (CoglTexture *tex, /* 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; @@ -464,7 +464,7 @@ _cogl_texture_draw_and_read (CoglTexture *tex, /* 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 */ @@ -544,10 +544,10 @@ _cogl_texture_download_from_gl (CoglTexture *tex, 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 () ); @@ -662,8 +662,8 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex, /* Iterate vertical spans */ for (source_y = src_y, _cogl_span_iter_begin (&y_iter, tex->slice_y_spans, - 0, 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); @@ -683,8 +683,8 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex, /* Iterate horizontal spans */ for (source_x = src_x, _cogl_span_iter_begin (&x_iter, tex->slice_x_spans, - 0, 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); @@ -702,15 +702,15 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex, 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 */ @@ -768,7 +768,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex, 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 @@ -813,7 +813,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex, 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 @@ -2148,24 +2148,24 @@ _cogl_texture_add_quad_vertices (GLfloat x1, GLfloat y1, 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); @@ -2180,7 +2180,7 @@ _cogl_texture_quad_sw (CoglTexture *tex, slices */ if (tx2 < tx1) { - CoglFixed temp = x1; + float temp = x1; x1 = x2; x2 = temp; temp = tx1; @@ -2189,7 +2189,7 @@ _cogl_texture_quad_sw (CoglTexture *tex, } if (ty2 < ty1) { - CoglFixed temp = y1; + float temp = y1; y1 = y2; y2 = temp; temp = ty1; @@ -2198,27 +2198,27 @@ _cogl_texture_quad_sw (CoglTexture *tex, } /* 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 */ @@ -2232,10 +2232,10 @@ _cogl_texture_quad_sw (CoglTexture *tex, /* 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; @@ -2257,10 +2257,10 @@ _cogl_texture_quad_sw (CoglTexture *tex, /* 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; @@ -2273,14 +2273,14 @@ _cogl_texture_quad_sw (CoglTexture *tex, #if COGL_DEBUG printf("~~~~~ slice (%d,%d)\n", iter_x.index, iter_y.index); - printf("qx1: %f\n", 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 */ @@ -2297,28 +2297,28 @@ _cogl_texture_quad_sw (CoglTexture *tex, 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; @@ -2352,19 +2352,19 @@ _cogl_texture_quad_hw (CoglTexture *tex, ty1 = ty1 * (y_span->size - y_span->waste) / y_span->size; ty2 = ty2 * (y_span->size - y_span->waste) / y_span->size; - _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; @@ -2411,10 +2411,10 @@ cogl_texture_multiple_rectangles (CoglHandle handle, 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 @@ -2430,16 +2430,16 @@ cogl_texture_multiple_rectangles (CoglHandle handle, 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; @@ -2541,7 +2541,7 @@ cogl_texture_polygon (CoglHandle handle, 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); diff --git a/gles/cogl.c b/gles/cogl.c index bb4a0ea76..226f2e432 100644 --- a/gles/cogl.c +++ b/gles/cogl.c @@ -116,41 +116,41 @@ cogl_pop_matrix (void) } void -cogl_scale (CoglFixed x, CoglFixed y) +cogl_scale (float x, float y) { - GE( cogl_wrap_glScalex (x, y, COGL_FIXED_1) ); + GE( cogl_wrap_glScalef (x, y, 1.0) ); } void -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 @@ -315,7 +315,7 @@ cogl_set_source_color (const CoglColor *color) #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)) ); @@ -326,22 +326,22 @@ cogl_set_source_color (const CoglColor *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; @@ -351,21 +351,21 @@ project_vertex (CoglFixed *modelview, 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); @@ -374,36 +374,36 @@ set_clip_plane (GLint plane_num, 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) ); @@ -421,7 +421,7 @@ _cogl_set_clip_planes (CoglFixed x_offset, 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)); @@ -437,10 +437,10 @@ _cogl_set_clip_planes (CoglFixed x_offset, } 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); @@ -476,9 +476,9 @@ _cogl_add_stencil_clip (CoglFixed x_offset, 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 () ); @@ -490,10 +490,10 @@ _cogl_add_stencil_clip (CoglFixed x_offset, } 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 @@ -522,25 +522,25 @@ _cogl_disable_clip_planes (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); @@ -558,76 +558,76 @@ cogl_perspective (CoglFixed fovy, * 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 } @@ -641,19 +641,19 @@ cogl_viewport (guint width, 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); @@ -666,24 +666,24 @@ cogl_setup_viewport (guint w, * 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 @@ -735,19 +735,19 @@ cogl_features_available (CoglFeatureFlags features) } 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; @@ -755,7 +755,7 @@ cogl_get_viewport (CoglFixed v[4]) 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 @@ -773,11 +773,11 @@ cogl_get_bitmasks (gint *red, gint *green, gint *blue, gint *alpha) 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); @@ -786,12 +786,12 @@ cogl_fog_set (const CoglColor *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); }