isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-22 16:10:41 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'cogl-float'

Browse Source 
Okey; to summarise the changes...

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

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

To summarise the rationale...

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

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

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

58
cogl-color.h
View File

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

12
cogl-fixed.h
View File

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

114
cogl-path.h
View File

@ -60,24 +60,10 @@ G_BEGIN_DECLS
* Fills a rectangle at the given coordinates with the current
* drawing color in a highly optimizied fashion.
**/
void cogl_rectangle (gint x,
gint y,
guint width,
guint height);
/**
* cogl_rectanglex:
* @x: X coordinate of the top-left corner
* @y: Y coordinate of the top-left corner
* @width: Width of the rectangle
* @height: Height of the rectangle
*
* A fixed-point version of cogl_fast_fill_rectangle.
**/
void cogl_rectanglex (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height);
void cogl_rectangle (float x,
float y,
float width,
float height);
/**
* cogl_path_fill:
@ -136,8 +122,8 @@ void cogl_path_new (void);
* Moves the pen to the given location. If there is an existing path
* 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 +135,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 +146,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 +157,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 +175,12 @@ void cogl_path_rel_line_to (CoglFixed x,
* of the arc. If you perform a move_to to the arcs start just before
* 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 +197,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 +218,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 +244,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 +267,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 +285,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 +299,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 +314,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 +332,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

20
cogl-texture.h
View File

@ -368,14 +368,14 @@ void cogl_texture_unref (CoglHandle handle);
* texture pass in @tx1=0.0 @ty1=0.0 @tx2=1.0 @ty2=1.0.
*/
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 #CoglFixed<!-- -->s with
* @verts should point to an array of #float<!-- -->s with
* @n_rects * 8 elements. Each group of 8 values corresponds to the
* parameters x1, y1, x2, y2, tx1, ty1, tx2 and ty2 and have the same
* meaning as in cogl_texture_rectangle().
@ -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

4
cogl-types.h
View File

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

112
cogl.h.in
View File

