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

Normalizes gl vs gles code in preperation for synching material changes

Browse Source 
This changes all GLES code to use the OpenGL function names instead of
the cogl_wrap_* names. For GLES2 we now define the OpenGL name to point
to the wrapper, as opposed to defining the wrapper to point to the
OpenGL name for GLES1.

I've also done a quick pass through gl/cogl.c and gles/cogl.c to make
them more easily comparable. (most of the code is now identical)
This commit is contained in:
Robert Bragg 2009-01-24 16:55:04 +00:00
parent 94077997a7
commit e9a9acd28d
7 changed files with 561 additions and 565 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
gl/cogl-primitives.c
View File

@ -47,8 +47,8 @@ _cogl_path_add_node (gboolean new_sub_path,
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
new_node.x = (x); new_node.x = x;
new_node.y = (y); new_node.y = y;
new_node.path_size = 0; new_node.path_size = 0;
if (new_sub_path || ctx->path_nodes->len == 0) if (new_sub_path || ctx->path_nodes->len == 0)
@ -123,15 +123,23 @@ _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
CoglPathNode *path, CoglPathNode *path,
gboolean merge) gboolean merge)
{ {
guint path_start = 0; guint path_start = 0;
guint sub_path_num = 0; guint sub_path_num = 0;
float bounds_x; float bounds_x;
float bounds_y; float bounds_y;
float bounds_w; float bounds_w;
float bounds_h; float bounds_h;
gulong enable_flags = COGL_ENABLE_VERTEX_ARRAY;
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
/* Just setup a simple material that doesn't use texturing... */
cogl_material_flush_gl_state (ctx->stencil_material, NULL);
enable_flags |=
cogl_material_get_cogl_enable_flags (ctx->source_material);
cogl_enable (enable_flags);
_cogl_path_get_bounds (nodes_min, nodes_max, _cogl_path_get_bounds (nodes_min, nodes_max,
&bounds_x, &bounds_y, &bounds_w, &bounds_h); &bounds_x, &bounds_y, &bounds_w, &bounds_h);
@ -155,15 +163,6 @@ _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
while (path_start < path_size) while (path_start < path_size)
{ {
gulong enable_flags = COGL_ENABLE_VERTEX_ARRAY;
/* Just setup a simple material that doesn't use texturing... */
cogl_material_flush_gl_state (ctx->stencil_material, NULL);
enable_flags |=
cogl_material_get_cogl_enable_flags (ctx->source_material);
cogl_enable (enable_flags);
GE( glVertexPointer (2, GL_FLOAT, sizeof (CoglPathNode), GE( glVertexPointer (2, GL_FLOAT, sizeof (CoglPathNode),
(guchar *) path (guchar *) path
+ G_STRUCT_OFFSET (CoglPathNode, x)) ); + G_STRUCT_OFFSET (CoglPathNode, x)) );
@ -201,8 +200,8 @@ _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
GE( glMatrixMode (GL_PROJECTION) ); GE( glMatrixMode (GL_PROJECTION) );
GE( glPushMatrix () ); GE( glPushMatrix () );
GE( glLoadIdentity () ); GE( glLoadIdentity () );
GE( glRecti (-1, 1, 1, -1) ); cogl_rectangle (-1.0, -1.0, 2, 2);
GE( glRecti (-1, 1, 1, -1) ); cogl_rectangle (-1.0, -1.0, 2, 2);
GE( glPopMatrix () ); GE( glPopMatrix () );
GE( glMatrixMode (GL_MODELVIEW) ); GE( glMatrixMode (GL_MODELVIEW) );
GE( glPopMatrix () ); GE( glPopMatrix () );
@ -226,6 +225,9 @@ _cogl_path_fill_nodes ()
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
_cogl_path_get_bounds (ctx->path_nodes_min, ctx->path_nodes_max,
&bounds_x, &bounds_y, &bounds_w, &bounds_h);
_cogl_add_path_to_stencil_buffer (ctx->path_nodes_min, _cogl_add_path_to_stencil_buffer (ctx->path_nodes_min,
ctx->path_nodes_max, ctx->path_nodes_max,
ctx->path_nodes->len, ctx->path_nodes->len,
@ -233,9 +235,6 @@ _cogl_path_fill_nodes ()
CoglPathNode, 0), CoglPathNode, 0),
ctx->clip.stencil_used); ctx->clip.stencil_used);
_cogl_path_get_bounds (ctx->path_nodes_min, ctx->path_nodes_max,
&bounds_x, &bounds_y, &bounds_w, &bounds_h);
cogl_rectangle (bounds_x, bounds_y, bounds_w, bounds_h); cogl_rectangle (bounds_x, bounds_y, bounds_w, bounds_h);
/* The stencil buffer now contains garbage so the clip area needs to /* The stencil buffer now contains garbage so the clip area needs to

144
gl/cogl.c
View File

@ -171,6 +171,10 @@ cogl_check_extension (const gchar *name, const gchar *ext)
void void
cogl_paint_init (const CoglColor *color) cogl_paint_init (const CoglColor *color)
{ {
#if COGL_DEBUG
fprintf(stderr, "\n ============== Paint Start ================ \n");
#endif
GE( glClearColor (cogl_color_get_red_float (color), GE( glClearColor (cogl_color_get_red_float (color),
cogl_color_get_green_float (color), cogl_color_get_green_float (color),
cogl_color_get_blue_float (color), cogl_color_get_blue_float (color),
@ -199,33 +203,31 @@ cogl_paint_init (const CoglColor *color)
void void
cogl_push_matrix (void) cogl_push_matrix (void)
{ {
glPushMatrix(); GE( glPushMatrix() );
} }
void void
cogl_pop_matrix (void) cogl_pop_matrix (void)
{ {
glPopMatrix(); GE( glPopMatrix() );
} }
void void
cogl_scale (float x, float y) cogl_scale (float x, float y)
{ {
glScalef ((float)(x), GE( glScalef (x, y, 1.0) );
(float)(y),
1.0);
} }
void void
cogl_translate (float x, float y, float z) cogl_translate (float x, float y, float z)
{ {
glTranslatef (x, y, z); GE( glTranslatef (x, y, z) );
} }
void void
cogl_rotate (float angle, float x, float y, float z) cogl_rotate (float angle, float x, float y, float z)
{ {
glRotatef (angle, x, y, z); GE( glRotatef (angle, x, y, z) );
} }
static inline gboolean static inline gboolean
@ -353,10 +355,10 @@ cogl_set_source_color (const CoglColor *color)
} }
static void static void
apply_matrix (const GLfloat *matrix, GLfloat *vertex) apply_matrix (const float *matrix, float *vertex)
{ {
int x, y; int x, y;
GLfloat vertex_out[4] = { 0 }; float vertex_out[4] = { 0 };
for (y = 0; y < 4; y++) for (y = 0; y < 4; y++)
for (x = 0; x < 4; x++) for (x = 0; x < 4; x++)
@ -366,7 +368,9 @@ apply_matrix (const GLfloat *matrix, GLfloat *vertex)
} }
static void static void
project_vertex (GLfloat *modelview, GLfloat *project, GLfloat *vertex) project_vertex (float *modelview,
float *project,
float *vertex)
{ {
int i; int i;
@ -381,8 +385,8 @@ project_vertex (GLfloat *modelview, GLfloat *project, GLfloat *vertex)
static void static void
set_clip_plane (GLint plane_num, set_clip_plane (GLint plane_num,
const GLfloat *vertex_a, const float *vertex_a,
const GLfloat *vertex_b) const float *vertex_b)
{ {
GLdouble plane[4]; GLdouble plane[4];
GLfloat angle; GLfloat angle;
@ -390,15 +394,15 @@ set_clip_plane (GLint plane_num,
/* Calculate the angle between the axes and the line crossing the /* Calculate the angle between the axes and the line crossing the
two points */ two points */
angle = atan2f ((vertex_b[1] - vertex_a[1]), angle = atan2f (vertex_b[1] - vertex_a[1],
(vertex_b[0] - vertex_a[0])) * 180.0f / G_PI; vertex_b[0] - vertex_a[0]) * (180.0/G_PI);
GE( glPushMatrix () ); GE( glPushMatrix () );
/* Load the identity matrix and multiply by the reverse of the /* Load the identity matrix and multiply by the reverse of the
projection matrix so we can specify the plane in screen projection matrix so we can specify the plane in screen
coordinates */ coordinates */
GE( glLoadIdentity () ); GE( glLoadIdentity () );
GE( glMultMatrixf (ctx->inverse_projection) ); GE( glMultMatrixf ((GLfloat *) ctx->inverse_projection) );
/* Rotate about point a */ /* Rotate about point a */
GE( glTranslatef (vertex_a[0], vertex_a[1], vertex_a[2]) ); GE( glTranslatef (vertex_a[0], vertex_a[1], vertex_a[2]) );
/* Rotate the plane by the calculated angle so that it will connect /* Rotate the plane by the calculated angle so that it will connect
@ -406,9 +410,9 @@ set_clip_plane (GLint plane_num,
GE( glRotatef (angle, 0.0f, 0.0f, 1.0f) ); GE( glRotatef (angle, 0.0f, 0.0f, 1.0f) );
GE( glTranslatef (-vertex_a[0], -vertex_a[1], -vertex_a[2]) ); GE( glTranslatef (-vertex_a[0], -vertex_a[1], -vertex_a[2]) );
plane[0] = 0.0f; plane[0] = 0;
plane[1] = -1.0f; plane[1] = -1.0;
plane[2] = 0.0f; plane[2] = 0;
plane[3] = vertex_a[1]; plane[3] = vertex_a[1];
GE( glClipPlane (plane_num, plane) ); GE( glClipPlane (plane_num, plane) );
@ -423,18 +427,11 @@ _cogl_set_clip_planes (float x_offset,
{ {
GLfloat modelview[16], projection[16]; GLfloat modelview[16], projection[16];
GLfloat vertex_tl[4] = { (x_offset), float vertex_tl[4] = { x_offset, y_offset, 0, 1.0 };
(y_offset), float vertex_tr[4] = { x_offset + width, y_offset, 0, 1.0 };
0.0f, 1.0f }; float vertex_bl[4] = { x_offset, y_offset + height, 0, 1.0 };
GLfloat vertex_tr[4] = { (x_offset + width), float vertex_br[4] = { x_offset + width, y_offset + height,
(y_offset), 0, 1.0 };
0.0f, 1.0f };
GLfloat vertex_bl[4] = { (x_offset),
(y_offset + height),
0.0f, 1.0f };
GLfloat vertex_br[4] = { (x_offset + width),
(y_offset + height),
0.0f, 1.0f };
GE( glGetFloatv (GL_MODELVIEW_MATRIX, modelview) ); GE( glGetFloatv (GL_MODELVIEW_MATRIX, modelview) );
GE( glGetFloatv (GL_PROJECTION_MATRIX, projection) ); GE( glGetFloatv (GL_PROJECTION_MATRIX, projection) );
@ -452,7 +449,7 @@ _cogl_set_clip_planes (float x_offset,
if ((vertex_tl[0] < vertex_tr[0] ? 1 : 0) if ((vertex_tl[0] < vertex_tr[0] ? 1 : 0)
!= (vertex_bl[1] < vertex_tl[1] ? 1 : 0)) != (vertex_bl[1] < vertex_tl[1] ? 1 : 0))
{ {
GLfloat temp[4]; float temp[4];
memcpy (temp, vertex_tl, sizeof (temp)); memcpy (temp, vertex_tl, sizeof (temp));
memcpy (vertex_tl, vertex_tr, sizeof (temp)); memcpy (vertex_tl, vertex_tr, sizeof (temp));
memcpy (vertex_tr, temp, sizeof (temp)); memcpy (vertex_tr, temp, sizeof (temp));
@ -512,7 +509,7 @@ _cogl_add_stencil_clip (float x_offset,
GE( glMatrixMode (GL_PROJECTION) ); GE( glMatrixMode (GL_PROJECTION) );
GE( glPushMatrix () ); GE( glPushMatrix () );
GE( glLoadIdentity () ); GE( glLoadIdentity () );
GE( glRecti (-1, 1, 1, -1) ); GE( glRectf (-1, 1, 1, -1) );
GE( glPopMatrix () ); GE( glPopMatrix () );
GE( glMatrixMode (GL_MODELVIEW) ); GE( glMatrixMode (GL_MODELVIEW) );
GE( glPopMatrix () ); GE( glPopMatrix () );
@ -526,14 +523,8 @@ _cogl_add_stencil_clip (float x_offset,
void void
_cogl_set_matrix (const float *matrix) _cogl_set_matrix (const float *matrix)
{ {
float float_matrix[16];
int i;
for (i = 0; i < 16; i++)
float_matrix[i] = (matrix[i]);
GE( glLoadIdentity () ); GE( glLoadIdentity () );
GE( glMultMatrixf (float_matrix) ); GE( glMultMatrixf (matrix) );
} }
void void
@ -597,26 +588,27 @@ cogl_perspective (float fovy,
d = (-(2 * zFar) * zNear) / (zFar - zNear); d = (-(2 * zFar) * zNear) / (zFar - zNear);
#define M(row,col) m[col*4+row] #define M(row,col) m[col*4+row]
M(0,0) = (x); M(0,0) = x;
M(1,1) = (y); M(1,1) = y;
M(2,2) = (c); M(2,2) = c;
M(2,3) = (d); M(2,3) = d;
M(3,2) = -1.0F; M(3,2) = -1.0;
GE( glMultMatrixf (m) ); GE( glMultMatrixf (m) );
GE( glMatrixMode (GL_MODELVIEW) ); GE( glMatrixMode (GL_MODELVIEW) );
/* Calculate and store the inverse of the matrix */ /* Calculate and store the inverse of the matrix */
memset (ctx->inverse_projection, 0, sizeof (GLfloat) * 16); memset (ctx->inverse_projection, 0, sizeof (float) * 16);
#define m ctx->inverse_projection #define m ctx->inverse_projection
M(0, 0) = 1.0f / (x); M(0, 0) = (1.0 / x);
M(1, 1) = 1.0f / (y); M(1, 1) = (1.0 / y);
M(2, 3) = -1.0f; M(2, 3) = -1.0;
M(3, 2) = 1.0f / (d); M(3, 2) = (1.0 / d);
M(3, 3) = (c) / (d); M(3, 3) = (c / d);
#undef m #undef m
#undef M #undef M
} }
@ -628,7 +620,7 @@ cogl_frustum (float left,
float z_near, float z_near,
float z_far) float z_far)
{ {
GLfloat c, d; float c, d;
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -645,24 +637,18 @@ cogl_frustum (float left,
GE( glMatrixMode (GL_MODELVIEW) ); GE( glMatrixMode (GL_MODELVIEW) );
/* Calculate and store the inverse of the matrix */ /* Calculate and store the inverse of the matrix */
memset (ctx->inverse_projection, 0, sizeof (GLfloat) * 16); memset (ctx->inverse_projection, 0, sizeof (float) * 16);
c = - (z_far + z_near) c = - (z_far + z_near) / (z_far - z_near);
/ (z_far - z_near); d = - (2 * (z_far * z_near)) / (z_far - z_near);
d = - (2 * (z_far * z_near))
/ (z_far - z_near);
#define M(row,col) ctx->inverse_projection[col*4+row] #define M(row,col) ctx->inverse_projection[col*4+row]
M(0,0) = (right - left) M(0,0) = (right - left) / (2 * z_near);
/ (2 * z_near); M(0,3) = (right + left) / (2 * z_near);
M(0,3) = (right + left) M(1,1) = (top - bottom) / (2 * z_near);
/ (2 * z_near); M(1,3) = (top + bottom) / (2 * z_near);
M(1,1) = (top - bottom) M(2,3) = -1.0;
/ (2 * z_near); M(3,2) = 1.0 / d;
M(1,3) = (top + bottom)
/ (2 * z_near);
M(2,3) = -1.0f;
M(3,2) = 1.0f / d;
M(3,3) = c / d; M(3,3) = c / d;
#undef M #undef M
} }
@ -675,18 +661,22 @@ cogl_viewport (guint width,
} }
void void
cogl_setup_viewport (guint width, cogl_setup_viewport (guint width,
guint height, guint height,
float fovy, float fovy,
float aspect, float aspect,
float z_near, float z_near,
float z_far) float z_far)
{ {
GLfloat z_camera; float z_camera;
GLfloat projection_matrix[16]; float projection_matrix[16];
GE( glViewport (0, 0, width, height) ); GE( glViewport (0, 0, width, height) );
/* For Ortho projection.
* glOrthof (0, width << 16, 0, height << 16, -1 << 16, 1 << 16);
*/
cogl_perspective (fovy, aspect, z_near, z_far); cogl_perspective (fovy, aspect, z_near, z_far);
/* /*
@ -734,9 +724,7 @@ cogl_setup_viewport (guint width,
GE( glLoadIdentity () ); GE( glLoadIdentity () );
GE( glTranslatef (-0.5f, -0.5f, -z_camera) ); GE( glTranslatef (-0.5f, -0.5f, -z_camera) );
GE( glScalef ( 1.0f / width, GE( glScalef (1.0f / width, -1.0f / height, 1.0f / width) );
-1.0f / height,
1.0f / width) );
GE( glTranslatef (0.0f, -1.0 * height, 0.0f) ); GE( glTranslatef (0.0f, -1.0 * height, 0.0f) );
} }
@ -1165,8 +1153,8 @@ cogl_get_bitmasks (gint *red, gint *green, gint *blue, gint *alpha)
void void
cogl_fog_set (const CoglColor *fog_color, cogl_fog_set (const CoglColor *fog_color,
float density, float density,
float start, float z_near,
float stop) float z_far)
{ {
GLfloat fogColor[4]; GLfloat fogColor[4];
@ -1182,8 +1170,8 @@ cogl_fog_set (const CoglColor *fog_color,
glFogi (GL_FOG_MODE, GL_LINEAR); glFogi (GL_FOG_MODE, GL_LINEAR);
glHint (GL_FOG_HINT, GL_NICEST); glHint (GL_FOG_HINT, GL_NICEST);
glFogf (GL_FOG_DENSITY, (density)); glFogf (GL_FOG_DENSITY, (GLfloat) density);
glFogf (GL_FOG_START, (start)); glFogf (GL_FOG_START, (GLfloat) z_near);
glFogf (GL_FOG_END, (stop)); glFogf (GL_FOG_END, (GLfloat) z_far);
} }

2
gles/cogl-context.c
View File

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

32
gles/cogl-fbo.c
View File

@ -206,29 +206,29 @@ cogl_draw_buffer (CoglBufferTarget target, CoglHandle offscreen)
from a non-screen buffer */ from a non-screen buffer */
GE( glGetIntegerv (GL_VIEWPORT, ctx->viewport_store) ); GE( glGetIntegerv (GL_VIEWPORT, ctx->viewport_store) );
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) ); GE( glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glPushMatrix () ); GE( glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () ); GE( glLoadIdentity () );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) ); GE( glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPushMatrix () ); GE( glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () ); GE( glLoadIdentity () );
} }
else else
{ {
/* Override viewport and matrix setup if redirecting /* Override viewport and matrix setup if redirecting
from another offscreen buffer */ from another offscreen buffer */
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) ); GE( glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glLoadIdentity () ); GE( glLoadIdentity () );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) ); GE( glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glLoadIdentity () ); GE( glLoadIdentity () );
} }
/* Setup new viewport and matrices */ /* Setup new viewport and matrices */
GE( glViewport (0, 0, fbo->width, fbo->height) ); GE( glViewport (0, 0, fbo->width, fbo->height) );
GE( cogl_wrap_glTranslatef (-1.0, -1.0, 0) ); GE( glTranslatef (-1.0, -1.0, 0) );
GE( cogl_wrap_glScalef (((float)(2) / GE( glScalef (((float)(2) /
(float)(fbo->width)), (float)(fbo->width)),
((float)(2) / ((float)(2) /
(float)(fbo->height)), (float)(fbo->height)),
@ -265,11 +265,11 @@ cogl_draw_buffer (CoglBufferTarget target, CoglHandle offscreen)
GE( glViewport (ctx->viewport_store[0], ctx->viewport_store[1], GE( glViewport (ctx->viewport_store[0], ctx->viewport_store[1],
ctx->viewport_store[2], ctx->viewport_store[3]) ); ctx->viewport_store[2], ctx->viewport_store[3]) );
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) ); GE( glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glPopMatrix () ); GE( glPopMatrix () );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) ); GE( glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPopMatrix () ); GE( glPopMatrix () );
} }
/* Bind window framebuffer object */ /* Bind window framebuffer object */