@ -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,21 +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);
/**
* cogl_translatex:
* @x: Distance to translate along the x-axis
* @y: Distance to translate along the y-axis
* @z: Distance to translate along the z-axis
*
* Multiplies the current model-view matrix by one that translates the
* model along all three axes according to the given values.
*/
void cogl_translatex (CoglFixed x,
CoglFixed y,
CoglFixed z);
void cogl_scale (float x,
float y);
/**
* cogl_translate:
@ -249,16 +236,15 @@ void cogl_translatex (CoglFixed x,
* @y: Distance to translate along the y-axis
* @z: Distance to translate along the z-axis
*
* Integer version of cogl_translatex(). Multiplies the current
* model-view matrix by one that translates the model along all three
* axes according to the given values.
* Multiplies the current model-view matrix by one that translates the
* model along all three axes according to the given values.
*/
void cogl_translate (gint x,
gint y,
gint z);
void cogl_translate (float x,
float y,
float z);
/**
* cogl_rotatex:
* cogl_rotate:
* @angle: Angle in degrees to rotate.
* @x: X-component of vertex to rotate around.
* @y: Y-component of vertex to rotate around.
@ -270,55 +256,39 @@ void cogl_translate (gint x,
* degrees about the vertex (0, 0, 1) causes a small counter-clockwise
* rotation.
*/
void cogl_rotatex (CoglFixed angle,
gint x,
gint y,
gint z);
/**
* cogl_rotate:
* @angle: Angle in degrees to rotate.
* @x: X-component of vertex to rotate around.
* @y: Y-component of vertex to rotate around.
* @z: Z-component of vertex to rotate around.
*
* Integer version of cogl_rotatex(). Multiplies the current
* model-view matrix by one that rotates the model around the vertex
* specified by @x, @y and @z.
*/
void cogl_rotate (gint angle,
gint x,
gint y,
gint z);
void cogl_rotate (float angle,
float x,
float y,
float z);
/**
* cogl_get_modelview_matrix:
* @m: pointer to a 4x4 array of #CoglFixed<!-- -->s to receive the matrix
* @m: pointer to a 4x4 array of #float<!-- -->s to receive the matrix
*
* Stores the current model-view matrix in @m. The matrix is in
* column-major order.
*/
void cogl_get_modelview_matrix (CoglFixed m[16]);
void cogl_get_modelview_matrix (float m[16]);
/**
* cogl_get_projection_matrix:
* @m: pointer to a 4x4 array of #CoglFixed<!-- -->s to receive the matrix
* @m: pointer to a 4x4 array of #float<!-- -->s to receive the matrix
*
* Stores the current projection matrix in @m. The matrix is in
* column-major order.
*/
void cogl_get_projection_matrix (CoglFixed m[16]);
void cogl_get_projection_matrix (float m[16]);
/**
* cogl_get_viewport:
* @v: pointer to a 4 element array of #CoglFixed<!-- -->s to
* @v: pointer to a 4 element array of #float<!-- -->s to
* receive the viewport dimensions.
*
* Stores the current viewport in @v. @v[0] and @v[1] get the x and y
* position of the viewport and @v[2] and @v[3] get the width and
* height.
*/
void cogl_get_viewport (CoglFixed v[4]);
void cogl_get_viewport (float v[4]);
/**
* cogl_clip_set:
@ -336,10 +306,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:
@ -442,8 +412,8 @@ void cogl_enable_backface_culling (gboolean setting);
* comparing with the value in @ref. The default function is CGL_ALWAYS the
* initial reference value is 1.0.
*/
void cogl_alpha_func (COGLenum func,
CoglFixed ref);
void cogl_alpha_func (COGLenum func,
float ref);
/**
* cogl_fog_set:
@ -460,9 +430,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:

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

@ -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;

44
common/cogl-color.c
View File

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

6
common/cogl-fixed.c
View File

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

309
common/cogl-primitives.c
View File

@ -33,46 +33,31 @@
#include <string.h>
#include <gmodule.h>
#include <math.h>
#define _COGL_MAX_BEZ_RECURSE_DEPTH 16
/* 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_rectangle (float x,
float y,
float width,
float height);
void
cogl_rectangle (gint x,
gint y,
guint width,
guint height)
cogl_rectangle (float x,
float y,
float width,
float height)
{
cogl_clip_ensure ();
_cogl_rectangle (x, y, width, height);
}
void
cogl_rectanglex (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height)
{
cogl_clip_ensure ();
_cogl_rectanglex (x, y, width, height);
}
void
cogl_path_fill (void)
{
@ -116,8 +101,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 +117,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 +127,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 +139,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 +166,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 +188,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 +196,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 +209,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 +237,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 +264,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 +293,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 +311,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 +362,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 +385,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 +403,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 +420,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 +444,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 +474,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 +503,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 +533,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 +552,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 +573,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 +593,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 +618,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);

22
common/cogl-primitives.h
View File

@ -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 */

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

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

8
gl/cogl-context.h
View File

@ -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];

79
gl/cogl-primitives.c
View File

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

227
gl/cogl-texture.c
View File

@ -37,6 +37,7 @@
#include <string.h>
#include <stdlib.h>
#include <math.h>
/*
#define COGL_DEBUG 1
@ -54,15 +55,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 +103,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 +132,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 +472,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 +493,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 +512,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 +556,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 + ((int)y_iter.intersect_start)
- dst_y)
* source_bmp->rowstride
+ (src_x + x_span->start + x_span->size - x_span->waste
@ -600,7 +601,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
guint copy_width;
src = source_bmp->data
+ (src_x + COGL_FIXED_TO_INT (x_iter.intersect_start)
+ (src_x + ((int)x_iter.intersect_start)
- dst_x)
* bpp
+ (src_y + y_span->start + y_span->size - y_span->waste
@ -2010,24 +2011,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 +2051,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 +2060,7 @@ _cogl_texture_quad_sw (CoglTexture *tex,
}
if (ty2 < ty1)
{
CoglFixed temp = y1;
float temp = y1;
y1 = y2;
y2 = temp;
temp = ty1;
@ -2068,27 +2069,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 +2103,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 +2131,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 +2150,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 +2173,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 +2210,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 +2252,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 +2315,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 +2334,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 +2456,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);

275
gl/cogl.c
View File

@ -209,40 +209,23 @@ 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),
glScalef ((float)(x),
(float)(y),
1.0);
}
void
cogl_translatex (CoglFixed x, CoglFixed y, CoglFixed z)
cogl_translate (float x, float y, float z)
{
glTranslated (COGL_FIXED_TO_DOUBLE (x),
COGL_FIXED_TO_DOUBLE (y),
COGL_FIXED_TO_DOUBLE (z));
glTranslatef (x, y, z);
}
void
cogl_translate (gint x, gint y, gint z)
cogl_rotate (float angle, float x, float y, float z)
{
glTranslatef ((float)x, (float)y, (float)z);
}
void
cogl_rotatex (CoglFixed angle, gint x, gint y, gint z)
{
glRotated (COGL_FIXED_TO_DOUBLE (angle),
COGL_FIXED_TO_DOUBLE (x),
COGL_FIXED_TO_DOUBLE (y),
COGL_FIXED_TO_DOUBLE (z));
}
void
cogl_rotate (gint angle, gint x, gint y, gint z)
{
glRotatef ((float)angle, (float)x, (float)y, (float)z);
glRotatef (angle, x, y, z);
}
static inline gboolean
@ -466,24 +449,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 +501,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 +520,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 +531,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 +557,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 +595,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];
@ -645,23 +628,19 @@ cogl_perspective (CoglFixed fovy,
* 2) When working with small numbers, we are loosing significant
* precision
*/
ymax =
COGL_FIXED_MUL (zNear,
COGL_FIXED_FAST_DIV (cogl_fixed_sin (fovy_rad_half),
cogl_fixed_cos (fovy_rad_half)));
ymax = (zNear * (sinf (fovy_rad_half) / cosf (fovy_rad_half)));
xmax = (ymax * aspect);
xmax = COGL_FIXED_MUL (ymax, aspect);
x = COGL_FIXED_FAST_DIV (zNear, xmax);
y = COGL_FIXED_FAST_DIV (zNear, ymax);
c = COGL_FIXED_FAST_DIV (-(zFar + zNear), ( zFar - zNear));
d = cogl_fixed_mul_div (-(2 * zFar), zNear, (zFar - zNear));
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) = 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 +651,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 +675,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 ((GLdouble)(left),
(GLdouble)(right),
(GLdouble)(bottom),
(GLdouble)(top),
(GLdouble)(z_near),
(GLdouble)(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 +717,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 +748,11 @@ 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);
z_camera = ((sinf (fovy_rad) / cosf (fovy_rad)) / 2);
}
GE( glTranslatef (-0.5f, -0.5f, -z_camera) );
@ -1164,75 +1141,21 @@ 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,1,0) = COGL_FIXED_FROM_FLOAT (M(md,1,0));
M(m,1,1) = COGL_FIXED_FROM_FLOAT (M(md,1,1));
M(m,1,2) = COGL_FIXED_FROM_FLOAT (M(md,1,2));
M(m,1,3) = COGL_FIXED_FROM_FLOAT (M(md,1,3));
M(m,2,0) = COGL_FIXED_FROM_FLOAT (M(md,2,0));
M(m,2,1) = COGL_FIXED_FROM_FLOAT (M(md,2,1));
M(m,2,2) = COGL_FIXED_FROM_FLOAT (M(md,2,2));
M(m,2,3) = COGL_FIXED_FROM_FLOAT (M(md,2,3));
M(m,3,0) = COGL_FIXED_FROM_FLOAT (M(md,3,0));
M(m,3,1) = COGL_FIXED_FROM_FLOAT (M(md,3,1));
M(m,3,2) = COGL_FIXED_FROM_FLOAT (M(md,3,2));
M(m,3,3) = COGL_FIXED_FROM_FLOAT (M(md,3,3));
#undef M
glGetFloatv (GL_MODELVIEW_MATRIX, m);
}
void
cogl_get_projection_matrix (CoglFixed m[16])
cogl_get_projection_matrix (float m[16])
{
GLdouble md[16];
glGetDoublev(GL_PROJECTION_MATRIX, &md[0]);
#define M(m,row,col) m[col*4+row]
M(m,0,0) = COGL_FIXED_FROM_FLOAT (M(md,0,0));
M(m,0,1) = COGL_FIXED_FROM_FLOAT (M(md,0,1));
M(m,0,2) = COGL_FIXED_FROM_FLOAT (M(md,0,2));
M(m,0,3) = COGL_FIXED_FROM_FLOAT (M(md,0,3));
M(m,1,0) = COGL_FIXED_FROM_FLOAT (M(md,1,0));
M(m,1,1) = COGL_FIXED_FROM_FLOAT (M(md,1,1));
M(m,1,2) = COGL_FIXED_FROM_FLOAT (M(md,1,2));
M(m,1,3) = COGL_FIXED_FROM_FLOAT (M(md,1,3));
M(m,2,0) = COGL_FIXED_FROM_FLOAT (M(md,2,0));
M(m,2,1) = COGL_FIXED_FROM_FLOAT (M(md,2,1));
M(m,2,2) = COGL_FIXED_FROM_FLOAT (M(md,2,2));
M(m,2,3) = COGL_FIXED_FROM_FLOAT (M(md,2,3));
M(m,3,0) = COGL_FIXED_FROM_FLOAT (M(md,3,0));
M(m,3,1) = COGL_FIXED_FROM_FLOAT (M(md,3,1));
M(m,3,2) = COGL_FIXED_FROM_FLOAT (M(md,3,2));
M(m,3,3) = COGL_FIXED_FROM_FLOAT (M(md,3,3));
#undef M
glGetFloatv (GL_PROJECTION_MATRIX, 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]);
glGetFloatv (GL_VIEWPORT, v);
}
void
@ -1263,9 +1186,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 +1204,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));
}