34
gles/cogl-primitives.c
View File

@ -55,8 +55,8 @@ _cogl_rectangle (float x,
cogl_enable (COGL_ENABLE_VERTEX_ARRAY cogl_enable (COGL_ENABLE_VERTEX_ARRAY
| (ctx->color_alpha < 255 ? COGL_ENABLE_BLEND : 0)); | (ctx->color_alpha < 255 ? COGL_ENABLE_BLEND : 0));
GE ( cogl_wrap_glVertexPointer (2, GL_FLOAT, 0, rect_verts ) ); GE ( glVertexPointer (2, GL_FLOAT, 0, rect_verts ) );
GE ( cogl_wrap_glDrawArrays (GL_TRIANGLE_STRIP, 0, 4) ); GE ( glDrawArrays (GL_TRIANGLE_STRIP, 0, 4) );
} }
void void
@ -109,10 +109,10 @@ _cogl_path_stroke_nodes ()
CoglPathNode *path = &g_array_index (ctx->path_nodes, CoglPathNode, CoglPathNode *path = &g_array_index (ctx->path_nodes, CoglPathNode,
path_start); path_start);
GE( cogl_wrap_glVertexPointer (2, GL_FIXED, sizeof (CoglPathNode), GE( glVertexPointer (2, GL_FIXED, sizeof (CoglPathNode),
(guchar *) path (guchar *) path
+ G_STRUCT_OFFSET (CoglPathNode, x)) ); + G_STRUCT_OFFSET (CoglPathNode, x)) );
GE( cogl_wrap_glDrawArrays (GL_LINE_STRIP, 0, path->path_size) ); GE( glDrawArrays (GL_LINE_STRIP, 0, path->path_size) );
path_start += path->path_size; path_start += path->path_size;
} }
@ -167,7 +167,7 @@ _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
GE( glStencilFunc (GL_LEQUAL, 0x1, 0x3) ); GE( glStencilFunc (GL_LEQUAL, 0x1, 0x3) );
} }
GE( cogl_wrap_glEnable (GL_STENCIL_TEST) ); GE( glEnable (GL_STENCIL_TEST) );
GE( glStencilOp (GL_INVERT, GL_INVERT, GL_INVERT) ); GE( glStencilOp (GL_INVERT, GL_INVERT, GL_INVERT) );
GE( glColorMask (FALSE, FALSE, FALSE, FALSE) ); GE( glColorMask (FALSE, FALSE, FALSE, FALSE) );
@ -177,10 +177,10 @@ _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
{ {
cogl_enable (COGL_ENABLE_VERTEX_ARRAY); cogl_enable (COGL_ENABLE_VERTEX_ARRAY);
GE( cogl_wrap_glVertexPointer (2, GL_FIXED, sizeof (CoglPathNode), GE( glVertexPointer (2, GL_FIXED, sizeof (CoglPathNode),
(guchar *) path (guchar *) path
+ G_STRUCT_OFFSET (CoglPathNode, x)) ); + G_STRUCT_OFFSET (CoglPathNode, x)) );
GE( cogl_wrap_glDrawArrays (GL_TRIANGLE_FAN, 0, path->path_size) ); GE( glDrawArrays (GL_TRIANGLE_FAN, 0, path->path_size) );
if (sub_path_num > 0) if (sub_path_num > 0)
{ {
@ -209,16 +209,16 @@ _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
GE( glStencilOp (GL_DECR, GL_DECR, GL_DECR) ); GE( glStencilOp (GL_DECR, GL_DECR, GL_DECR) );
/* Decrement all of the bits twice so that only pixels where the /* Decrement all of the bits twice so that only pixels where the
value is 3 will remain */ value is 3 will remain */
GE( cogl_wrap_glPushMatrix () ); GE( glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () ); GE( glLoadIdentity () );
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) ); GE( glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glPushMatrix () ); GE( glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () ); GE( glLoadIdentity () );
cogl_rectangle (-1.0, -1.0, 2, 2); cogl_rectangle (-1.0, -1.0, 2, 2);
cogl_rectangle (-1.0, -1.0, 2, 2); cogl_rectangle (-1.0, -1.0, 2, 2);
GE( cogl_wrap_glPopMatrix () ); GE( glPopMatrix () );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) ); GE( glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPopMatrix () ); GE( glPopMatrix () );
} }
GE( glStencilMask (~(GLuint) 0) ); GE( glStencilMask (~(GLuint) 0) );
@ -392,8 +392,8 @@ _cogl_path_fill_nodes_scanlines (CoglPathNode *path,
/* render triangles */ /* render triangles */
cogl_enable (COGL_ENABLE_VERTEX_ARRAY cogl_enable (COGL_ENABLE_VERTEX_ARRAY
| (ctx->color_alpha < 255 ? COGL_ENABLE_BLEND : 0)); | (ctx->color_alpha < 255 ? COGL_ENABLE_BLEND : 0));
GE ( cogl_wrap_glVertexPointer (2, GL_FIXED, 0, coords ) ); GE ( glVertexPointer (2, GL_FIXED, 0, coords ) );
GE ( cogl_wrap_glDrawArrays (GL_TRIANGLES, 0, spans * 2 * 3)); GE ( glDrawArrays (GL_TRIANGLES, 0, spans * 2 * 3));
g_free (coords); g_free (coords);
} }
} }