2
gles/cogl-context.c
View File

@ -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);

10
gles/cogl-context.h
View File

@ -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;

12
gles/cogl-fbo.c
View File

@ -227,12 +227,12 @@ cogl_draw_buffer (CoglBufferTarget target, CoglHandle offscreen)
/* Setup new viewport and matrices */
GE( glViewport (0, 0, fbo->width, fbo->height) );
GE( cogl_wrap_glTranslatex (-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) );

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

@ -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);
@ -514,15 +514,6 @@ cogl_gles2_wrapper_update_matrix (CoglGles2Wrapper *wrapper, GLenum matrix_num)
}
}
void
cogl_wrap_glClearColorx (GLclampx r, GLclampx g, GLclampx b, GLclampx a)
{
glClearColor (COGL_FIXED_TO_FLOAT (r),
COGL_FIXED_TO_FLOAT (g),
COGL_FIXED_TO_FLOAT (b),
COGL_FIXED_TO_FLOAT (a));
}
void
cogl_wrap_glPushMatrix ()
{
@ -666,58 +657,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 +716,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 +759,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 +1024,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,30 +1134,17 @@ cogl_wrap_glAlphaFunc (GLenum func, GLclampf ref)
}
void
cogl_wrap_glColor4x (GLclampx r, GLclampx g, GLclampx b, GLclampx a)
cogl_wrap_glColor4f (GLclampf r, GLclampf g, GLclampf b, GLclampf a)
{
glVertexAttrib4f (COGL_GLES2_WRAPPER_COLOR_ATTRIB,
COGL_FIXED_TO_FLOAT (r),
COGL_FIXED_TO_FLOAT (g),
COGL_FIXED_TO_FLOAT (b),
COGL_FIXED_TO_FLOAT (a));
glVertexAttrib4f (COGL_GLES2_WRAPPER_COLOR_ATTRIB, r, g, b, a);
}
void
cogl_wrap_glClipPlanex (GLenum plane, GLfixed *equation)
cogl_wrap_glClipPlanef (GLenum plane, GLfloat *equation)
{
/* FIXME */
}
static void
cogl_gles2_float_array_to_fixed (int size,
const GLfloat *floats,
GLfixed *fixeds)
{
while (size-- > 0)
*(fixeds++) = COGL_FIXED_FROM_FLOAT (*(floats++));
}
void
cogl_wrap_glGetIntegerv (GLenum pname, GLint *params)
{
@ -1185,37 +1163,30 @@ cogl_wrap_glGetIntegerv (GLenum pname, GLint *params)
}
void
cogl_wrap_glGetFixedv (GLenum pname, GLfixed *params)
cogl_wrap_glGetFloatv (GLenum pname, GLfloat *params)
{
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
switch (pname)
{
case GL_MODELVIEW_MATRIX:
cogl_gles2_float_array_to_fixed (16, w->modelview_stack
+ w->modelview_stack_pos * 16,
params);
memcpy (params, w->modelview_stack + w->modelview_stack_pos * 16,
sizeof (GLfloat) * 16);
break;
case GL_PROJECTION_MATRIX:
cogl_gles2_float_array_to_fixed (16, w->projection_stack
+ w->projection_stack_pos * 16,
params);
memcpy (params, w->projection_stack + w->projection_stack_pos * 16,
sizeof (GLfloat) * 16);
break;
case GL_VIEWPORT:
{
GLfloat v[4];
glGetFloatv (GL_VIEWPORT, v);
cogl_gles2_float_array_to_fixed (4, v, params);
}
glGetFloatv (GL_VIEWPORT, params);
break;
}
}
void
cogl_wrap_glFogx (GLenum pname, GLfixed param)
cogl_wrap_glFogf (GLenum pname, GLfloat param)
{
_COGL_GET_GLES2_WRAPPER (w, NO_RETVAL);
@ -1227,23 +1198,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 +1222,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;
}

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