585
gles/cogl-texture.c
View File

File diff suppressed because it is too large Load Diff

286
gles/cogl.c
View File

@ -73,14 +73,13 @@ _cogl_error_string(GLenum errorCode)
} }
#endif #endif
CoglFuncPtr CoglFuncPtr
cogl_get_proc_address (const gchar* name) cogl_get_proc_address (const gchar* name)
{ {
return NULL; return NULL;
} }
gboolean gboolean
cogl_check_extension (const gchar *name, const gchar *ext) cogl_check_extension (const gchar *name, const gchar *ext)
{ {
return FALSE; return FALSE;
@ -99,39 +98,53 @@ cogl_paint_init (const CoglColor *color)
0); 0);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
cogl_wrap_glDisable (GL_LIGHTING); glDisable (GL_LIGHTING);
cogl_wrap_glDisable (GL_FOG); glDisable (GL_FOG);
/*
* Disable the depth test for now as has some strange side effects,
* mainly on x/y axis rotation with multiple layers at same depth
* (eg rotating text on a bg has very strange effect). Seems no clean
* 100% effective way to fix without other odd issues.. So for now
* move to application to handle and add cogl_enable_depth_test()
* as for custom actors (i.e groups) to enable if need be.
*
* glEnable (GL_DEPTH_TEST);
* glEnable (GL_ALPHA_TEST)
* glDepthFunc (GL_LEQUAL);
* glAlphaFunc (GL_GREATER, 0.1);
*/
} }
/* FIXME: inline most of these */ /* FIXME: inline most of these */
void void
cogl_push_matrix (void) cogl_push_matrix (void)
{ {
GE( cogl_wrap_glPushMatrix() ); GE( glPushMatrix() );
} }
void void
cogl_pop_matrix (void) cogl_pop_matrix (void)
{ {
GE( cogl_wrap_glPopMatrix() ); GE( glPopMatrix() );
} }
void void
cogl_scale (float x, float y) cogl_scale (float x, float y)
{ {
GE( cogl_wrap_glScalef (x, y, 1.0) ); GE( glScalef (x, y, 1.0) );
} }
void void
cogl_translate (float x, float y, float z) cogl_translate (float x, float y, float z)
{ {
GE( cogl_wrap_glTranslatef (x, y, z) ); GE( glTranslatef (x, y, z) );
} }
void void
cogl_rotate (float angle, float x, float y, float z) cogl_rotate (float angle, float x, float y, float z)
{ {
GE( cogl_wrap_glRotatef (angle, x, y, z) ); GE( glRotatef (angle, x, y, z) );
} }
static inline gboolean static inline gboolean
@ -147,17 +160,17 @@ cogl_toggle_flag (CoglContext *ctx,
{ {
if (!(ctx->enable_flags & flag)) if (!(ctx->enable_flags & flag))
{ {
GE( cogl_wrap_glEnable (gl_flag) ); GE( glEnable (gl_flag) );
ctx->enable_flags |= flag; ctx->enable_flags |= flag;
return TRUE; return TRUE;
} }
} }
else if (ctx->enable_flags & flag) else if (ctx->enable_flags & flag)
{ {
GE( cogl_wrap_glDisable (gl_flag) ); GE( glDisable (gl_flag) );
ctx->enable_flags &= ~flag; ctx->enable_flags &= ~flag;
} }
return FALSE; return FALSE;
} }
@ -174,17 +187,17 @@ cogl_toggle_client_flag (CoglContext *ctx,
{ {
if (!(ctx->enable_flags & flag)) if (!(ctx->enable_flags & flag))
{ {
GE( cogl_wrap_glEnableClientState (gl_flag) ); GE( glEnableClientState (gl_flag) );
ctx->enable_flags |= flag; ctx->enable_flags |= flag;
return TRUE; return TRUE;
} }
} }
else if (ctx->enable_flags & flag) else if (ctx->enable_flags & flag)
{ {
GE( cogl_wrap_glDisableClientState (gl_flag) ); GE( glDisableClientState (gl_flag) );
ctx->enable_flags &= ~flag; ctx->enable_flags &= ~flag;
} }
return FALSE; return FALSE;
} }
@ -195,11 +208,11 @@ cogl_enable (gulong flags)
* hope of lessening number GL traffic. * hope of lessening number GL traffic.
*/ */
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
cogl_toggle_flag (ctx, flags, cogl_toggle_flag (ctx, flags,
COGL_ENABLE_BLEND, COGL_ENABLE_BLEND,
GL_BLEND); GL_BLEND);
cogl_toggle_flag (ctx, flags, cogl_toggle_flag (ctx, flags,
COGL_ENABLE_TEXTURE_2D, COGL_ENABLE_TEXTURE_2D,
GL_TEXTURE_2D); GL_TEXTURE_2D);
@ -211,7 +224,7 @@ cogl_enable (gulong flags)
cogl_toggle_client_flag (ctx, flags, cogl_toggle_client_flag (ctx, flags,
COGL_ENABLE_VERTEX_ARRAY, COGL_ENABLE_VERTEX_ARRAY,
GL_VERTEX_ARRAY); GL_VERTEX_ARRAY);
cogl_toggle_client_flag (ctx, flags, cogl_toggle_client_flag (ctx, flags,
COGL_ENABLE_TEXCOORD_ARRAY, COGL_ENABLE_TEXCOORD_ARRAY,
GL_TEXTURE_COORD_ARRAY); GL_TEXTURE_COORD_ARRAY);
@ -225,7 +238,7 @@ gulong
cogl_get_enable () cogl_get_enable ()
{ {
_COGL_GET_CONTEXT (ctx, 0); _COGL_GET_CONTEXT (ctx, 0);
return ctx->enable_flags; return ctx->enable_flags;
} }
@ -234,15 +247,15 @@ cogl_enable_depth_test (gboolean setting)
{ {
if (setting) if (setting)
{ {
cogl_wrap_glEnable (GL_DEPTH_TEST); glEnable (GL_DEPTH_TEST);
cogl_wrap_glEnable (GL_ALPHA_TEST); glEnable (GL_ALPHA_TEST);
glDepthFunc (GL_LEQUAL); glDepthFunc (GL_LEQUAL);
cogl_wrap_glAlphaFunc (GL_GREATER, 0.1); glAlphaFunc (GL_GREATER, 0.1);
} }
else else
{ {
cogl_wrap_glDisable (GL_DEPTH_TEST); glDisable (GL_DEPTH_TEST);
cogl_wrap_glDisable (GL_ALPHA_TEST); glDisable (GL_ALPHA_TEST);
} }
} }
@ -258,14 +271,14 @@ void
cogl_set_source_color (const CoglColor *color) cogl_set_source_color (const CoglColor *color)
{ {
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
#if 0 /*HAVE_GLES_COLOR4UB*/ #if 0 /*HAVE_GLES_COLOR4UB*/
/* NOTE: seems SDK_OGLES-1.1_LINUX_PCEMULATION_2.02.22.0756 has this call /* NOTE: seems SDK_OGLES-1.1_LINUX_PCEMULATION_2.02.22.0756 has this call
* but is broken - see #857. Therefor disabling. * but is broken - see #857. Therefor disabling.
*/ */
/* /*
* GLES 1.1 does actually have this function, it's in the header file but * GLES 1.1 does actually have this function, it's in the header file but
* missing in the reference manual (and SDK): * missing in the reference manual (and SDK):
* *
@ -279,12 +292,12 @@ cogl_set_source_color (const CoglColor *color)
#else #else
/* conversion can cause issues with picking on some gles implementations */ /* conversion can cause issues with picking on some gles implementations */
GE( cogl_wrap_glColor4f (cogl_color_get_red (color), GE( glColor4f (cogl_color_get_red (color),
cogl_color_get_green (color), cogl_color_get_green (color),
cogl_color_get_blue (color), cogl_color_get_blue (color),
cogl_color_get_alpha (color)) ); cogl_color_get_alpha (color)) );
#endif #endif
/* Store alpha for proper blending enables */ /* Store alpha for proper blending enables */
ctx->color_alpha = cogl_color_get_alpha_byte (color); ctx->color_alpha = cogl_color_get_alpha_byte (color);
} }
@ -297,7 +310,7 @@ apply_matrix (const float *matrix, float *vertex)
for (y = 0; y < 4; y++) for (y = 0; y < 4; y++)
for (x = 0; x < 4; x++) for (x = 0; x < 4; x++)
vertex_out[y] += (vertex[x] * matrix[y + x * 4]); vertex_out[y] += vertex[x] * matrix[y + x * 4];
memcpy (vertex, vertex_out, sizeof (vertex_out)); memcpy (vertex, vertex_out, sizeof (vertex_out));
} }
@ -315,7 +328,7 @@ project_vertex (float *modelview,
apply_matrix (project, vertex); apply_matrix (project, vertex);
/* Convert from homogenized coordinates */ /* Convert from homogenized coordinates */
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++)
vertex[i] = (vertex[i] / vertex[3]); vertex[i] /= vertex[3];
} }
static void static void
@ -332,26 +345,26 @@ set_clip_plane (GLint plane_num,
angle = atan2f (vertex_b[1] - vertex_a[1], angle = atan2f (vertex_b[1] - vertex_a[1],
vertex_b[0] - vertex_a[0]) * (180.0/G_PI); vertex_b[0] - vertex_a[0]) * (180.0/G_PI);
GE( cogl_wrap_glPushMatrix () ); GE( glPushMatrix () );
/* Load the identity matrix and multiply by the reverse of the /* Load the identity matrix and multiply by the reverse of the
projection matrix so we can specify the plane in screen projection matrix so we can specify the plane in screen
coordinates */ coordinates */
GE( cogl_wrap_glLoadIdentity () ); GE( glLoadIdentity () );
GE( cogl_wrap_glMultMatrixf ((GLfloat *) ctx->inverse_projection) ); GE( glMultMatrixf ((GLfloat *) ctx->inverse_projection) );
/* Rotate about point a */ /* Rotate about point a */
GE( cogl_wrap_glTranslatef (vertex_a[0], vertex_a[1], vertex_a[2]) ); GE( glTranslatef (vertex_a[0], vertex_a[1], vertex_a[2]) );
/* Rotate the plane by the calculated angle so that it will connect /* Rotate the plane by the calculated angle so that it will connect
the two points */ the two points */
GE( cogl_wrap_glRotatef (angle, 0.0f, 0.0f, 1.0f) ); GE( glRotatef (angle, 0.0f, 0.0f, 1.0f) );
GE( cogl_wrap_glTranslatef (-vertex_a[0], -vertex_a[1], -vertex_a[2]) ); GE( glTranslatef (-vertex_a[0], -vertex_a[1], -vertex_a[2]) );
plane[0] = 0; plane[0] = 0;
plane[1] = -1.0; plane[1] = -1.0;
plane[2] = 0; plane[2] = 0;
plane[3] = vertex_a[1]; plane[3] = vertex_a[1];
GE( cogl_wrap_glClipPlanef (plane_num, plane) ); GE( glClipPlanef (plane_num, plane) );
GE( cogl_wrap_glPopMatrix () ); GE( glPopMatrix () );
} }
void void
@ -366,21 +379,21 @@ _cogl_set_clip_planes (float x_offset,
float vertex_tr[4] = { x_offset + width, 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_bl[4] = { x_offset, y_offset + height, 0, 1.0 };
float vertex_br[4] = { x_offset + width, y_offset + height, float vertex_br[4] = { x_offset + width, y_offset + height,
0, 1.0 }; 0, 1.0 };
GE( cogl_wrap_glGetFloatv (GL_MODELVIEW_MATRIX, modelview) ); GE( glGetFloatv (GL_MODELVIEW_MATRIX, modelview) );
GE( cogl_wrap_glGetFloatv (GL_PROJECTION_MATRIX, projection) ); GE( glGetFloatv (GL_PROJECTION_MATRIX, projection) );
project_vertex (modelview, projection, vertex_tl); project_vertex (modelview, projection, vertex_tl);
project_vertex (modelview, projection, vertex_tr); project_vertex (modelview, projection, vertex_tr);
project_vertex (modelview, projection, vertex_bl); project_vertex (modelview, projection, vertex_bl);
project_vertex (modelview, projection, vertex_br); project_vertex (modelview, projection, vertex_br);
/* If the order of the top and bottom lines is different from /* If the order of the top and bottom lines is different from the
the order of the left and right lines then the clip rect must order of the left and right lines then the clip rect must have
have been transformed so that the back is visible. We been transformed so that the back is visible. We therefore need
therefore need to swap one pair of vertices otherwise all of to swap one pair of vertices otherwise all of the planes will be
the planes will be the wrong way around */ the wrong way around */
if ((vertex_tl[0] < vertex_tr[0] ? 1 : 0) if ((vertex_tl[0] < vertex_tr[0] ? 1 : 0)
!= (vertex_bl[1] < vertex_tl[1] ? 1 : 0)) != (vertex_bl[1] < vertex_tl[1] ? 1 : 0))
{ {
@ -410,8 +423,8 @@ _cogl_add_stencil_clip (float x_offset,
if (first) if (first)
{ {
GE( cogl_wrap_glEnable (GL_STENCIL_TEST) ); GE( glEnable (GL_STENCIL_TEST) );
/* Initially disallow everything */ /* Initially disallow everything */
GE( glClearStencil (0) ); GE( glClearStencil (0) );
GE( glClear (GL_STENCIL_BUFFER_BIT) ); GE( glClear (GL_STENCIL_BUFFER_BIT) );
@ -434,15 +447,15 @@ _cogl_add_stencil_clip (float x_offset,
only pixels where both the original stencil buffer and the only pixels where both the original stencil buffer and the
rectangle are set will be valid */ rectangle are set will be valid */
GE( glStencilOp (GL_DECR, GL_DECR, GL_DECR) ); GE( glStencilOp (GL_DECR, GL_DECR, GL_DECR) );
GE( cogl_wrap_glPushMatrix () ); GE( glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () ); GE( glLoadIdentity () );
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) ); GE( glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glPushMatrix () ); GE( glPushMatrix () );
GE( cogl_wrap_glLoadIdentity () ); GE( glLoadIdentity () );
cogl_rectangle (-1.0, -1.0, 2, 2); cogl_rectangle (-1.0, -1.0, 2, 2);
GE( cogl_wrap_glPopMatrix () ); GE( glPopMatrix () );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) ); GE( glMatrixMode (GL_MODELVIEW) );
GE( cogl_wrap_glPopMatrix () ); GE( glPopMatrix () );
} }
/* Restore the stencil mode */ /* Restore the stencil mode */
@ -453,37 +466,34 @@ _cogl_add_stencil_clip (float x_offset,
void void
_cogl_set_matrix (const float *matrix) _cogl_set_matrix (const float *matrix)
{ {
GE( cogl_wrap_glLoadIdentity () ); GE( glLoadIdentity () );
GE( cogl_wrap_glMultMatrixf (matrix) ); GE( glMultMatrixf (matrix) );
} }
void void
_cogl_disable_stencil_buffer (void) _cogl_disable_stencil_buffer (void)
{ {
GE( cogl_wrap_glDisable (GL_STENCIL_TEST) ); GE( glDisable (GL_STENCIL_TEST) );
} }
void void
_cogl_enable_clip_planes (void) _cogl_enable_clip_planes (void)
{ {
GE( cogl_wrap_glEnable (GL_CLIP_PLANE0) ); GE( glEnable (GL_CLIP_PLANE0) );
GE( cogl_wrap_glEnable (GL_CLIP_PLANE1) ); GE( glEnable (GL_CLIP_PLANE1) );
GE( cogl_wrap_glEnable (GL_CLIP_PLANE2) ); GE( glEnable (GL_CLIP_PLANE2) );
GE( cogl_wrap_glEnable (GL_CLIP_PLANE3) ); GE( glEnable (GL_CLIP_PLANE3) );
} }
void void
_cogl_disable_clip_planes (void) _cogl_disable_clip_planes (void)
{ {
GE( cogl_wrap_glDisable (GL_CLIP_PLANE3) ); GE( glDisable (GL_CLIP_PLANE3) );
GE( cogl_wrap_glDisable (GL_CLIP_PLANE2) ); GE( glDisable (GL_CLIP_PLANE2) );
GE( cogl_wrap_glDisable (GL_CLIP_PLANE1) ); GE( glDisable (GL_CLIP_PLANE1) );
GE( cogl_wrap_glDisable (GL_CLIP_PLANE0) ); GE( glDisable (GL_CLIP_PLANE0) );
} }
/*
* Fixed point implementation of the perspective function
*/
void void
cogl_perspective (float fovy, cogl_perspective (float fovy,
float aspect, float aspect,
@ -495,21 +505,21 @@ cogl_perspective (float fovy,
float fovy_rad_half = (fovy * G_PI) / 360; float fovy_rad_half = (fovy * G_PI) / 360;
GLfloat m[16]; GLfloat m[16];
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
memset (&m[0], 0, sizeof (m)); memset (&m[0], 0, sizeof (m));
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) ); GE( glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glLoadIdentity () ); GE( glLoadIdentity () );
/* /*
* Based on the original algorithm in perspective(): * Based on the original algorithm in perspective():
* *
* 1) xmin = -xmax => xmax + xmin == 0 && xmax - xmin == 2 * xmax * 1) xmin = -xmax => xmax + xmin == 0 && xmax - xmin == 2 * xmax
* same true for y, hence: a == 0 && b == 0; * same true for y, hence: a == 0 && b == 0;
* *
* 2) When working with small numbers, we can are loosing significant * 2) When working with small numbers, we are loosing significant
* precision * precision
*/ */
ymax = (zNear * (sinf (fovy_rad_half) / cosf (fovy_rad_half))); ymax = (zNear * (sinf (fovy_rad_half) / cosf (fovy_rad_half)));
@ -527,9 +537,9 @@ cogl_perspective (float fovy,
M(2,3) = d; M(2,3) = d;
M(3,2) = -1.0; M(3,2) = -1.0;
GE( cogl_wrap_glMultMatrixf (m) ); GE( glMultMatrixf (m) );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) ); GE( glMatrixMode (GL_MODELVIEW) );
/* Calculate and store the inverse of the matrix */ /* Calculate and store the inverse of the matrix */
memset (ctx->inverse_projection, 0, sizeof (float) * 16); memset (ctx->inverse_projection, 0, sizeof (float) * 16);
@ -557,30 +567,33 @@ cogl_frustum (float left,
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
GE( cogl_wrap_glMatrixMode (GL_PROJECTION) ); GE( glMatrixMode (GL_PROJECTION) );
GE( cogl_wrap_glLoadIdentity () ); GE( glLoadIdentity () );
GE( cogl_wrap_glFrustumf (left, right, GE( glFrustumf (left,
bottom, top, right,
z_near, z_far) ); bottom,
top,
z_near,
z_far) );
GE( cogl_wrap_glMatrixMode (GL_MODELVIEW) ); GE( glMatrixMode (GL_MODELVIEW) );
/* Calculate and store the inverse of the matrix */ /* Calculate and store the inverse of the matrix */
memset (ctx->inverse_projection, 0, sizeof (float) * 16); memset (ctx->inverse_projection, 0, sizeof (float) * 16);
c = -(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); d = - (2 * (z_far * z_near)) / (z_far - z_near);
#define M(row,col) ctx->inverse_projection[col*4+row] #define M(row,col) ctx->inverse_projection[col*4+row]
M(0,0) = (right - left / 2 * z_near); M(0,0) = (right - left) / (2 * z_near);
M(0,3) = (right + left / 2 * z_near); M(0,3) = (right + left) / (2 * z_near);
M(1,1) = (top - bottom / 2 * z_near); M(1,1) = (top - bottom) / (2 * z_near);
M(1,3) = (top + bottom / 2 * z_near); M(1,3) = (top + bottom) / (2 * z_near);
M(2,3) = -1.0; M(2,3) = -1.0;
M(3,2) = (1.0 / d); M(3,2) = 1.0 / d;
M(3,3) = (c / d); M(3,3) = c / d;
#undef M #undef M
} }
void void
@ -591,26 +604,24 @@ cogl_viewport (guint width,
} }
void void
cogl_setup_viewport (guint w, cogl_setup_viewport (guint width,
guint h, guint height,
float fovy, float fovy,
float aspect, float aspect,
float z_near, float z_near,
float z_far) float z_far)
{ {
gint width = (gint) w;
gint height = (gint) h;
float z_camera; float z_camera;
float projection_matrix[16]; float projection_matrix[16];
GE( glViewport (0, 0, width, height) ); GE( glViewport (0, 0, width, height) );
/* For Ortho projection. /* For Ortho projection.
* cogl_wrap_glOrthof (0, width << 16, 0, height << 16, -1 << 16, 1 << 16); * glOrthof (0, width << 16, 0, height << 16, -1 << 16, 1 << 16);
*/ */
cogl_perspective (fovy, aspect, z_near, z_far); cogl_perspective (fovy, aspect, z_near, z_far);
/* /*
* camera distance from screen * camera distance from screen
* *
@ -620,15 +631,13 @@ cogl_setup_viewport (guint w,
cogl_get_projection_matrix (projection_matrix); cogl_get_projection_matrix (projection_matrix);
z_camera = 0.5 * projection_matrix[0]; z_camera = 0.5 * projection_matrix[0];
GE( cogl_wrap_glLoadIdentity () ); GE( glLoadIdentity () );
GE( cogl_wrap_glTranslatef (-0.5f, -0.5f, -z_camera) ); GE( glTranslatef (-0.5f, -0.5f, -z_camera) );
GE( cogl_wrap_glScalef ( 1.0 / width, GE( glScalef (1.0f / width, -1.0f / height, 1.0f / width) );
-1.0 / height,
1.0 / width) );
GE( cogl_wrap_glTranslatef (0, -1.0 * height, 0) ); GE( glTranslatef (0.0f, -1.0 * height, 0.0f) );
} }
static void static void
@ -640,12 +649,12 @@ _cogl_features_init ()
_COGL_GET_CONTEXT (ctx, NO_RETVAL); _COGL_GET_CONTEXT (ctx, NO_RETVAL);
GE( cogl_wrap_glGetIntegerv (GL_STENCIL_BITS, &num_stencil_bits) ); GE( glGetIntegerv (GL_STENCIL_BITS, &num_stencil_bits) );
/* We need at least three stencil bits to combine clips */ /* We need at least three stencil bits to combine clips */
if (num_stencil_bits > 2) if (num_stencil_bits > 2)
flags |= COGL_FEATURE_STENCIL_BUFFER; flags |= COGL_FEATURE_STENCIL_BUFFER;
GE( cogl_wrap_glGetIntegerv (GL_MAX_CLIP_PLANES, &max_clip_planes) ); GE( glGetIntegerv (GL_MAX_CLIP_PLANES, &max_clip_planes) );
if (max_clip_planes >= 4) if (max_clip_planes >= 4)
flags |= COGL_FEATURE_FOUR_CLIP_PLANES; flags |= COGL_FEATURE_FOUR_CLIP_PLANES;
@ -653,6 +662,7 @@ _cogl_features_init ()
flags |= COGL_FEATURE_SHADERS_GLSL | COGL_FEATURE_OFFSCREEN; flags |= COGL_FEATURE_SHADERS_GLSL | COGL_FEATURE_OFFSCREEN;
#endif #endif
/* Cache features */
ctx->feature_flags = flags; ctx->feature_flags = flags;
ctx->features_cached = TRUE; ctx->features_cached = TRUE;
} }
@ -661,10 +671,10 @@ CoglFeatureFlags
cogl_get_features () cogl_get_features ()
{ {
_COGL_GET_CONTEXT (ctx, 0); _COGL_GET_CONTEXT (ctx, 0);
if (!ctx->features_cached) if (!ctx->features_cached)
_cogl_features_init (); _cogl_features_init ();
return ctx->feature_flags; return ctx->feature_flags;
} }
@ -672,23 +682,23 @@ gboolean
cogl_features_available (CoglFeatureFlags features) cogl_features_available (CoglFeatureFlags features)
{ {
_COGL_GET_CONTEXT (ctx, 0); _COGL_GET_CONTEXT (ctx, 0);
if (!ctx->features_cached) if (!ctx->features_cached)
_cogl_features_init (); _cogl_features_init ();
return (ctx->feature_flags & features) == features; return (ctx->feature_flags & features) == features;
} }
void void
cogl_get_modelview_matrix (float m[16]) cogl_get_modelview_matrix (float m[16])
{ {
cogl_wrap_glGetFloatv (GL_MODELVIEW_MATRIX, m); glGetFloatv (GL_MODELVIEW_MATRIX, m);
} }
void void
cogl_get_projection_matrix (float m[16]) cogl_get_projection_matrix (float m[16])
{ {
cogl_wrap_glGetFloatv (GL_PROJECTION_MATRIX, m); glGetFloatv (GL_PROJECTION_MATRIX, m);
} }
void void
@ -697,7 +707,7 @@ cogl_get_viewport (float v[4])
GLint viewport[4]; GLint viewport[4];
int i; int i;
cogl_wrap_glGetIntegerv (GL_VIEWPORT, viewport); glGetIntegerv (GL_VIEWPORT, viewport);
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++)
v[i] = (float)(viewport[i]); v[i] = (float)(viewport[i]);
@ -706,14 +716,27 @@ cogl_get_viewport (float v[4])
void void
cogl_get_bitmasks (gint *red, gint *green, gint *blue, gint *alpha) cogl_get_bitmasks (gint *red, gint *green, gint *blue, gint *alpha)
{ {
GLint value;
if (red) if (red)
GE( cogl_wrap_glGetIntegerv(GL_RED_BITS, red) ); {
GE( glGetIntegerv(GL_RED_BITS, &value) );
*red = value;
}
if (green) if (green)
GE( cogl_wrap_glGetIntegerv(GL_GREEN_BITS, green) ); {
GE( glGetIntegerv(GL_GREEN_BITS, &value) );
*green = value;
}
if (blue) if (blue)
GE( cogl_wrap_glGetIntegerv(GL_BLUE_BITS, blue) ); {
GE( glGetIntegerv(GL_BLUE_BITS, &value) );
*blue = value;
}
if (alpha) if (alpha)
GE( cogl_wrap_glGetIntegerv(GL_ALPHA_BITS, alpha ) ); {
GE( glGetIntegerv(GL_ALPHA_BITS, &value ) );
*alpha = value;
}
} }
void void
@ -724,19 +747,20 @@ cogl_fog_set (const CoglColor *fog_color,
{ {
GLfloat fogColor[4]; GLfloat fogColor[4];
fogColor[0] = cogl_color_get_red (fog_color); fogColor[0] = cogl_color_get_red_float (fog_color);
fogColor[1] = cogl_color_get_green (fog_color); fogColor[1] = cogl_color_get_green_float (fog_color);
fogColor[2] = cogl_color_get_blue (fog_color); fogColor[2] = cogl_color_get_blue_float (fog_color);
fogColor[3] = cogl_color_get_alpha (fog_color); fogColor[3] = cogl_color_get_alpha_float (fog_color);
cogl_wrap_glEnable (GL_FOG); glEnable (GL_FOG);
cogl_wrap_glFogfv (GL_FOG_COLOR, fogColor); glFogfv (GL_FOG_COLOR, fogColor);
cogl_wrap_glFogf (GL_FOG_MODE, GL_LINEAR); glFogf (GL_FOG_MODE, GL_LINEAR);
glHint (GL_FOG_HINT, GL_NICEST); glHint (GL_FOG_HINT, GL_NICEST);
cogl_wrap_glFogf (GL_FOG_DENSITY, (GLfloat) density); glFogf (GL_FOG_DENSITY, (GLfloat) density);
cogl_wrap_glFogf (GL_FOG_START, (GLfloat) z_near); glFogf (GL_FOG_START, (GLfloat) z_near);
cogl_wrap_glFogf (GL_FOG_END, (GLfloat) z_far); glFogf (GL_FOG_END, (GLfloat) z_far);
} }