@ -203,22 +203,20 @@ struct _CoglGles2WrapperShader
void cogl_gles2_wrapper_init (CoglGles2Wrapper *wrapper);
void cogl_gles2_wrapper_deinit (CoglGles2Wrapper *wrapper);
void cogl_wrap_glClearColorx (GLclampx r, GLclampx g, GLclampx b, GLclampx a);
void cogl_wrap_glPushMatrix ();
void cogl_wrap_glPopMatrix ();
void cogl_wrap_glMatrixMode (GLenum mode);
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 +230,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 (GLclampf r, GLclampf g, GLclampf b, GLclampf a);
void cogl_wrap_glClipPlanex (GLenum plane, GLfixed *equation);
void cogl_wrap_glClipPlanef (GLenum plane, GLfloat *equation);
void cogl_wrap_glGetIntegerv (GLenum pname, GLint *params);
void cogl_wrap_glGetFixedv (GLenum pname, GLfixed *params);
void cogl_wrap_glGetFloatv (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,
@ -273,35 +271,34 @@ void _cogl_gles2_clear_cache_for_program (CoglHandle program);
/* If we're not using GL ES 2 then just use the GL functions
directly */
#define cogl_wrap_glClearColorx glClearColorx
#define cogl_wrap_glDrawArrays glDrawArrays
#define cogl_wrap_glDrawElements glDrawElements
#define cogl_wrap_glPushMatrix glPushMatrix
#define cogl_wrap_glPopMatrix glPopMatrix
#define cogl_wrap_glMatrixMode glMatrixMode
#define cogl_wrap_glLoadIdentity glLoadIdentity
#define cogl_wrap_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 glMultMatrixf
#define cogl_wrap_glFrustumf glFrustumf
#define cogl_wrap_glScalef glScalef
#define cogl_wrap_glTranslatef glTranslatef
#define cogl_wrap_glRotatef glRotatef
#define cogl_wrap_glOrthof glOrthof
#define cogl_wrap_glEnable glEnable
#define cogl_wrap_glDisable glDisable
#define cogl_wrap_glTexCoordPointer glTexCoordPointer
#define cogl_wrap_glVertexPointer glVertexPointer
#define cogl_wrap_glColorPointer glColorPointer
#define cogl_wrap_glNormalPointer glNormalPointer
#define cogl_wrap_glTexEnvx glTexEnvx
#define cogl_wrap_glTexEnvf glTexEnvf
#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 glColor4f
#define cogl_wrap_glClipPlanef glClipPlanef
#define cogl_wrap_glGetIntegerv glGetIntegerv
#define cogl_wrap_glGetFixedv glGetFixedv
#define cogl_wrap_glFogx glFogx
#define cogl_wrap_glFogxv glFogxv
#define cogl_wrap_glGetFloatv glGetFloatv
#define cogl_wrap_glFogf glFogf
#define cogl_wrap_glFogfv glFogfv
#define cogl_wrap_glTexParameteri glTexParameteri
/* The extra third parameter of the bind texture wrapper isn't needed

128
gles/cogl-primitives.c
View File

@ -34,63 +34,35 @@
#include <string.h>
#include <gmodule.h>
#include <math.h>
#define _COGL_MAX_BEZ_RECURSE_DEPTH 16
void
_cogl_rectangle (gint x,
gint y,
guint width,
guint height)
_cogl_rectangle (float x,
float y,
float width,
float height)
{
/* 32-bit integers are not supported as coord types
in GLES . Fixed type has got 16 bits left of the
point which is equal to short anyway. */
GLshort rect_verts[8] = {
(GLshort) x, (GLshort) y,
(GLshort) (x + width), (GLshort) y,
(GLshort) x, (GLshort) (y + height),
(GLshort) (x + width), (GLshort) (y + height)
GLfloat rect_verts[8] = {
(GLfloat) x, (GLfloat) y,
(GLfloat) (x + width), (GLfloat) y,
(GLfloat) x, (GLfloat) (y + height),
(GLfloat) (x + width), (GLfloat) (y + height)
};
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
cogl_enable (COGL_ENABLE_VERTEX_ARRAY
| (ctx->color_alpha < 255 ? COGL_ENABLE_BLEND : 0));
GE ( cogl_wrap_glVertexPointer (2, GL_SHORT, 0, rect_verts ) );
GE ( cogl_wrap_glVertexPointer (2, GL_FLOAT, 0, rect_verts ) );
GE ( cogl_wrap_glDrawArrays (GL_TRIANGLE_STRIP, 0, 4) );
}
void
_cogl_rectanglex (CoglFixed x,
CoglFixed y,
CoglFixed width,
CoglFixed height)
{
GLfixed rect_verts[8] = {
x, y,
x + width, y,
x, y + height,
x + width, y + height
};
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
cogl_enable (COGL_ENABLE_VERTEX_ARRAY
| (ctx->color_alpha < 255
? COGL_ENABLE_BLEND : 0));
GE( cogl_wrap_glVertexPointer (2, GL_FIXED, 0, rect_verts) );
GE( cogl_wrap_glDrawArrays (GL_TRIANGLE_STRIP, 0, 4) );
}
void
_cogl_path_add_node (gboolean new_sub_path,
CoglFixed x,
CoglFixed y)
float x,
float y)
{
CoglPathNode new_node;
@ -147,19 +119,17 @@ _cogl_path_stroke_nodes ()
}
static void
_cogl_path_get_bounds (CoglFixedVec2 nodes_min,
CoglFixedVec2 nodes_max,
gint *bounds_x,
gint *bounds_y,
guint *bounds_w,
guint *bounds_h)
_cogl_path_get_bounds (floatVec2 nodes_min,
floatVec2 nodes_max,
float *bounds_x,
float *bounds_y,
float *bounds_w,
float *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 = nodes_min.x;
*bounds_y = nodes_min.y;
*bounds_w = nodes_max.x - *bounds_x;
*bounds_h = nodes_max.y - *bounds_y;
}
static gint compare_ints (gconstpointer a,
@ -169,18 +139,18 @@ 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)
{
guint path_start = 0;
guint sub_path_num = 0;
gint bounds_x;
gint bounds_y;
guint bounds_w;
guint bounds_h;
float bounds_x;
float bounds_y;
float bounds_w;
float bounds_h;
_cogl_path_get_bounds (nodes_min, nodes_max,
&bounds_x, &bounds_y, &bounds_w, &bounds_h);
@ -244,12 +214,8 @@ _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_rectangle (-1.0, -1.0, 2, 2);
cogl_rectangle (-1.0, -1.0, 2, 2);
GE( cogl_wrap_glPopMatrix () );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPopMatrix () );
@ -292,14 +258,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 +328,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 +346,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 +356,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 */
@ -435,10 +401,10 @@ _cogl_path_fill_nodes_scanlines (CoglPathNode *path,
void
_cogl_path_fill_nodes ()
{
gint bounds_x;
gint bounds_y;
guint bounds_w;
guint bounds_h;
float bounds_x;
float bounds_y;
float bounds_w;
float bounds_h;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);

241
gles/cogl-texture.c
View File

@ -39,6 +39,7 @@
#include <string.h>
#include <stdlib.h>
#include <math.h>
#define glVertexPointer cogl_wrap_glVertexPointer
#define glTexCoordPointer cogl_wrap_glTexCoordPointer
@ -63,15 +64,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 +117,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 +146,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 +399,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 +423,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 +440,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 +451,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 +465,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 +545,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 +663,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 +684,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 +703,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 +769,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 + ((int)y_iter.intersect_start)
- dst_y)
* source_bmp->rowstride
+ (src_x + x_span->start + x_span->size - x_span->waste
@ -813,7 +814,7 @@ _cogl_texture_upload_subregion_to_gl (CoglTexture *tex,
guint copy_width;
src = source_bmp->data
+ (src_x + COGL_FIXED_TO_INT (x_iter.intersect_start)
+ (src_x + ((int)x_iter.intersect_start)
- dst_x)
* bpp
+ (src_y + y_span->start + y_span->size - y_span->waste
@ -2148,24 +2149,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 +2181,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 +2190,7 @@ _cogl_texture_quad_sw (CoglTexture *tex,
}
if (ty2 < ty1)
{
CoglFixed temp = y1;
float temp = y1;
y1 = y2;
y2 = temp;
temp = ty1;
@ -2198,27 +2199,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 +2233,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 +2258,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 +2274,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 +2298,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 +2353,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 +2412,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 +2431,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 +2542,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);

278
gles/cogl.c
View File

@ -37,6 +37,7 @@
#include "cogl-context.h"
#include "cogl-gles2-wrapper.h"
#include <math.h>
/* GL error to string conversion */
#if COGL_DEBUG
@ -92,10 +93,10 @@ cogl_paint_init (const CoglColor *color)
fprintf(stderr, "\n ============== Paint Start ================ \n");
#endif
cogl_wrap_glClearColorx (cogl_color_get_red (color),
cogl_color_get_green (color),
cogl_color_get_blue (color),
0);
glClearColor (cogl_color_get_red (color),
cogl_color_get_green (color),
cogl_color_get_blue (color),
0);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
cogl_wrap_glDisable (GL_LIGHTING);
@ -116,41 +117,21 @@ 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_translate (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)
cogl_rotate (float angle, float x, float y, float z)
{
GE( cogl_wrap_glTranslatex (COGL_FIXED_FROM_INT(x),
COGL_FIXED_FROM_INT(y),
COGL_FIXED_FROM_INT(z)) );
}
void
cogl_rotatex (CoglFixed angle,
CoglFixed x,
CoglFixed y,
CoglFixed z)
{
GE( cogl_wrap_glRotatex (angle,x,y,z) );
}
void
cogl_rotate (gint angle, gint x, gint y, gint z)
{
GE( cogl_wrap_glRotatex (COGL_FIXED_FROM_INT(angle),
COGL_FIXED_FROM_INT(x),
COGL_FIXED_FROM_INT(y),
COGL_FIXED_FROM_INT(z)) );
GE( cogl_wrap_glRotatef (angle, x, y, z) );
}
static inline gboolean
@ -315,7 +296,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 +307,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,62 +332,61 @@ 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],
vertex_b[0] - vertex_a[0]),
COGL_RADIANS_TO_DEGREES);
angle = atan2f (vertex_b[1] - vertex_a[1],
vertex_b[0] - vertex_a[0]) * (180.0/G_PI);
GE( cogl_wrap_glPushMatrix () );
/* Load the identity matrix and multiply by the reverse of the
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) );
GE( cogl_wrap_glGetFloatv (GL_MODELVIEW_MATRIX, modelview) );
GE( cogl_wrap_glGetFloatv (GL_PROJECTION_MATRIX, projection) );
project_vertex (modelview, projection, vertex_tl);
project_vertex (modelview, projection, vertex_tr);
@ -421,7 +401,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 +417,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);
@ -457,7 +437,7 @@ _cogl_add_stencil_clip (CoglFixed x_offset,
GE( glStencilFunc (GL_NEVER, 0x1, 0x1) );
GE( glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE) );
cogl_rectanglex (x_offset, y_offset, width, height);
cogl_rectangle (x_offset, y_offset, width, height);
}
else
{
@ -465,7 +445,7 @@ _cogl_add_stencil_clip (CoglFixed x_offset,
rectangle */
GE( glStencilFunc (GL_NEVER, 0x1, 0x3) );
GE( glStencilOp (GL_INCR, GL_INCR, GL_INCR) );
cogl_rectanglex (x_offset, y_offset, width, height);
cogl_rectangle (x_offset, y_offset, width, height);
/* Subtract one from all pixels in the stencil buffer so that
only pixels where both the original stencil buffer and the
@ -476,9 +456,7 @@ _cogl_add_stencil_clip (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_rectangle (-1.0, -1.0, 2, 2);
GE( cogl_wrap_glPopMatrix () );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPopMatrix () );
@ -490,10 +468,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 +500,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 +536,74 @@ 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 +617,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 +642,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;
z_camera = cogl_fixed_div (cogl_fixed_sin (fovy_rad),
cogl_fixed_cos (fovy_rad)) >> 1;
float fovy_rad = (fovy * G_PI) / 180;
z_camera = (sinf (fovy_rad) / cosf (fovy_rad)) / 2;
}
GE( cogl_wrap_glTranslatex (-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_glTranslatef (-0.5f, -0.5f, -z_camera) );
GE( cogl_wrap_glTranslatex (0, -COGL_FIXED_1 * height, 0) );
GE( cogl_wrap_glScalef ( 1.0 / width,
-1.0 / height,
1.0 / width) );
GE( cogl_wrap_glTranslatef (0, -1.0 * height, 0) );
}
static void
@ -735,19 +711,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]);
cogl_wrap_glGetFloatv (GL_MODELVIEW_MATRIX, m);
}
void
cogl_get_projection_matrix (CoglFixed m[16])
cogl_get_projection_matrix (float m[16])
{
cogl_wrap_glGetFixedv(GL_PROJECTION_MATRIX, &m[0]);
cogl_wrap_glGetFloatv (GL_PROJECTION_MATRIX, m);
}
void
cogl_get_viewport (CoglFixed v[4])
cogl_get_viewport (float v[4])
{
GLint viewport[4];
int i;
@ -755,7 +731,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 +749,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 +762,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);
}