diff options
| author | Neil Roberts <neil@linux.intel.com> | 2011-07-06 21:51:00 +0100 |
|---|---|---|
| committer | Neil Roberts <neil@linux.intel.com> | 2011-07-08 15:35:46 +0100 |
| commit | 2b119b07da34f7aad987f032fb0987af9e7fbac6 (patch) | |
| tree | 79466967949021f50e714a5d96d824dec61f7dc5 | |
| parent | dae02a99a5c8c5f17188a0efb60eb8555e3e471f (diff) | |
| download | cogl-2b119b07da34f7aad987f032fb0987af9e7fbac6.tar.gz | |
Use all core GL functions through indirect pointers
cogl-ext-functions.h now contains definitions for all of the core GL
and GLES functions that we would normally link to directly. All of the
code has changed to access them through the cogl context pointer. The
GE macro now takes an extra parameter to specify the context because
the macro itself needs to make GL calls but various points in the Cogl
source use different names for the context variable.
31 files changed, 989 insertions, 828 deletions
diff --git a/cogl/cogl-attribute.c b/cogl/cogl-attribute.c index 0e5e1066..5970b79e 100644 --- a/cogl/cogl-attribute.c +++ b/cogl/cogl-attribute.c @@ -47,30 +47,7 @@ #include <string.h> #include <stdio.h> -#if defined (HAVE_COGL_GL) - -#define glGenBuffers ctx->glGenBuffers -#define glBindBuffer ctx->glBindBuffer -#define glBufferData ctx->glBufferData -#define glBufferSubData ctx->glBufferSubData -#define glGetBufferSubData ctx->glGetBufferSubData -#define glDeleteBuffers ctx->glDeleteBuffers -#define glMapBuffer ctx->glMapBuffer -#define glUnmapBuffer ctx->glUnmapBuffer -#define glClientActiveTexture ctx->glClientActiveTexture -#ifndef GL_ARRAY_BUFFER -#define GL_ARRAY_BUFFER GL_ARRAY_BUFFER_ARB -#endif - -#define glVertexAttribPointer ctx->glVertexAttribPointer -#define glEnableVertexAttribArray ctx->glEnableVertexAttribArray -#define glDisableVertexAttribArray ctx->glDisableVertexAttribArray -#define MAY_HAVE_PROGRAMABLE_GL - -#define glDrawRangeElements(mode, start, end, count, type, indices) \ - ctx->glDrawRangeElements (mode, start, end, count, type, indices) - -#else /* GLES 1/2 */ +#if ! defined (HAVE_COGL_GL) /* GLES doesn't have glDrawRangeElements, so we simply pretend it does * but that it makes no use of the start, end constraints: */ @@ -433,23 +410,23 @@ toggle_enabled_cb (int bit_num, void *user_data) const CoglBitmask *new_values = user_data; gboolean enabled = _cogl_bitmask_get (new_values, bit_num); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + #ifdef HAVE_COGL_GLES2 if (enabled) - GE( glEnableVertexAttribArray (bit_num) ); + GE( ctx, glEnableVertexAttribArray (bit_num) ); else - GE( glDisableVertexAttribArray (bit_num) ); + GE( ctx, glDisableVertexAttribArray (bit_num) ); #else /* HAVE_COGL_GLES2 */ - _COGL_GET_CONTEXT (ctx, NO_RETVAL); - - GE( glClientActiveTexture (GL_TEXTURE0 + bit_num) ); + GE( ctx, glClientActiveTexture (GL_TEXTURE0 + bit_num) ); if (enabled) - GE( glEnableClientState (GL_TEXTURE_COORD_ARRAY) ); + GE( ctx, glEnableClientState (GL_TEXTURE_COORD_ARRAY) ); else - GE( glDisableClientState (GL_TEXTURE_COORD_ARRAY) ); + GE( ctx, glDisableClientState (GL_TEXTURE_COORD_ARRAY) ); #endif /* HAVE_COGL_GLES2 */ } @@ -619,7 +596,8 @@ enable_gl_state (CoglDrawFlags flags, _cogl_pipeline_progend_glsl_get_color_attribute (source); if (attrib_location != -1) { - GE( glVertexAttribPointer (attrib_location, + GE( ctx, + glVertexAttribPointer (attrib_location, attribute->n_components, attribute->type, TRUE, /* normalize */ @@ -632,11 +610,11 @@ enable_gl_state (CoglDrawFlags flags, #else enable_flags |= COGL_ENABLE_COLOR_ARRAY; - /* GE (glEnableClientState (GL_COLOR_ARRAY)); */ - GE (glColorPointer (attribute->n_components, - attribute->type, - attribute->stride, - base + attribute->offset)); + /* GE (ctx, glEnableClientState (GL_COLOR_ARRAY)); */ + GE (ctx, glColorPointer (attribute->n_components, + attribute->type, + attribute->stride, + base + attribute->offset)); #endif @@ -648,7 +626,8 @@ enable_gl_state (CoglDrawFlags flags, _cogl_pipeline_progend_glsl_get_normal_attribute (source); if (attrib_location != -1) { - GE( glVertexAttribPointer (attrib_location, + GE( ctx, + glVertexAttribPointer (attrib_location, attribute->n_components, attribute->type, TRUE, /* normalize */ @@ -660,10 +639,10 @@ enable_gl_state (CoglDrawFlags flags, #else /* FIXME: go through cogl cache to enable normal array */ - GE (glEnableClientState (GL_NORMAL_ARRAY)); - GE (glNormalPointer (attribute->type, - attribute->stride, - base + attribute->offset)); + GE (ctx, glEnableClientState (GL_NORMAL_ARRAY)); + GE (ctx, glNormalPointer (attribute->type, + attribute->stride, + base + attribute->offset)); #endif @@ -675,7 +654,8 @@ enable_gl_state (CoglDrawFlags flags, (source, attribute->texture_unit); if (attrib_location != -1) { - GE( glVertexAttribPointer (attrib_location, + GE( ctx, + glVertexAttribPointer (attrib_location, attribute->n_components, attribute->type, FALSE, /* normalize */ @@ -685,12 +665,12 @@ enable_gl_state (CoglDrawFlags flags, } #else - GE (glClientActiveTexture (GL_TEXTURE0 + - attribute->texture_unit)); - GE (glTexCoordPointer (attribute->n_components, - attribute->type, - attribute->stride, - base + attribute->offset)); + GE (ctx, glClientActiveTexture (GL_TEXTURE0 + + attribute->texture_unit)); + GE (ctx, glTexCoordPointer (attribute->n_components, + attribute->type, + attribute->stride, + base + attribute->offset)); _cogl_bitmask_set (&ctx->temp_bitmask, attribute->texture_unit, TRUE); @@ -703,7 +683,8 @@ enable_gl_state (CoglDrawFlags flags, _cogl_pipeline_progend_glsl_get_position_attribute (source); if (attrib_location != -1) { - GE( glVertexAttribPointer (attrib_location, + GE( ctx, + glVertexAttribPointer (attrib_location, attribute->n_components, attribute->type, FALSE, /* normalize */ @@ -715,11 +696,11 @@ enable_gl_state (CoglDrawFlags flags, #else enable_flags |= COGL_ENABLE_VERTEX_ARRAY; - /* GE (glEnableClientState (GL_VERTEX_ARRAY)); */ - GE (glVertexPointer (attribute->n_components, - attribute->type, - attribute->stride, - base + attribute->offset)); + /* GE (ctx, glEnableClientState (GL_VERTEX_ARRAY)); */ + GE (ctx, glVertexPointer (attribute->n_components, + attribute->type, + attribute->stride, + base + attribute->offset)); #endif break; @@ -729,13 +710,13 @@ enable_gl_state (CoglDrawFlags flags, /* FIXME: go through cogl cache to enable generic array. */ /* FIXME: this is going to end up just using the builtins on GLES 2 */ - GE (glEnableVertexAttribArray (generic_index++)); - GE (glVertexAttribPointer (generic_index, - attribute->n_components, - attribute->type, - attribute->normalized, - attribute->stride, - base + attribute->offset)); + GE (ctx, glEnableVertexAttribArray (generic_index++)); + GE (ctx, glVertexAttribPointer (generic_index, + attribute->n_components, + attribute->type, + attribute->normalized, + attribute->stride, + base + attribute->offset)); #endif } break; @@ -788,12 +769,12 @@ disable_gl_state (CoglAttribute **attributes, switch (attribute->name_id) { case COGL_ATTRIBUTE_NAME_ID_COLOR_ARRAY: - /* GE (glDisableClientState (GL_COLOR_ARRAY)); */ + /* GE (ctx, glDisableClientState (GL_COLOR_ARRAY)); */ break; case COGL_ATTRIBUTE_NAME_ID_NORMAL_ARRAY: /* FIXME: go through cogl cache to enable normal array */ #ifndef HAVE_COGL_GLES2 - GE (glDisableClientState (GL_NORMAL_ARRAY)); + GE (ctx, glDisableClientState (GL_NORMAL_ARRAY)); #endif break; case COGL_ATTRIBUTE_NAME_ID_TEXTURE_COORD_ARRAY: @@ -804,12 +785,12 @@ disable_gl_state (CoglAttribute **attributes, required */ break; case COGL_ATTRIBUTE_NAME_ID_POSITION_ARRAY: - /* GE (glDisableClientState (GL_VERTEX_ARRAY)); */ + /* GE (ctx, glDisableClientState (GL_VERTEX_ARRAY)); */ break; case COGL_ATTRIBUTE_NAME_ID_CUSTOM_ARRAY: #ifdef MAY_HAVE_PROGRAMABLE_GL /* FIXME: go through cogl cache to enable generic array */ - GE (glDisableVertexAttribArray (generic_index++)); + GE (ctx, glDisableVertexAttribArray (generic_index++)); #endif break; default: @@ -1109,11 +1090,13 @@ _cogl_draw_attributes (CoglVerticesMode mode, ValidateLayerState state; CoglPipeline *source; + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + flush_state (flags, &state); source = enable_gl_state (flags, attributes, n_attributes, &state); - GE (glDrawArrays ((GLenum)mode, first_vertex, n_vertices)); + GE (ctx, glDrawArrays ((GLenum)mode, first_vertex, n_vertices)); /* FIXME: we shouldn't be disabling state after drawing we should * just disable the things not needed after enabling state. */ @@ -1223,10 +1206,10 @@ _cogl_draw_indexed_attributes (CoglVerticesMode mode, break; } - GE (glDrawElements ((GLenum)mode, - n_vertices, - indices_gl_type, - base + buffer_offset + index_size * first_vertex)); + GE (ctx, glDrawElements ((GLenum)mode, + n_vertices, + indices_gl_type, + base + buffer_offset + index_size * first_vertex)); _cogl_buffer_unbind (buffer); diff --git a/cogl/cogl-buffer.c b/cogl/cogl-buffer.c index eae7e0c3..207b1700 100644 --- a/cogl/cogl-buffer.c +++ b/cogl/cogl-buffer.c @@ -49,21 +49,6 @@ * GL/GLES compatibility defines for the buffer API: */ -#if defined (HAVE_COGL_GL) - -#define glGenBuffers ctx->glGenBuffers -#define glBindBuffer ctx->glBindBuffer -#define glBufferData ctx->glBufferData -#define glBufferSubData ctx->glBufferSubData -#define glGetBufferSubData ctx->glGetBufferSubData -#define glDeleteBuffers ctx->glDeleteBuffers - -#endif - -/* These two are always accessed through an extension, even on GLES */ -#define glMapBuffer ctx->glMapBuffer -#define glUnmapBuffer ctx->glUnmapBuffer - #ifndef GL_PIXEL_PACK_BUFFER #define GL_PIXEL_PACK_BUFFER 0x88EB #endif @@ -165,16 +150,21 @@ bo_map (CoglBuffer *buffer, * store is created. */ if (!buffer->store_created || (hints & COGL_BUFFER_MAP_HINT_DISCARD)) { - GE( glBufferData (gl_target, - buffer->size, - NULL, - _cogl_buffer_hints_to_gl_enum (buffer->usage_hint, - buffer->update_hint)) ); + GLenum gl_enum; + + gl_enum = _cogl_buffer_hints_to_gl_enum (buffer->usage_hint, + buffer->update_hint); + + + GE( ctx, glBufferData (gl_target, + buffer->size, + NULL, + gl_enum) ); buffer->store_created = TRUE; } - GE_RET( data, glMapBuffer (gl_target, - _cogl_buffer_access_to_gl_enum (access)) ); + GE_RET( data, ctx, glMapBuffer (gl_target, + _cogl_buffer_access_to_gl_enum (access)) ); if (data) buffer->flags |= COGL_BUFFER_FLAG_MAPPED; @@ -190,7 +180,8 @@ bo_unmap (CoglBuffer *buffer) _cogl_buffer_bind (buffer, buffer->last_target); - GE( glUnmapBuffer (convert_bind_target_to_gl_target (buffer->last_target)) ); + GE( ctx, glUnmapBuffer (convert_bind_target_to_gl_target + (buffer->last_target)) ); buffer->flags &= ~COGL_BUFFER_FLAG_MAPPED; _cogl_buffer_unbind (buffer); @@ -217,15 +208,16 @@ bo_set_data (CoglBuffer *buffer, * store is created. */ if (!buffer->store_created) { - GE( glBufferData (gl_target, - buffer->size, - NULL, - _cogl_buffer_hints_to_gl_enum (buffer->usage_hint, - buffer->update_hint)) ); + GLenum gl_enum = _cogl_buffer_hints_to_gl_enum (buffer->usage_hint, + buffer->update_hint); + GE( ctx, glBufferData (gl_target, + buffer->size, + NULL, + gl_enum) ); buffer->store_created = TRUE; } - GE( glBufferSubData (gl_target, offset, size, data) ); + GE( ctx, glBufferSubData (gl_target, offset, size, data) ); _cogl_buffer_unbind (buffer); @@ -294,7 +286,7 @@ _cogl_buffer_initialize (CoglBuffer *buffer, buffer->vtable.unmap = bo_unmap; buffer->vtable.set_data = bo_set_data; - GE( glGenBuffers (1, &buffer->gl_handle) ); + GE( ctx, glGenBuffers (1, &buffer->gl_handle) ); buffer->flags |= COGL_BUFFER_FLAG_BUFFER_OBJECT; } } @@ -308,7 +300,7 @@ _cogl_buffer_fini (CoglBuffer *buffer) g_return_if_fail (buffer->immutable_ref == 0); if (buffer->flags & COGL_BUFFER_FLAG_BUFFER_OBJECT) - GE( glDeleteBuffers (1, &buffer->gl_handle) ); + GE( ctx, glDeleteBuffers (1, &buffer->gl_handle) ); else g_free (buffer->data); } @@ -372,7 +364,7 @@ _cogl_buffer_bind (CoglBuffer *buffer, CoglBufferBindTarget target) if (buffer->flags & COGL_BUFFER_FLAG_BUFFER_OBJECT) { GLenum gl_target = convert_bind_target_to_gl_target (buffer->last_target); - GE( glBindBuffer (gl_target, buffer->gl_handle) ); + GE( ctx, glBindBuffer (gl_target, buffer->gl_handle) ); return NULL; } else @@ -392,7 +384,7 @@ _cogl_buffer_unbind (CoglBuffer *buffer) if (buffer->flags & COGL_BUFFER_FLAG_BUFFER_OBJECT) { GLenum gl_target = convert_bind_target_to_gl_target (buffer->last_target); - GE( glBindBuffer (gl_target, 0) ); + GE( ctx, glBindBuffer (gl_target, 0) ); } ctx->current_buffer[buffer->last_target] = NULL; diff --git a/cogl/cogl-clip-stack.c b/cogl/cogl-clip-stack.c index 5f21810e..c599cfd2 100644 --- a/cogl/cogl-clip-stack.c +++ b/cogl/cogl-clip-stack.c @@ -117,9 +117,9 @@ set_clip_plane (GLint plane_num, #if defined (HAVE_COGL_GLES2) g_assert_not_reached (); #elif defined (HAVE_COGL_GLES) - GE( glClipPlanef (plane_num, plane) ); + GE( ctx, glClipPlanef (plane_num, plane) ); #else - GE( glClipPlane (plane_num, plane) ); + GE( ctx, glClipPlane (plane_num, plane) ); #endif _cogl_matrix_stack_pop (modelview_stack); @@ -213,15 +213,15 @@ add_stencil_clip_rectangle (float x_1, if (first) { - GE( glEnable (GL_STENCIL_TEST) ); + GE( ctx, glEnable (GL_STENCIL_TEST) ); /* Initially disallow everything */ - GE( glClearStencil (0) ); - GE( glClear (GL_STENCIL_BUFFER_BIT) ); + GE( ctx, glClearStencil (0) ); + GE( ctx, glClear (GL_STENCIL_BUFFER_BIT) ); /* Punch out a hole to allow the rectangle */ - GE( glStencilFunc (GL_NEVER, 0x1, 0x1) ); - GE( glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE) ); + GE( ctx, glStencilFunc (GL_NEVER, 0x1, 0x1) ); + GE( ctx, glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE) ); _cogl_rectangle_immediate (x_1, y_1, x_2, y_2); } @@ -229,14 +229,14 @@ add_stencil_clip_rectangle (float x_1, { /* Add one to every pixel of the stencil buffer in the rectangle */ - GE( glStencilFunc (GL_NEVER, 0x1, 0x3) ); - GE( glStencilOp (GL_INCR, GL_INCR, GL_INCR) ); + GE( ctx, glStencilFunc (GL_NEVER, 0x1, 0x3) ); + GE( ctx, glStencilOp (GL_INCR, GL_INCR, GL_INCR) ); _cogl_rectangle_immediate (x_1, y_1, x_2, y_2); /* Subtract one from all pixels in the stencil buffer so that only pixels where both the original stencil buffer and the rectangle are set will be valid */ - GE( glStencilOp (GL_DECR, GL_DECR, GL_DECR) ); + GE( ctx, glStencilOp (GL_DECR, GL_DECR, GL_DECR) ); _cogl_matrix_stack_push (projection_stack); _cogl_matrix_stack_load_identity (projection_stack); @@ -256,8 +256,8 @@ add_stencil_clip_rectangle (float x_1, } /* Restore the stencil mode */ - GE( glStencilFunc (GL_EQUAL, 0x1, 0x1) ); - GE( glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP) ); + GE( ctx, glStencilFunc (GL_EQUAL, 0x1, 0x1) ); + GE( ctx, glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP) ); /* restore the original source pipeline */ cogl_pop_source (); @@ -266,25 +266,31 @@ add_stencil_clip_rectangle (float x_1, static void disable_stencil_buffer (void) { - GE( glDisable (GL_STENCIL_TEST) ); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + + GE( ctx, glDisable (GL_STENCIL_TEST) ); } static void enable_clip_planes (void) { - GE( glEnable (GL_CLIP_PLANE0) ); - GE( glEnable (GL_CLIP_PLANE1) ); - GE( glEnable (GL_CLIP_PLANE2) ); - GE( glEnable (GL_CLIP_PLANE3) ); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + + GE( ctx, glEnable (GL_CLIP_PLANE0) ); + GE( ctx, glEnable (GL_CLIP_PLANE1) ); + GE( ctx, glEnable (GL_CLIP_PLANE2) ); + GE( ctx, glEnable (GL_CLIP_PLANE3) ); } static void disable_clip_planes (void) { - GE( glDisable (GL_CLIP_PLANE3) ); - GE( glDisable (GL_CLIP_PLANE2) ); - GE( glDisable (GL_CLIP_PLANE1) ); - GE( glDisable (GL_CLIP_PLANE0) ); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + + GE( ctx, glDisable (GL_CLIP_PLANE3) ); + GE( ctx, glDisable (GL_CLIP_PLANE2) ); + GE( ctx, glDisable (GL_CLIP_PLANE1) ); + GE( ctx, glDisable (GL_CLIP_PLANE0) ); } static gpointer @@ -612,7 +618,7 @@ _cogl_clip_stack_flush (CoglClipStack *stack) COGL_NOTE (CLIPPING, "Flushed empty clip stack"); ctx->current_clip_stack_uses_stencil = FALSE; - GE (glDisable (GL_SCISSOR_TEST)); + GE (ctx, glDisable (GL_SCISSOR_TEST)); return; } @@ -654,10 +660,10 @@ _cogl_clip_stack_flush (CoglClipStack *stack) scissor_x0, scissor_y0, scissor_x1, scissor_y1); - GE (glEnable (GL_SCISSOR_TEST)); - GE (glScissor (scissor_x0, scissor_y_start, - scissor_x1 - scissor_x0, - scissor_y1 - scissor_y0)); + GE (ctx, glEnable (GL_SCISSOR_TEST)); + GE (ctx, glScissor (scissor_x0, scissor_y_start, + scissor_x1 - scissor_x0, + scissor_y1 - scissor_y0)); /* Add all of the entries. This will end up adding them in the reverse order that they were specified but as all of the clips diff --git a/cogl/cogl-context.c b/cogl/cogl-context.c index 884ec4a7..13c9142b 100644 --- a/cogl/cogl-context.c +++ b/cogl/cogl-context.c @@ -47,7 +47,6 @@ #ifdef HAVE_COGL_GL #include "cogl-pipeline-fragend-arbfp-private.h" -#define glActiveTexture _context->glActiveTexture #endif /* This isn't defined in the GLES headers */ @@ -199,7 +198,7 @@ cogl_context_new (CoglDisplay *display, /* See cogl-pipeline.c for more details about why we leave texture unit 1 * active by default... */ context->active_texture_unit = 1; - GE (glActiveTexture (GL_TEXTURE1)); + GE (context, glActiveTexture (GL_TEXTURE1)); context->legacy_fog_state.enabled = FALSE; @@ -307,7 +306,7 @@ cogl_context_new (CoglDisplay *display, * makes things a bit simpler for us. Under GLES2 the alpha test is * implemented in the fragment shader so there is no enable for it */ - GE (glEnable (GL_ALPHA_TEST)); + GE (context, glEnable (GL_ALPHA_TEST)); #endif #ifdef HAVE_COGL_GLES2 @@ -355,7 +354,7 @@ cogl_context_new (CoglDisplay *display, sprites are handled using a builtin varying in the shader. */ #ifndef HAVE_COGL_GLES2 if (cogl_features_available (COGL_FEATURE_POINT_SPRITE)) - GE (glEnable (GL_POINT_SPRITE)); + GE (context, glEnable (GL_POINT_SPRITE)); #endif return _cogl_context_object_new (context); diff --git a/cogl/cogl-ext-functions.h b/cogl/cogl-ext-functions.h index e73e4dce..2a85687d 100644 --- a/cogl/cogl-ext-functions.h +++ b/cogl/cogl-ext-functions.h @@ -48,6 +48,219 @@ * @extension_names: A list of extension names to try. If any of these * extensions match then it will be used. */ + +/* These are the core GL functions which we assume will always be + available */ +COGL_EXT_BEGIN (core, + 0, 0, + COGL_EXT_IN_GLES | COGL_EXT_IN_GLES2, + "\0", + "\0") +COGL_EXT_FUNCTION (void, glBindTexture, + (GLenum target, GLuint texture)) +COGL_EXT_FUNCTION (void, glBlendFunc, + (GLenum sfactor, GLenum dfactor)) +COGL_EXT_FUNCTION (void, glClear, + (GLbitfield mask)) +COGL_EXT_FUNCTION (void, glClearColor, + (GLclampf red, + GLclampf green, + GLclampf blue, + GLclampf alpha)) +COGL_EXT_FUNCTION (void, glClearStencil, + (GLint s)) +COGL_EXT_FUNCTION (void, glColorMask, + (GLboolean red, + GLboolean green, + GLboolean blue, + GLboolean alpha)) +COGL_EXT_FUNCTION (void, glCopyTexSubImage2D, + (GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint x, + GLint y, + GLsizei width, + GLsizei height)) +COGL_EXT_FUNCTION (void, glDeleteTextures, + (GLsizei n, const GLuint* textures)) +COGL_EXT_FUNCTION (void, glDepthFunc, + (GLenum func)) +COGL_EXT_FUNCTION (void, glDepthMask, + (GLboolean flag)) +COGL_EXT_FUNCTION (void, glDisable, + (GLenum cap)) +COGL_EXT_FUNCTION (void, glDrawArrays, + (GLenum mode, GLint first, GLsizei count)) +COGL_EXT_FUNCTION (void, glDrawElements, + (GLenum mode, + GLsizei count, + GLenum type, + const GLvoid* indices)) +COGL_EXT_FUNCTION (void, glEnable, + (GLenum cap)) +COGL_EXT_FUNCTION (void, glFinish, + (void)) +COGL_EXT_FUNCTION (void, glFlush, + (void)) +COGL_EXT_FUNCTION (void, glFrontFace, + (GLenum mode)) +COGL_EXT_FUNCTION (void, glGenTextures, + (GLsizei n, GLuint* textures)) +COGL_EXT_FUNCTION (GLenum, glGetError, + (void)) +COGL_EXT_FUNCTION (void, glGetIntegerv, + (GLenum pname, GLint* params)) +COGL_EXT_FUNCTION (const GLubyte*, glGetString, + (GLenum name)) +COGL_EXT_FUNCTION (void, glHint, + (GLenum target, GLenum mode)) +COGL_EXT_FUNCTION (GLboolean, glIsTexture, + (GLuint texture)) +COGL_EXT_FUNCTION (void, glPixelStorei, + (GLenum pname, GLint param)) +COGL_EXT_FUNCTION (void, glReadPixels, + (GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLvoid* pixels)) +COGL_EXT_FUNCTION (void, glScissor, + (GLint x, GLint y, GLsizei width, GLsizei height)) +COGL_EXT_FUNCTION (void, glStencilFunc, + (GLenum func, GLint ref, GLuint mask)) +COGL_EXT_FUNCTION (void, glStencilMask, + (GLuint mask)) +COGL_EXT_FUNCTION (void, glStencilOp, + (GLenum fail, GLenum zfail, GLenum zpass)) +COGL_EXT_FUNCTION (void, glTexImage2D, + (GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLenum format, + GLenum type, + const GLvoid* pixels)) +COGL_EXT_FUNCTION (void, glTexParameterfv, + (GLenum target, GLenum pname, const GLfloat* params)) +COGL_EXT_FUNCTION (void, glTexParameteri, + (GLenum target, GLenum pname, GLint param)) +COGL_EXT_FUNCTION (void, glTexSubImage2D, + (GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + const GLvoid* pixels)) +COGL_EXT_FUNCTION (void, glViewport, + (GLint x, GLint y, GLsizei width, GLsizei height)) +COGL_EXT_END () + +/* These are the core GL functions which are available when the API + supports fixed-function (ie, GL and GLES1.1) */ +COGL_EXT_BEGIN (fixed_function_core, + 0, 0, + COGL_EXT_IN_GLES, + "\0", + "\0") +COGL_EXT_FUNCTION (void, glAlphaFunc, + (GLenum func, GLclampf ref)) +COGL_EXT_FUNCTION (void, glFogf, + (GLenum pname, GLfloat param)) +COGL_EXT_FUNCTION (void, glFogfv, + (GLenum pname, const GLfloat *params)) +COGL_EXT_FUNCTION (void, glLoadMatrixf, + (const GLfloat *m)) +COGL_EXT_FUNCTION (void, glMaterialfv, + (GLenum face, GLenum pname, const GLfloat *params)) +COGL_EXT_FUNCTION (void, glPointSize, + (GLfloat size)) +COGL_EXT_FUNCTION (void, glTexEnvfv, + (GLenum target, GLenum pname, const GLfloat *params)) +COGL_EXT_FUNCTION (void, glColor4ub, + (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)) +COGL_EXT_FUNCTION (void, glColorPointer, + (GLint size, + GLenum type, + GLsizei stride, + const GLvoid *pointer)) +COGL_EXT_FUNCTION (void, glDisableClientState, + (GLenum array)) +COGL_EXT_FUNCTION (void, glEnableClientState, + (GLenum array)) +COGL_EXT_FUNCTION (void, glLoadIdentity, + (void)) +COGL_EXT_FUNCTION (void, glMatrixMode, + (GLenum mode)) +COGL_EXT_FUNCTION (void, glNormalPointer, + (GLenum type, GLsizei stride, const GLvoid *pointer)) +COGL_EXT_FUNCTION (void, glTexCoordPointer, + (GLint size, + GLenum type, + GLsizei stride, + const GLvoid *pointer)) +COGL_EXT_FUNCTION (void, glTexEnvi, + (GLenum target, + GLenum pname, + GLint param)) +COGL_EXT_FUNCTION (void, glVertexPointer, + (GLint size, + GLenum type, + GLsizei stride, + const GLvoid *pointer)) +COGL_EXT_END () + +/* These are the core GL functions which are only available in big + GL */ +COGL_EXT_BEGIN (only_in_big_gl, + 0, 0, + 0, /* not in GLES */ + "\0", + "\0") +COGL_EXT_FUNCTION (void, glGetTexLevelParameteriv, + (GLenum target, GLint level, + GLenum pname, GLint *params)) +COGL_EXT_FUNCTION (void, glGetTexImage, + (GLenum target, GLint level, + GLenum format, GLenum type, + GLvoid *pixels)) +COGL_EXT_FUNCTION (void, glClipPlane, + (GLenum plane, const double *equation)) +COGL_EXT_FUNCTION (void, glDepthRange, + (double near_val, double far_val)) +COGL_EXT_FUNCTION (void, glDrawBuffer, + (GLenum mode)) +COGL_EXT_END () + +/* These functions are only available in GLES and are used as + replacements for some GL equivalents that only accept double + arguments */ +COGL_EXT_BEGIN (only_in_gles1, + 255, 255, + COGL_EXT_IN_GLES, + "\0", + "\0") +COGL_EXT_FUNCTION (void, glClipPlanef, + (GLenum plane, const GLfloat *equation)) +COGL_EXT_END () +COGL_EXT_BEGIN (only_in_both_gles, + 255, 255, + COGL_EXT_IN_GLES | + COGL_EXT_IN_GLES2, + "\0", + "\0") +COGL_EXT_FUNCTION (void, glDepthRangef, + (GLfloat near_val, GLfloat far_val)) +COGL_EXT_END () + COGL_EXT_BEGIN (offscreen, 255, 255, COGL_EXT_IN_GLES2, @@ -303,6 +516,12 @@ COGL_EXT_FUNCTION (void, glGetProgramInfoLog, GLsizei *length, GLchar *infoLog)) +COGL_EXT_FUNCTION (void, glVertexAttrib4f, + (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) + +COGL_EXT_FUNCTION (GLint, glGetAttribLocation, + (GLuint program, const GLchar *name)) + COGL_EXT_END () COGL_EXT_BEGIN (vbos, 1, 5, diff --git a/cogl/cogl-framebuffer.c b/cogl/cogl-framebuffer.c index e96f1f6d..d5b4ad43 100644 --- a/cogl/cogl-framebuffer.c +++ b/cogl/cogl-framebuffer.c @@ -40,25 +40,6 @@ #include "cogl-journal-private.h" #include "cogl-winsys-private.h" -#ifndef HAVE_COGL_GLES2 - -#define glGenRenderbuffers ctx->glGenRenderbuffers -#define glDeleteRenderbuffers ctx->glDeleteRenderbuffers -#define glBindRenderbuffer ctx->glBindRenderbuffer -#define glRenderbufferStorage ctx->glRenderbufferStorage -#define glGenFramebuffers ctx->glGenFramebuffers -#define glBindFramebuffer ctx->glBindFramebuffer -#define glFramebufferTexture2D ctx->glFramebufferTexture2D -#define glFramebufferRenderbuffer ctx->glFramebufferRenderbuffer -#define glCheckFramebufferStatus ctx->glCheckFramebufferStatus -#define glDeleteFramebuffers ctx->glDeleteFramebuffers -#define glGetFramebufferAttachmentParameteriv \ - ctx->glGetFramebufferAttachmentParameteriv - -#endif - -#define glBlitFramebuffer ctx->glBlitFramebuffer - #ifndef GL_FRAMEBUFFER #define GL_FRAMEBUFFER 0x8D40 #endif @@ -252,9 +233,11 @@ _cogl_clear4f (unsigned long buffers, { GLbitfield gl_buffers = 0; + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + if (buffers & COGL_BUFFER_BIT_COLOR) { - GE( glClearColor (red, green, blue, alpha) ); + GE( ctx, glClearColor (red, green, blue, alpha) ); gl_buffers |= GL_COLOR_BUFFER_BIT; } @@ -277,7 +260,7 @@ _cogl_clear4f (unsigned long buffers, return; } - GE (glClear (gl_buffers)); + GE (ctx, glClear (gl_buffers)); } void @@ -626,9 +609,7 @@ _cogl_framebuffer_flush_dependency_journals (CoglFramebuffer *framebuffer) static inline void _cogl_framebuffer_init_bits (CoglFramebuffer *framebuffer) { -#ifdef HAVE_COGL_GL CoglContext *ctx = framebuffer->context; -#endif if (G_LIKELY (!framebuffer->dirty_bitmasks)) return; @@ -642,36 +623,39 @@ _cogl_framebuffer_init_bits (CoglFramebuffer *framebuffer) attachment = GL_COLOR_ATTACHMENT0; pname = GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE; - GE( glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, - attachment, - pname, - &framebuffer->red_bits) ); + GE( ctx, glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, + attachment, + pname, + &framebuffer->red_bits) ); pname = GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE; - GE( glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, - attachment, - pname, - &framebuffer->green_bits) ); + GE( ctx, glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, + attachment, + pname, + &framebuffer->green_bits) + ); pname = GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE; - GE( glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, - attachment, - pname, - &framebuffer->blue_bits) ); + GE( ctx, glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, + attachment, + pname, + &framebuffer->blue_bits) + ); pname = GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE; - GE( glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, - attachment, - pname, - &framebuffer->alpha_bits) ); + GE( ctx, glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, + attachment, + pname, + &framebuffer->alpha_bits) + ); } else #endif /* HAVE_COGL_GL */ { - GE( glGetIntegerv (GL_RED_BITS, &framebuffer->red_bits) ); - GE( glGetIntegerv (GL_GREEN_BITS, &framebuffer->green_bits) ); - GE( glGetIntegerv (GL_BLUE_BITS, &framebuffer->blue_bits) ); - GE( glGetIntegerv (GL_ALPHA_BITS, &framebuffer->alpha_bits) ); + GE( ctx, glGetIntegerv (GL_RED_BITS, &framebuffer->red_bits) ); + GE( ctx, glGetIntegerv (GL_GREEN_BITS, &framebuffer->green_bits) ); + GE( ctx, glGetIntegerv (GL_BLUE_BITS, &framebuffer->blue_bits) ); + GE( ctx, glGetIntegerv (GL_ALPHA_BITS, &framebuffer->alpha_bits) ); } @@ -729,28 +713,30 @@ try_creating_fbo (CoglOffscreen *offscreen, ctx->dirty_bound_framebuffer = 1; /* Generate framebuffer */ - glGenFramebuffers (1, &fbo_gl_handle); - GE (glBindFramebuffer (GL_FRAMEBUFFER, fbo_gl_handle)); + ctx->glGenFramebuffers (1, &fbo_gl_handle); + GE (ctx, glBindFramebuffer (GL_FRAMEBUFFER, fbo_gl_handle)); offscreen->fbo_handle = fbo_gl_handle; - GE (glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, - tex_gl_target, tex_gl_handle, data->level)); + GE (ctx, glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, + tex_gl_target, tex_gl_handle, data->level)); if (flags & _TRY_DEPTH_STENCIL) { /* Create a renderbuffer for depth and stenciling */ - GE (glGenRenderbuffers (1, &gl_depth_stencil_handle)); - GE (glBindRenderbuffer (GL_RENDERBUFFER, gl_depth_stencil_handle)); - GE (glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH_STENCIL, - data->level_width, - data->level_height)); - GE (glBindRenderbuffer (GL_RENDERBUFFER, 0)); - GE (glFramebufferRenderbuffer (GL_FRAMEBUFFER, - GL_STENCIL_ATTACHMENT, - GL_RENDERBUFFER, gl_depth_stencil_handle)); - GE (glFramebufferRenderbuffer (GL_FRAMEBUFFER, - GL_DEPTH_ATTACHMENT, - GL_RENDERBUFFER, gl_depth_stencil_handle)); + GE (ctx, glGenRenderbuffers (1, &gl_depth_stencil_handle)); + GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, gl_depth_stencil_handle)); + GE (ctx, glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH_STENCIL, + data->level_width, + data->level_height)); + GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, 0)); + GE (ctx, glFramebufferRenderbuffer (GL_FRAMEBUFFER, + GL_STENCIL_ATTACHMENT, + GL_RENDERBUFFER, + gl_depth_stencil_handle)); + GE (ctx, glFramebufferRenderbuffer (GL_FRAMEBUFFER, + GL_DEPTH_ATTACHMENT, + GL_RENDERBUFFER, + gl_depth_stencil_handle)); offscreen->renderbuffers = g_slist_prepend (offscreen->renderbuffers, GUINT_TO_POINTER (gl_depth_stencil_handle)); @@ -758,15 +744,15 @@ try_creating_fbo (CoglOffscreen *offscreen, if (flags & _TRY_DEPTH) { - GE (glGenRenderbuffers (1, &gl_depth_handle)); - GE (glBindRenderbuffer (GL_RENDERBUFFER, gl_depth_handle)); + GE (ctx, glGenRenderbuffers (1, &gl_depth_handle)); + GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, gl_depth_handle)); /* For now we just ask for GL_DEPTH_COMPONENT16 since this is all that's * available under GLES */ - GE (glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, + GE (ctx, glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, data->level_width, data->level_height)); - GE (glBindRenderbuffer (GL_RENDERBUFFER, 0)); - GE (glFramebufferRenderbuffer (GL_FRAMEBUFFER, + GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, 0)); + GE (ctx, glFramebufferRenderbuffer (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, gl_depth_handle)); offscreen->renderbuffers = @@ -776,13 +762,13 @@ try_creating_fbo (CoglOffscreen *offscreen, if (flags & _TRY_STENCIL) { - GE (glGenRenderbuffers (1, &gl_stencil_handle)); - GE (glBindRenderbuffer (GL_RENDERBUFFER, gl_stencil_handle)); - GE (glRenderbufferStorage (GL_RENDERBUFFER, GL_STENCIL_INDEX8, + GE (ctx, glGenRenderbuffers (1, &gl_stencil_handle)); + GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, gl_stencil_handle)); + GE (ctx, glRenderbufferStorage (GL_RENDERBUFFER, GL_STENCIL_INDEX8, data->level_width, data->level_height)); - GE (glBindRenderbuffer (GL_RENDERBUFFER, 0)); - GE (glFramebufferRenderbuffer (GL_FRAMEBUFFER, + GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, 0)); + GE (ctx, glFramebufferRenderbuffer (GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, gl_stencil_handle)); offscreen->renderbuffers = @@ -791,18 +777,18 @@ try_creating_fbo (CoglOffscreen *offscreen, } /* Make sure it's complete */ - status = glCheckFramebufferStatus (GL_FRAMEBUFFER); + status = ctx->glCheckFramebufferStatus (GL_FRAMEBUFFER); if (status != GL_FRAMEBUFFER_COMPLETE) { GSList *l; - GE (glDeleteFramebuffers (1, &fbo_gl_handle)); + GE (ctx, glDeleteFramebuffers (1, &fbo_gl_handle)); for (l = offscreen->renderbuffers; l; l = l->next) { GLuint renderbuffer = GPOINTER_TO_UINT (l->data); - GE (glDeleteRenderbuffers (1, &renderbuffer)); + GE (ctx, glDeleteRenderbuffers (1, &renderbuffer)); } g_slist_free (offscreen->renderbuffers); @@ -941,9 +927,7 @@ static void _cogl_offscreen_free (CoglOffscreen *offscreen) { CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (offscreen); -#ifndef HAVE_COGL_GLES2 CoglContext *ctx = framebuffer->context; -#endif GSList *l; /* Chain up to parent */ @@ -952,11 +936,11 @@ _cogl_offscreen_free (CoglOffscreen *offscreen) for (l = offscreen->renderbuffers; l; l = l->next) { GLuint renderbuffer = GPOINTER_TO_UINT (l->data); - GE (glDeleteRenderbuffers (1, &renderbuffer)); + GE (ctx, glDeleteRenderbuffers (1, &renderbuffer)); } g_slist_free (offscreen->renderbuffers); - GE (glDeleteFramebuffers (1, &offscreen->fbo_handle)); + GE (ctx, glDeleteFramebuffers (1, &offscreen->fbo_handle)); if (offscreen->texture != COGL_INVALID_HANDLE) cogl_handle_unref (offscreen->texture); @@ -1368,7 +1352,7 @@ bind_gl_framebuffer (CoglContext *ctx, CoglFramebuffer *framebuffer) { if (framebuffer->type == COGL_FRAMEBUFFER_TYPE_OFFSCREEN) - GE (glBindFramebuffer (target, + GE (ctx, glBindFramebuffer (target, COGL_OFFSCREEN (framebuffer)->fbo_handle)); else { @@ -1377,7 +1361,7 @@ bind_gl_framebuffer (CoglContext *ctx, winsys->onscreen_bind (COGL_ONSCREEN (framebuffer)); /* glBindFramebuffer is an an extension with OpenGL ES 1.1 */ if (cogl_features_available (COGL_FEATURE_OFFSCREEN)) - GE (glBindFramebuffer (target, 0)); + GE (ctx, glBindFramebuffer (target, 0)); } } @@ -1435,7 +1419,7 @@ _cogl_framebuffer_flush_state (CoglFramebuffer *draw_buffer, draw_buffer->viewport_width, draw_buffer->viewport_height); - GE (glViewport (draw_buffer->viewport_x, + GE (ctx, glViewport (draw_buffer->viewport_x, gl_viewport_y, draw_buffer->viewport_width, draw_buffer->viewport_height)); @@ -1596,7 +1580,7 @@ _cogl_blit_framebuffer (unsigned int src_x, the scissor */ _cogl_clip_stack_flush (NULL); - glBlitFramebuffer (src_x, src_y, + ctx->glBlitFramebuffer (src_x, src_y, src_x + width, src_y + height, dst_x, dst_y, dst_x + width, dst_y + height, diff --git a/cogl/cogl-internal.h b/cogl/cogl-internal.h index b695abdf..71e5766d 100644 --- a/cogl/cogl-internal.h +++ b/cogl/cogl-internal.h @@ -66,10 +66,10 @@ typedef struct _CoglBoxedValue const char * cogl_gl_error_to_string (GLenum error_code); -#define GE(x) G_STMT_START { \ +#define GE(ctx, x) G_STMT_START { \ GLenum __err; \ - (x); \ - while ((__err = glGetError ()) != GL_NO_ERROR) \ + (ctx)->x; \ + while ((__err = (ctx)->glGetError ()) != GL_NO_ERROR) \ { \ g_warning ("%s: GL error (%d): %s\n", \ G_STRLOC, \ @@ -77,10 +77,10 @@ cogl_gl_error_to_string (GLenum error_code); cogl_gl_error_to_string (__err)); \ } } G_STMT_END -#define GE_RET(ret, x) G_STMT_START { \ +#define GE_RET(ret, ctx, x) G_STMT_START { \ GLenum __err; \ - ret = (x); \ - while ((__err = glGetError ()) != GL_NO_ERROR) \ + ret = (ctx)->x; \ + while ((__err = (ctx)->glGetError ()) != GL_NO_ERROR) \ { \ g_warning ("%s: GL error (%d): %s\n", \ G_STRLOC, \ @@ -90,8 +90,8 @@ cogl_gl_error_to_string (GLenum error_code); #else /* !COGL_GL_DEBUG */ -#define GE(x) (x) -#define GE_RET(ret, x) (ret = (x)) +#define GE(ctx, x) ((ctx)->x) +#define GE_RET(ret, ctx, x) (ret = ((ctx)->x)) #endif /* COGL_GL_DEBUG */ diff --git a/cogl/cogl-matrix-stack.c b/cogl/cogl-matrix-stack.c index d844c7b9..d761b536 100644 --- a/cogl/cogl-matrix-stack.c +++ b/cogl/cogl-matrix-stack.c @@ -402,15 +402,17 @@ flush_to_fixed_api_gl (gboolean is_identity, { CoglMatrixStack *stack = user_data; + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + if (is_identity) { if (!stack->flushed_identity) - GE (glLoadIdentity ()); + GE (ctx, glLoadIdentity ()); stack->flushed_identity = TRUE; } else { - GE (glLoadMatrixf (cogl_matrix_get_array (matrix)) ); + GE (ctx, glLoadMatrixf (cogl_matrix_get_array (matrix)) ); stack->flushed_identity = FALSE; } } @@ -516,7 +518,7 @@ _cogl_matrix_stack_flush_to_gl (CoglMatrixStack *stack, break; } - GE (glMatrixMode (gl_mode)); + GE (ctx, glMatrixMode (gl_mode)); ctx->flushed_matrix_mode = mode; } diff --git a/cogl/cogl-pipeline-fragend-arbfp.c b/cogl/cogl-pipeline-fragend-arbfp.c index 3f4c4a39..ef073577 100644 --- a/cogl/cogl-pipeline-fragend-arbfp.c +++ b/cogl/cogl-pipeline-fragend-arbfp.c @@ -50,19 +50,6 @@ #include <glib/gprintf.h> #include <string.h> -/* - * GL/GLES compatability defines for pipeline thingies: - */ - -#ifdef HAVE_COGL_GL -#define glProgramString ctx->glProgramString -#define glBindProgram ctx->glBindProgram -#define glDeletePrograms ctx->glDeletePrograms -#define glGenPrograms ctx->glGenPrograms -#define glProgramLocalParameter4fv ctx->glProgramLocalParameter4fv -#define glUseProgram ctx->glUseProgram -#endif - /* This might not be defined on GLES */ #ifndef GL_TEXTURE_3D #define GL_TEXTURE_3D 0x806F @@ -135,7 +122,7 @@ arbfp_program_state_unref (ArbfpProgramState *state) { if (state->gl_program) { - GE (glDeletePrograms (1, &state->gl_program)); + GE (ctx, glDeletePrograms (1, &state->gl_program)); state->gl_program = 0; } @@ -866,9 +853,9 @@ update_constants_cb (CoglPipeline *pipeline, _cogl_pipeline_get_layer_combine_constant (pipeline, layer_index, constant); - GE (glProgramLocalParameter4fv (GL_FRAGMENT_PROGRAM_ARB, - unit_state->constant_id, - constant)); + GE (ctx, glProgramLocalParameter4fv (GL_FRAGMENT_PROGRAM_ARB, + unit_state->constant_id, + constant)); unit_state->dirty_combine_constant = FALSE; } return TRUE; @@ -901,22 +888,22 @@ _cogl_pipeline_fragend_arbfp_end (CoglPipeline *pipeline, if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_SHOW_SOURCE))) g_message ("pipeline program:\n%s", arbfp_program_state->source->str); - GE (glGenPrograms (1, &arbfp_program_state->gl_program)); + GE (ctx, glGenPrograms (1, &arbfp_program_state->gl_program)); - GE (glBindProgram (GL_FRAGMENT_PROGRAM_ARB, + GE (ctx, glBindProgram (GL_FRAGMENT_PROGRAM_ARB, arbfp_program_state->gl_program)); - while ((gl_error = glGetError ()) != GL_NO_ERROR) + while ((gl_error = ctx->glGetError ()) != GL_NO_ERROR) ; - glProgramString (GL_FRAGMENT_PROGRAM_ARB, - GL_PROGRAM_FORMAT_ASCII_ARB, - arbfp_program_state->source->len, - arbfp_program_state->source->str); - if (glGetError () != GL_NO_ERROR) + ctx->glProgramString (GL_FRAGMENT_PROGRAM_ARB, + GL_PROGRAM_FORMAT_ASCII_ARB, + arbfp_program_state->source->len, + arbfp_program_state->source->str); + if (ctx->glGetError () != GL_NO_ERROR) { g_warning ("\n%s\n%s", arbfp_program_state->source->str, - glGetString (GL_PROGRAM_ERROR_STRING_ARB)); + ctx->glGetString (GL_PROGRAM_ERROR_STRING_ARB)); } arbfp_program_state->source = NULL; @@ -979,7 +966,7 @@ _cogl_pipeline_fragend_arbfp_end (CoglPipeline *pipeline, else gl_program = arbfp_program_state->gl_program; - GE (glBindProgram (GL_FRAGMENT_PROGRAM_ARB, gl_program)); + GE (ctx, glBindProgram (GL_FRAGMENT_PROGRAM_ARB, gl_program)); _cogl_use_fragment_program (0, COGL_PIPELINE_PROGRAM_TYPE_ARBFP); if (arbfp_program_state->user_program == COGL_INVALID_HANDLE) diff --git a/cogl/cogl-pipeline-fragend-fixed.c b/cogl/cogl-pipeline-fragend-fixed.c index ee80b5e9..ebd2ec87 100644 --- a/cogl/cogl-pipeline-fragend-fixed.c +++ b/cogl/cogl-pipeline-fragend-fixed.c @@ -62,7 +62,7 @@ _cogl_disable_texture_unit (int unit_index) if (unit->enabled_gl_target) { _cogl_set_active_texture_unit (unit_index); - GE (glDisable (unit->enabled_gl_target)); + GE (ctx, glDisable (unit->enabled_gl_target)); unit->enabled_gl_target = 0; } } @@ -77,8 +77,8 @@ get_max_texture_units (void) if (ctx->max_texture_units == -1) { ctx->max_texture_units = 1; - GE (glGetIntegerv (GL_MAX_TEXTURE_UNITS, - &ctx->max_texture_units)); + GE (ctx, glGetIntegerv (GL_MAX_TEXTURE_UNITS, + &ctx->max_texture_units)); } return ctx->max_texture_units; @@ -162,12 +162,12 @@ _cogl_pipeline_fragend_fixed_add_layer (CoglPipeline *pipeline, { /* Disable the previous target if it's still enabled */ if (unit->enabled_gl_target) - GE (glDisable (unit->enabled_gl_target)); + GE (ctx, glDisable (unit->enabled_gl_target)); /* Enable the new target */ if (!G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_TEXTURING))) { - GE (glEnable (gl_target)); + GE (ctx, glEnable (gl_target)); unit->enabled_gl_target = gl_target; } } @@ -183,7 +183,7 @@ _cogl_pipeline_fragend_fixed_add_layer (CoglPipeline *pipeline, unit->enabled_gl_target == 0) { _cogl_set_active_texture_unit (unit_index); - GE (glEnable (unit->gl_target)); + GE (ctx, glEnable (unit->gl_target)); unit->enabled_gl_target = unit->gl_target; } } @@ -195,15 +195,15 @@ _cogl_pipeline_fragend_fixed_add_layer (CoglPipeline *pipeline, COGL_PIPELINE_LAYER_STATE_COMBINE); CoglPipelineLayerBigState *big_state = authority->big_state; - GE (glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE)); + GE (ctx, glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE)); /* Set the combiner functions... */ - GE (glTexEnvi (GL_TEXTURE_ENV, - GL_COMBINE_RGB, - big_state->texture_combine_rgb_func)); - GE (glTexEnvi (GL_TEXTURE_ENV, - GL_COMBINE_ALPHA, - big_state->texture_combine_alpha_func)); + GE (ctx, glTexEnvi (GL_TEXTURE_ENV, + GL_COMBINE_RGB, + big_state->texture_combine_rgb_func)); + GE (ctx, glTexEnvi (GL_TEXTURE_ENV, + GL_COMBINE_ALPHA, + big_state->texture_combine_alpha_func)); /* * Setup the function arguments... @@ -213,46 +213,46 @@ _cogl_pipeline_fragend_fixed_add_layer (CoglPipeline *pipeline, n_rgb_func_args = _cogl_get_n_args_for_combine_func (big_state->texture_combine_rgb_func); - GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_RGB, - big_state->texture_combine_rgb_src[0])); - GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, - big_state->texture_combine_rgb_op[0])); + GE (ctx, glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_RGB, + big_state->texture_combine_rgb_src[0])); + GE (ctx, glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, + big_state->texture_combine_rgb_op[0])); if (n_rgb_func_args > 1) { - GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC1_RGB, - big_state->texture_combine_rgb_src[1])); - GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_RGB, - big_state->texture_combine_rgb_op[1])); + GE (ctx, glTexEnvi (GL_TEXTURE_ENV, GL_SRC1_RGB, + big_state->texture_combine_rgb_src[1])); + GE (ctx, glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_RGB, + big_state->texture_combine_rgb_op[1])); } if (n_rgb_func_args > 2) { - GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC2_RGB, - big_state->texture_combine_rgb_src[2])); - GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_RGB, - big_state->texture_combine_rgb_op[2])); + GE (ctx, glTexEnvi (GL_TEXTURE_ENV, GL_SRC2_RGB, + big_state->texture_combine_rgb_src[2])); + GE (ctx, glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_RGB, + big_state->texture_combine_rgb_op[2])); } /* For the Alpha component */ n_alpha_func_args = _cogl_get_n_args_for_combine_func (big_state->texture_combine_alpha_func); - GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_ALPHA, - big_state->texture_combine_alpha_src[0])); - GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, - big_state->texture_combine_alpha_op[0])); + GE (ctx, glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_ALPHA, + big_state->texture_combine_alpha_src[0])); + GE (ctx, glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, + big_state->texture_combine_alpha_op[0])); if (n_alpha_func_args > 1) { - GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC1_ALPHA, - big_state->texture_combine_alpha_src[1])); - GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, - big_state->texture_combine_alpha_op[1])); + GE (ctx, glTexEnvi (GL_TEXTURE_ENV, GL_SRC1_ALPHA, + big_state->texture_combine_alpha_src[1])); + GE (ctx, glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, + big_state->texture_combine_alpha_op[1])); } if (n_alpha_func_args > 2) { - GE (glTexEnvi (GL_TEXTURE_ENV, GL_SRC2_ALPHA, - big_state->texture_combine_alpha_src[2])); - GE (glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, - big_state->texture_combine_alpha_op[2])); + GE (ctx, glTexEnvi (GL_TEXTURE_ENV, GL_SRC2_ALPHA, + big_state->texture_combine_alpha_src[2])); + GE (ctx, glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, + big_state->texture_combine_alpha_op[2])); } } @@ -263,8 +263,8 @@ _cogl_pipeline_fragend_fixed_add_layer (CoglPipeline *pipeline, (layer, COGL_PIPELINE_LAYER_STATE_COMBINE_CONSTANT); CoglPipelineLayerBigState *big_state = authority->big_state; - GE (glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, - big_state->texture_combine_constant)); + GE (ctx, glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, + big_state->texture_combine_constant)); } return TRUE; @@ -315,9 +315,9 @@ _cogl_pipeline_fragend_fixed_end (CoglPipeline *pipeline, fogColor[2] = cogl_color_get_blue_float (&fog_state->color); fogColor[3] = cogl_color_get_alpha_float (&fog_state->color); - GE (glEnable (GL_FOG)); + GE (ctx, glEnable (GL_FOG)); - GE (glFogfv (GL_FOG_COLOR, fogColor)); + GE (ctx, glFogfv (GL_FOG_COLOR, fogColor)); #if HAVE_COGL_GLES switch (fog_state->mode) @@ -336,15 +336,15 @@ _cogl_pipeline_fragend_fixed_end (CoglPipeline *pipeline, /* TODO: support other modes for GLES2 */ /* NB: GLES doesn't have glFogi */ - GE (glFogf (GL_FOG_MODE, gl_mode)); - GE (glHint (GL_FOG_HINT, GL_NICEST)); + GE (ctx, glFogf (GL_FOG_MODE, gl_mode)); + GE (ctx, glHint (GL_FOG_HINT, GL_NICEST)); - GE (glFogf (GL_FOG_DENSITY, fog_state->density)); - GE (glFogf (GL_FOG_START, fog_state->z_near)); - GE (glFogf (GL_FOG_END, fog_state->z_far)); + GE (ctx, glFogf (GL_FOG_DENSITY, fog_state->density)); + GE (ctx, glFogf (GL_FOG_START, fog_state->z_near)); + GE (ctx, glFogf (GL_FOG_END, fog_state->z_far)); } else - GE (glDisable (GL_FOG)); + GE (ctx, glDisable (GL_FOG)); } return TRUE; diff --git a/cogl/cogl-pipeline-fragend-glsl.c b/cogl/cogl-pipeline-fragend-glsl.c index 6f6fb3a9..a0787c40 100644 --- a/cogl/cogl-pipeline-fragend-glsl.c +++ b/cogl/cogl-pipeline-fragend-glsl.c @@ -45,17 +45,6 @@ #include "cogl-shader-private.h" #include "cogl-program-private.h" -#ifndef HAVE_COGL_GLES2 - -#define glCreateShader ctx->glCreateShader -#define glGetShaderiv ctx->glGetShaderiv -#define glGetShaderInfoLog ctx->glGetShaderInfoLog -#define glCompileShader ctx->glCompileShader -#define glShaderSource ctx->glShaderSource -#define glDeleteShader ctx->glDeleteShader - -#endif /* HAVE_COGL_GLES2 */ - #include <glib.h> /* @@ -124,7 +113,7 @@ glsl_shader_state_unref (GlslShaderState *state) if (state->ref_count == 0) { if (state->gl_shader) - GE( glDeleteShader (state->gl_shader) ); + GE( ctx, glDeleteShader (state->gl_shader) ); g_free (state->unit_state); @@ -277,7 +266,7 @@ _cogl_pipeline_fragend_glsl_start (CoglPipeline *pipeline, return TRUE; /* We need to recreate the shader so destroy the existing one */ - GE( glDeleteShader (priv->glsl_shader_state->gl_shader) ); + GE( ctx, glDeleteShader (priv->glsl_shader_state->gl_shader) ); priv->glsl_shader_state->gl_shader = 0; } @@ -798,7 +787,7 @@ _cogl_pipeline_fragend_glsl_end (CoglPipeline *pipeline, g_string_append (glsl_shader_state->source, "}\n"); - GE_RET( shader, glCreateShader (GL_FRAGMENT_SHADER) ); + GE_RET( shader, ctx, glCreateShader (GL_FRAGMENT_SHADER) ); lengths[0] = glsl_shader_state->header->len; source_strings[0] = glsl_shader_state->header->str; @@ -817,17 +806,17 @@ _cogl_pipeline_fragend_glsl_end (CoglPipeline *pipeline, 2, /* count */ source_strings, lengths); - GE( glCompileShader (shader) ); - GE( glGetShaderiv (shader, GL_COMPILE_STATUS, &compile_status) ); + GE( ctx, glCompileShader (shader) ); + GE( ctx, glGetShaderiv (shader, GL_COMPILE_STATUS, &compile_status) ); if (!compile_status) { GLint len = 0; char *shader_log; - GE( glGetShaderiv (shader, GL_INFO_LOG_LENGTH, &len) ); + GE( ctx, glGetShaderiv (shader, GL_INFO_LOG_LENGTH, &len) ); shader_log = g_alloca (len); - GE( glGetShaderInfoLog (shader, len, &len, shader_log) ); + GE( ctx, glGetShaderInfoLog (shader, len, &len, shader_log) ); g_warning ("Shader compilation failed:\n%s", shader_log); } diff --git a/cogl/cogl-pipeline-opengl.c b/cogl/cogl-pipeline-opengl.c index 51ac2f64..836a8017 100644 --- a/cogl/cogl-pipeline-opengl.c +++ b/cogl/cogl-pipeline-opengl.c @@ -49,20 +49,6 @@ * GL/GLES compatability defines for pipeline thingies: */ -#ifdef HAVE_COGL_GL -#define glActiveTexture ctx->glActiveTexture -#define glClientActiveTexture ctx->glClientActiveTexture -#define glBlendEquation ctx->glBlendEquation -#define glBlendColor ctx->glBlendColor - -#define glProgramString ctx->glProgramString -#define glBindProgram ctx->glBindProgram -#define glDeletePrograms ctx->glDeletePrograms -#define glGenPrograms ctx->glGenPrograms -#define glProgramLocalParameter4fv ctx->glProgramLocalParameter4fv -#define glUseProgram ctx->glUseProgram -#endif - /* These aren't defined in the GLES headers */ #ifndef GL_POINT_SPRITE #define GL_POINT_SPRITE 0x8861 @@ -144,7 +130,7 @@ _cogl_set_active_texture_unit (int unit_index) if (ctx->active_texture_unit != unit_index) { - GE (glActiveTexture (GL_TEXTURE0 + unit_index)); + GE (ctx, glActiveTexture (GL_TEXTURE0 + unit_index)); ctx->active_texture_unit = unit_index; } } @@ -196,7 +182,7 @@ _cogl_bind_gl_texture_transient (GLenum gl_target, !unit->is_foreign) return; - GE (glBindTexture (gl_target, gl_texture)); + GE (ctx, glBindTexture (gl_target, gl_texture)); unit->dirty_gl_texture = TRUE; unit->is_foreign = is_foreign; @@ -222,7 +208,7 @@ _cogl_delete_gl_texture (GLuint gl_texture) } } - GE (glDeleteTextures (1, &gl_texture)); + GE (ctx, glDeleteTextures (1, &gl_texture)); } /* Whenever the underlying GL texture storage of a CoglTexture is @@ -266,14 +252,14 @@ set_glsl_program (GLuint gl_program) { GLenum gl_error; - while ((gl_error = glGetError ()) != GL_NO_ERROR) + while ((gl_error = ctx->glGetError ()) != GL_NO_ERROR) ; - glUseProgram (gl_program); - if (glGetError () == GL_NO_ERROR) + ctx->glUseProgram (gl_program); + if (ctx->glGetError () == GL_NO_ERROR) ctx->current_gl_program = gl_program; else { - GE( glUseProgram (0) ); + GE( ctx, glUseProgram (0) ); ctx->current_gl_program = 0; } } @@ -302,7 +288,7 @@ _cogl_use_fragment_program (GLuint gl_program, CoglPipelineProgramType type) case COGL_PIPELINE_PROGRAM_TYPE_ARBFP: #ifdef HAVE_COGL_GL - GE( glDisable (GL_FRAGMENT_PROGRAM_ARB) ); + GE( ctx, glDisable (GL_FRAGMENT_PROGRAM_ARB) ); #endif break; @@ -316,7 +302,7 @@ _cogl_use_fragment_program (GLuint gl_program, CoglPipelineProgramType type) { case COGL_PIPELINE_PROGRAM_TYPE_ARBFP: #ifdef HAVE_COGL_GL - GE( glEnable (GL_FRAGMENT_PROGRAM_ARB) ); + GE( ctx, glEnable (GL_FRAGMENT_PROGRAM_ARB) ); #endif break; @@ -421,8 +407,8 @@ _cogl_get_max_texture_image_units (void) if (G_UNLIKELY (ctx->max_texture_image_units == -1)) { ctx->max_texture_image_units = 1; - GE (glGetIntegerv (GL_MAX_TEXTURE_IMAGE_UNITS, - &ctx->max_texture_image_units)); + GE (ctx, glGetIntegerv (GL_MAX_TEXTURE_IMAGE_UNITS, + &ctx->max_texture_image_units)); } return ctx->max_texture_image_units; @@ -449,14 +435,14 @@ flush_depth_state (CoglDepthState *depth_state) if (ctx->depth_test_function_cache != depth_state->test_function) { - GE (glDepthFunc (depth_state->test_function)); + GE (ctx, glDepthFunc (depth_state->test_function)); ctx->depth_test_function_cache = depth_state->test_function; } if (ctx->depth_writing_enabled_cache != depth_state->write_enabled) { - GE (glDepthMask (depth_state->write_enabled ? - GL_TRUE : GL_FALSE)); + GE (ctx, glDepthMask (depth_state->write_enabled ? + GL_TRUE : GL_FALSE)); ctx->depth_writing_enabled_cache = depth_state->write_enabled; } @@ -465,11 +451,11 @@ flush_depth_state (CoglDepthState *depth_state) ctx->depth_range_far_cache != depth_state->range_far) { #ifdef COGL_HAS_GLES2 - GE (glDepthRangef (depth_state->range_near, - depth_state->range_far)); + GE (ctx, glDepthRangef (depth_state->range_near, + depth_state->range_far)); #else - GE (glDepthRange (depth_state->range_near, - depth_state->range_far)); + GE (ctx, glDepthRange (depth_state->range_near, + depth_state->range_far)); #endif ctx->depth_range_near_cache = depth_state->range_near; ctx->depth_range_far_cache = depth_state->range_far; @@ -496,10 +482,10 @@ _cogl_pipeline_flush_color_blend_alpha_depth_state ( { CoglPipeline *authority = _cogl_pipeline_get_authority (pipeline, COGL_PIPELINE_STATE_COLOR); - GE (glColor4ub (cogl_color_get_red_byte (&authority->color), - cogl_color_get_green_byte (&authority->color), - cogl_color_get_blue_byte (&authority->color), - cogl_color_get_alpha_byte (&authority->color))); + GE (ctx, glColor4ub (cogl_color_get_red_byte (&authority->color), + cogl_color_get_green_byte (&authority->color), + cogl_color_get_blue_byte (&authority->color), + cogl_color_get_alpha_byte (&authority->color))); } } #endif @@ -539,28 +525,28 @@ _cogl_pipeline_flush_color_blend_alpha_depth_state ( cogl_color_get_alpha_float (&blend_state->blend_constant); - GE (glBlendColor (red, green, blue, alpha)); + GE (ctx, glBlendColor (red, green, blue, alpha)); } if (have_blend_equation_seperate && blend_state->blend_equation_rgb != blend_state->blend_equation_alpha) - GE (ctx->glBlendEquationSeparate (blend_state->blend_equation_rgb, + GE (ctx, glBlendEquationSeparate (blend_state->blend_equation_rgb, blend_state->blend_equation_alpha)); else - GE (glBlendEquation (blend_state->blend_equation_rgb)); + GE (ctx, glBlendEquation (blend_state->blend_equation_rgb)); if (have_blend_func_separate && (blend_state->blend_src_factor_rgb != blend_state->blend_src_factor_alpha || (blend_state->blend_src_factor_rgb != blend_state->blend_src_factor_alpha))) - GE (ctx->glBlendFuncSeparate (blend_state->blend_src_factor_rgb, + GE (ctx, glBlendFuncSeparate (blend_state->blend_src_factor_rgb, blend_state->blend_dst_factor_rgb, blend_state->blend_src_factor_alpha, blend_state->blend_dst_factor_alpha)); else #endif - GE (glBlendFunc (blend_state->blend_src_factor_rgb, - blend_state->blend_dst_factor_rgb)); + GE (ctx, glBlendFunc (blend_state->blend_src_factor_rgb, + blend_state->blend_dst_factor_rgb)); } #ifndef HAVE_COGL_GLES2 @@ -576,8 +562,8 @@ _cogl_pipeline_flush_color_blend_alpha_depth_state ( &authority->big_state->alpha_state; /* NB: Currently the Cogl defines are compatible with the GL ones: */ - GE (glAlphaFunc (alpha_state->alpha_func, - alpha_state->alpha_func_reference)); + GE (ctx, glAlphaFunc (alpha_state->alpha_func, + alpha_state->alpha_func_reference)); } /* Under GLES2 the lighting parameters are implemented as uniforms @@ -589,16 +575,16 @@ _cogl_pipeline_flush_color_blend_alpha_depth_state ( CoglPipelineLightingState *lighting_state = &authority->big_state->lighting_state; - GE (glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT, - lighting_state->ambient)); - GE (glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, - lighting_state->diffuse)); - GE (glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, - lighting_state->specular)); - GE (glMaterialfv (GL_FRONT_AND_BACK, GL_EMISSION, - lighting_state->emission)); - GE (glMaterialfv (GL_FRONT_AND_BACK, GL_SHININESS, - &lighting_state->shininess)); + GE (ctx, glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT, + lighting_state->ambient)); + GE (ctx, glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, + lighting_state->diffuse)); + GE (ctx, glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, + lighting_state->specular)); + GE (ctx, glMaterialfv (GL_FRONT_AND_BACK, GL_EMISSION, + lighting_state->emission)); + GE (ctx, glMaterialfv (GL_FRONT_AND_BACK, GL_SHININESS, + &lighting_state->shininess)); } #endif /* HAVE_COGL_GLES2 */ @@ -613,14 +599,14 @@ _cogl_pipeline_flush_color_blend_alpha_depth_state ( { if (ctx->depth_test_enabled_cache != TRUE) { - GE (glEnable (GL_DEPTH_TEST)); + GE (ctx, glEnable (GL_DEPTH_TEST)); ctx->depth_test_enabled_cache = depth_state->test_enabled; } flush_depth_state (depth_state); } else if (ctx->depth_test_enabled_cache != FALSE) { - GE (glDisable (GL_DEPTH_TEST)); + GE (ctx, glDisable (GL_DEPTH_TEST)); ctx->depth_test_enabled_cache = depth_state->test_enabled; } } @@ -628,9 +614,9 @@ _cogl_pipeline_flush_color_blend_alpha_depth_state ( if (pipeline->real_blend_enable != ctx->gl_blend_enable_cache) { if (pipeline->real_blend_enable) - GE (glEnable (GL_BLEND)); + GE (ctx, glEnable (GL_BLEND)); else - GE (glDisable (GL_BLEND)); + GE (ctx, glDisable (GL_BLEND)); /* XXX: we shouldn't update any other blend state if blending * is disabled! */ ctx->gl_blend_enable_cache = pipeline->real_blend_enable; @@ -658,24 +644,24 @@ get_max_activateable_texture_units (void) /* Previously this code subtracted the value by one but there was no explanation for why it did this and it doesn't seem to make sense so it has been removed */ - GE (glGetIntegerv (GL_MAX_TEXTURE_COORDS, values + n_values++)); + GE (ctx, glGetIntegerv (GL_MAX_TEXTURE_COORDS, values + n_values++)); /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS is defined for GLSL but not ARBfp */ if (cogl_features_available (COGL_FEATURE_SHADERS_GLSL)) - GE (glGetIntegerv (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, - values + n_values++)); + GE (ctx, glGetIntegerv (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, + values + n_values++)); #endif /* HAVE_COGL_GL */ #ifdef HAVE_COGL_GLES2 - GE (glGetIntegerv (GL_MAX_VERTEX_ATTRIBS, values + n_values)); + GE (ctx, glGetIntegerv (GL_MAX_VERTEX_ATTRIBS, values + n_values)); /* Two of the vertex attribs need to be used for the position and color */ values[n_values++] -= 2; - GE (glGetIntegerv (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, - values + n_values++)); + GE (ctx, glGetIntegerv (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, + values + n_values++)); #else /* HAVE_COGL_GLES2 */ @@ -684,8 +670,8 @@ get_max_activateable_texture_units (void) available in GLES2. These are also tied to the number of texture coordinates that can be uploaded so it should be less than that available from the shader extensions */ - GE (glGetIntegerv (GL_MAX_TEXTURE_UNITS, - values + n_values++)); + GE (ctx, glGetIntegerv (GL_MAX_TEXTURE_UNITS, + values + n_values++)); #endif /* HAVE_COGL_GLES2 */ @@ -784,7 +770,7 @@ flush_layers_common_gl_state_cb (CoglPipelineLayer *layer, void *user_data) if (unit_index == 1) unit->dirty_gl_texture = TRUE; else - GE (glBindTexture (gl_target, gl_texture)); + GE (ctx, glBindTexture (gl_target, gl_texture)); unit->gl_texture = gl_texture; unit->gl_target = gl_target; } @@ -810,8 +796,8 @@ flush_layers_common_gl_state_cb (CoglPipelineLayer *layer, void *user_data) _cogl_set_active_texture_unit (unit_index); - GE (glTexEnvi (GL_POINT_SPRITE, GL_COORD_REPLACE, - big_state->point_sprite_coords)); + GE (ctx, glTexEnvi (GL_POINT_SPRITE, GL_COORD_REPLACE, + big_state->point_sprite_coords)); } #endif /* HAVE_COGL_GLES2 */ @@ -1321,7 +1307,8 @@ done: attribute = _cogl_pipeline_progend_glsl_get_color_attribute (pipeline); if (attribute != -1) - GE (glVertexAttrib4f (attribute, + GE (ctx, + glVertexAttrib4f (attribute, cogl_color_get_red_float (&authority->color), cogl_color_get_green_float (&authority->color), cogl_color_get_blue_float (&authority->color), @@ -1352,7 +1339,7 @@ done: if (cogl_pipeline_get_n_layers (pipeline) > 1 && unit1->dirty_gl_texture) { _cogl_set_active_texture_unit (1); - GE (glBindTexture (unit1->gl_target, unit1->gl_texture)); + GE (ctx, glBindTexture (unit1->gl_target, unit1->gl_texture)); unit1->dirty_gl_texture = FALSE; } diff --git a/cogl/cogl-pipeline-progend-glsl.c b/cogl/cogl-pipeline-progend-glsl.c index 7efbe258..51be8d12 100644 --- a/cogl/cogl-pipeline-progend-glsl.c +++ b/cogl/cogl-pipeline-progend-glsl.c @@ -42,21 +42,7 @@ #include "cogl-pipeline-fragend-glsl-private.h" #include "cogl-pipeline-vertend-glsl-private.h" -#ifndef HAVE_COGL_GLES2 - -#define glCreateProgram ctx->glCreateProgram -#define glAttachShader ctx->glAttachShader -#define glUseProgram ctx->glUseProgram -#define glLinkProgram ctx->glLinkProgram -#define glDeleteProgram ctx->glDeleteProgram -#define glGetProgramInfoLog ctx->glGetProgramInfoLog -#define glGetProgramiv ctx->glGetProgramiv -#define glGetUniformLocation ctx->glGetUniformLocation -#define glUniform1i ctx->glUniform1i -#define glUniform1f ctx->glUniform1f -#define glUniform4fv ctx->glUniform4fv - -#else +#ifdef HAVE_COGL_GLES2 /* These are used to generalise updating some uniforms that are required when building for GLES2 */ @@ -178,12 +164,14 @@ _cogl_pipeline_progend_glsl_get_position_attribute (CoglPipeline *pipeline) { CoglPipelineProgendPrivate *priv = get_glsl_priv (pipeline); + _COGL_GET_CONTEXT (ctx, -1); + g_return_val_if_fail (priv != NULL, -1); g_return_val_if_fail (priv->program != 0, -1); if (priv->position_attribute_location == ATTRIBUTE_LOCATION_UNKNOWN) GE_RET( priv->position_attribute_location, - glGetAttribLocation (priv->program, "cogl_position_in") ); + ctx, glGetAttribLocation (priv->program, "cogl_position_in") ); return priv->position_attribute_location; } @@ -193,12 +181,14 @@ _cogl_pipeline_progend_glsl_get_color_attribute (CoglPipeline *pipeline) { CoglPipelineProgendPrivate *priv = get_glsl_priv (pipeline); + _COGL_GET_CONTEXT (ctx, -1); + g_return_val_if_fail (priv != NULL, -1); g_return_val_if_fail (priv->program != 0, -1); if (priv->color_attribute_location == ATTRIBUTE_LOCATION_UNKNOWN) GE_RET( priv->color_attribute_location, - glGetAttribLocation (priv->program, "cogl_color_in") ); + ctx, glGetAttribLocation (priv->program, "cogl_color_in") ); return priv->color_attribute_location; } @@ -208,12 +198,14 @@ _cogl_pipeline_progend_glsl_get_normal_attribute (CoglPipeline *pipeline) { CoglPipelineProgendPrivate *priv = get_glsl_priv (pipeline); + _COGL_GET_CONTEXT (ctx, -1); + g_return_val_if_fail (priv != NULL, -1); g_return_val_if_fail (priv->program != 0, -1); if (priv->normal_attribute_location == ATTRIBUTE_LOCATION_UNKNOWN) GE_RET( priv->normal_attribute_location, - glGetAttribLocation (priv->program, "cogl_normal_in") ); + ctx, glGetAttribLocation (priv->program, "cogl_normal_in") ); return priv->normal_attribute_location; } @@ -224,6 +216,8 @@ _cogl_pipeline_progend_glsl_get_tex_coord_attribute (CoglPipeline *pipeline, { CoglPipelineProgendPrivate *priv = get_glsl_priv (pipeline); + _COGL_GET_CONTEXT (ctx, -1); + g_return_val_if_fail (priv != NULL, -1); g_return_val_if_fail (priv->program != 0, -1); @@ -231,7 +225,8 @@ _cogl_pipeline_progend_glsl_get_tex_coord_attribute (CoglPipeline *pipeline, { if (priv->tex_coord0_attribute_location == ATTRIBUTE_LOCATION_UNKNOWN) GE_RET( priv->tex_coord0_attribute_location, - glGetAttribLocation (priv->program, "cogl_tex_coord0_in") ); + ctx, glGetAttribLocation (priv->program, + "cogl_tex_coord0_in") ); return priv->tex_coord0_attribute_location; } @@ -256,7 +251,7 @@ _cogl_pipeline_progend_glsl_get_tex_coord_attribute (CoglPipeline *pipeline, if (locations[unit - 1] == ATTRIBUTE_LOCATION_UNKNOWN) GE_RET( locations[unit - 1], - glGetAttribLocation (priv->program, name) ); + ctx, glGetAttribLocation (priv->program, name) ); g_free (name); @@ -311,7 +306,7 @@ destroy_glsl_priv (void *user_data) #endif if (priv->program) - GE( glDeleteProgram (priv->program) ); + GE( ctx, glDeleteProgram (priv->program) ); g_free (priv->unit_state); @@ -344,9 +339,9 @@ link_program (GLint gl_program) _COGL_GET_CONTEXT (ctx, NO_RETVAL); - GE( glLinkProgram (gl_program) ); + GE( ctx, glLinkProgram (gl_program) ); - GE( glGetProgramiv (gl_program, GL_LINK_STATUS, &link_status) ); + GE( ctx, glGetProgramiv (gl_program, GL_LINK_STATUS, &link_status) ); if (!link_status) { @@ -354,12 +349,12 @@ link_program (GLint gl_program) GLsizei out_log_length; char *log; - GE( glGetProgramiv (gl_program, GL_INFO_LOG_LENGTH, &log_length) ); + GE( ctx, glGetProgramiv (gl_program, GL_INFO_LOG_LENGTH, &log_length) ); log = g_malloc (log_length); - GE( glGetProgramInfoLog (gl_program, log_length, - &out_log_length, log) ); + GE( ctx, glGetProgramInfoLog (gl_program, log_length, + &out_log_length, log) ); g_warning ("Failed to link GLSL program:\n%.*s\n", log_length, log); @@ -395,23 +390,23 @@ get_uniform_cb (CoglPipeline *pipeline, "_cogl_sampler_%i", state->unit); GE_RET( uniform_location, - glGetUniformLocation (state->gl_program, - ctx->codegen_source_buffer->str) ); + ctx, glGetUniformLocation (state->gl_program, + ctx->codegen_source_buffer->str) ); /* We can set the uniform immediately because the samplers are the unit index not the texture object number so it will never change. Unfortunately GL won't let us use a constant instead of a uniform */ if (uniform_location != -1) - GE( glUniform1i (uniform_location, state->unit) ); + GE( ctx, glUniform1i (uniform_location, state->unit) ); g_string_set_size (ctx->codegen_source_buffer, 0); g_string_append_printf (ctx->codegen_source_buffer, "_cogl_layer_constant_%i", state->unit); GE_RET( uniform_location, - glGetUniformLocation (state->gl_program, - ctx->codegen_source_buffer->str) ); + ctx, glGetUniformLocation (state->gl_program, + ctx->codegen_source_buffer->str) ); unit_state->combine_constant_uniform = uniform_location; @@ -422,8 +417,8 @@ get_uniform_cb (CoglPipeline *pipeline, "cogl_texture_matrix[%i]", state->unit); GE_RET( uniform_location, - glGetUniformLocation (state->gl_program, - ctx->codegen_source_buffer->str) ); + ctx, glGetUniformLocation (state->gl_program, + ctx->codegen_source_buffer->str) ); unit_state->texture_matrix_uniform = uniform_location; @@ -452,8 +447,8 @@ update_constants_cb (CoglPipeline *pipeline, _cogl_pipeline_get_layer_combine_constant (pipeline, layer_index, constant); - GE (glUniform4fv (unit_state->combine_constant_uniform, - 1, constant)); + GE (ctx, glUniform4fv (unit_state->combine_constant_uniform, + 1, constant)); unit_state->dirty_combine_constant = FALSE; } @@ -467,8 +462,8 @@ update_constants_cb (CoglPipeline *pipeline, matrix = _cogl_pipeline_get_layer_matrix (pipeline, layer_index); array = cogl_matrix_get_array (matrix); - GE (glUniformMatrix4fv (unit_state->texture_matrix_uniform, - 1, FALSE, array)); + GE (ctx, glUniformMatrix4fv (unit_state->texture_matrix_uniform, + 1, FALSE, array)); unit_state->dirty_texture_matrix = FALSE; } @@ -575,7 +570,7 @@ _cogl_pipeline_progend_glsl_end (CoglPipeline *pipeline, (user_program->age != priv->user_program_age || n_tex_coord_attribs > priv->n_tex_coord_attribs)) { - GE( glDeleteProgram (priv->program) ); + GE( ctx, glDeleteProgram (priv->program) ); priv->program = 0; } @@ -584,7 +579,7 @@ _cogl_pipeline_progend_glsl_end (CoglPipeline *pipeline, GLuint backend_shader; GSList *l; - GE_RET( priv->program, glCreateProgram () ); + GE_RET( priv->program, ctx, glCreateProgram () ); /* Attach all of the shader from the user program */ if (user_program) @@ -613,8 +608,8 @@ _cogl_pipeline_progend_glsl_end (CoglPipeline *pipeline, g_assert (shader->language == COGL_SHADER_LANGUAGE_GLSL); - GE( glAttachShader (priv->program, - shader->gl_handle) ); + GE( ctx, glAttachShader (priv->program, + shader->gl_handle) ); } priv->user_program_age = user_program->age; @@ -623,10 +618,10 @@ _cogl_pipeline_progend_glsl_end (CoglPipeline *pipeline, /* Attach any shaders from the GLSL backends */ if (pipeline->fragend == COGL_PIPELINE_FRAGEND_GLSL && (backend_shader = _cogl_pipeline_fragend_glsl_get_shader (pipeline))) - GE( glAttachShader (priv->program, backend_shader) ); + GE( ctx, glAttachShader (priv->program, backend_shader) ); if (pipeline->vertend == COGL_PIPELINE_VERTEND_GLSL && (backend_shader = _cogl_pipeline_vertend_glsl_get_shader (pipeline))) - GE( glAttachShader (priv->program, backend_shader) ); + GE( ctx, glAttachShader (priv->program, backend_shader) ); link_program (priv->program); @@ -669,20 +664,20 @@ _cogl_pipeline_progend_glsl_end (CoglPipeline *pipeline, for (i = 0; i < G_N_ELEMENTS (builtin_uniforms); i++) GE_RET( priv->builtin_uniform_locations[i], - glGetUniformLocation (gl_program, - builtin_uniforms[i].uniform_name) ); + ctx, glGetUniformLocation (gl_program, + builtin_uniforms[i].uniform_name) ); GE_RET( priv->modelview_uniform, - glGetUniformLocation (gl_program, - "cogl_modelview_matrix") ); + ctx, glGetUniformLocation (gl_program, + "cogl_modelview_matrix") ); GE_RET( priv->projection_uniform, - glGetUniformLocation (gl_program, - "cogl_projection_matrix") ); + ctx, glGetUniformLocation (gl_program, + "cogl_projection_matrix") ); GE_RET( priv->mvp_uniform, - glGetUniformLocation (gl_program, - "cogl_modelview_projection_matrix") ); + ctx, glGetUniformLocation (gl_program, + "cogl_modelview_projection_matrix") ); } if (program_changed || priv->last_used_for_pipeline != pipeline) @@ -775,8 +770,10 @@ flush_modelview_cb (gboolean is_identity, { CoglPipelineProgendPrivate *priv = user_data; - GE( glUniformMatrix4fv (priv->modelview_uniform, 1, FALSE, - cogl_matrix_get_array (matrix)) ); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + + GE( ctx, glUniformMatrix4fv (priv->modelview_uniform, 1, FALSE, + cogl_matrix_get_array (matrix)) ); } static void @@ -786,8 +783,10 @@ flush_projection_cb (gboolean is_identity, { CoglPipelineProgendPrivate *priv = user_data; - GE( glUniformMatrix4fv (priv->projection_uniform, 1, FALSE, - cogl_matrix_get_array (matrix)) ); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + + GE( ctx, glUniformMatrix4fv (priv->projection_uniform, 1, FALSE, + cogl_matrix_get_array (matrix)) ); } typedef struct @@ -804,19 +803,23 @@ flush_combined_step_two_cb (gboolean is_identity, FlushCombinedData *data = user_data; CoglMatrix mvp_matrix; + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + /* If the modelview is the identity then we can bypass the matrix multiplication */ if (is_identity) - GE( glUniformMatrix4fv (data->priv->mvp_uniform, 1, FALSE, - cogl_matrix_get_array (data->projection_matrix)) ); + { + const float *array = cogl_matrix_get_array (data->projection_matrix); + GE( ctx, glUniformMatrix4fv (data->priv->mvp_uniform, 1, FALSE, array ) ); + } else { cogl_matrix_multiply (&mvp_matrix, data->projection_matrix, matrix); - GE( glUniformMatrix4fv (data->priv->mvp_uniform, 1, FALSE, - cogl_matrix_get_array (&mvp_matrix)) ); + GE( ctx, glUniformMatrix4fv (data->priv->mvp_uniform, 1, FALSE, + cogl_matrix_get_array (&mvp_matrix)) ); } } @@ -927,8 +930,10 @@ update_float_uniform (CoglPipeline *pipeline, float (* float_getter_func) (CoglPipeline *) = getter_func; float value; + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + value = float_getter_func (pipeline); - GE( glUniform1f (uniform_location, value) ); + GE( ctx, glUniform1f (uniform_location, value) ); } #endif diff --git a/cogl/cogl-pipeline-vertend-fixed.c b/cogl/cogl-pipeline-vertend-fixed.c index dc2008ac..d6baf98f 100644 --- a/cogl/cogl-pipeline-vertend-fixed.c +++ b/cogl/cogl-pipeline-vertend-fixed.c @@ -104,7 +104,7 @@ _cogl_pipeline_vertend_fixed_end (CoglPipeline *pipeline, if (ctx->point_size_cache != authority->big_state->point_size) { - GE( glPointSize (authority->big_state->point_size) ); + GE( ctx, glPointSize (authority->big_state->point_size) ); ctx->point_size_cache = authority->big_state->point_size; } } diff --git a/cogl/cogl-pipeline-vertend-glsl.c b/cogl/cogl-pipeline-vertend-glsl.c index 44a747b8..ac98c877 100644 --- a/cogl/cogl-pipeline-vertend-glsl.c +++ b/cogl/cogl-pipeline-vertend-glsl.c @@ -41,17 +41,6 @@ #include "cogl-program-private.h" #include "cogl-pipeline-vertend-glsl-private.h" -#ifndef HAVE_COGL_GLES2 - -#define glCreateShader ctx->glCreateShader -#define glGetShaderiv ctx->glGetShaderiv -#define glGetShaderInfoLog ctx->glGetShaderInfoLog -#define glCompileShader ctx->glCompileShader -#define glShaderSource ctx->glShaderSource -#define glDeleteShader ctx->glDeleteShader - -#endif /* HAVE_COGL_GLES2 */ - const CoglPipelineVertend _cogl_pipeline_glsl_vertend; typedef struct @@ -86,7 +75,7 @@ destroy_glsl_priv (void *user_data) if (--priv->ref_count == 0) { if (priv->gl_shader) - GE( glDeleteShader (priv->gl_shader) ); + GE( ctx, glDeleteShader (priv->gl_shader) ); g_slice_free (CoglPipelineVertendPrivate, priv); } @@ -185,7 +174,7 @@ _cogl_pipeline_vertend_glsl_start (CoglPipeline *pipeline, return TRUE; /* We need to recreate the shader so destroy the existing one */ - GE( glDeleteShader (priv->gl_shader) ); + GE( ctx, glDeleteShader (priv->gl_shader) ); priv->gl_shader = 0; } @@ -234,7 +223,7 @@ _cogl_pipeline_vertend_glsl_start (CoglPipeline *pipeline, if (ctx->point_size_cache != authority->big_state->point_size) { - GE( glPointSize (authority->big_state->point_size) ); + GE( ctx, glPointSize (authority->big_state->point_size) ); ctx->point_size_cache = authority->big_state->point_size; } } @@ -332,7 +321,7 @@ _cogl_pipeline_vertend_glsl_end (CoglPipeline *pipeline, " cogl_color_out = cogl_color_in;\n" "}\n"); - GE_RET( shader, glCreateShader (GL_VERTEX_SHADER) ); + GE_RET( shader, ctx, glCreateShader (GL_VERTEX_SHADER) ); lengths[0] = priv->header->len; source_strings[0] = priv->header->str; @@ -346,17 +335,17 @@ _cogl_pipeline_vertend_glsl_end (CoglPipeline *pipeline, 2, /* count */ source_strings, lengths); - GE( glCompileShader (shader) ); - GE( glGetShaderiv (shader, GL_COMPILE_STATUS, &compile_status) ); + GE( ctx, glCompileShader (shader) ); + GE( ctx, glGetShaderiv (shader, GL_COMPILE_STATUS, &compile_status) ); if (!compile_status) { GLint len = 0; char *shader_log; - GE( glGetShaderiv (shader, GL_INFO_LOG_LENGTH, &len) ); + GE( ctx, glGetShaderiv (shader, GL_INFO_LOG_LENGTH, &len) ); shader_log = g_alloca (len); - GE( glGetShaderInfoLog (shader, len, &len, shader_log) ); + GE( ctx, glGetShaderInfoLog (shader, len, &len, shader_log) ); g_warning ("Shader compilation failed:\n%s", shader_log); } diff --git a/cogl/cogl-pixel-buffer.c b/cogl/cogl-pixel-buffer.c index ea925530..e8a1b06b 100644 --- a/cogl/cogl-pixel-buffer.c +++ b/cogl/cogl-pixel-buffer.c @@ -52,15 +52,6 @@ #if defined (HAVE_COGL_GL) -#define glGenBuffers ctx->drv.pf_glGenBuffers -#define glBindBuffer ctx->drv.pf_glBindBuffer -#define glBufferData ctx->drv.pf_glBufferData -#define glBufferSubData ctx->drv.pf_glBufferSubData -#define glGetBufferSubData ctx->drv.pf_glGetBufferSubData -#define glDeleteBuffers ctx->drv.pf_glDeleteBuffers -#define glMapBuffer ctx->drv.pf_glMapBuffer -#define glUnmapBuffer ctx->drv.pf_glUnmapBuffer - #ifndef GL_PIXEL_UNPACK_BUFFER #define GL_PIXEL_UNPACK_BUFFER GL_PIXEL_UNPACK_BUFFER_ARB #endif diff --git a/cogl/cogl-primitives.c b/cogl/cogl-primitives.c index fd83813f..69cb71ed 100644 --- a/cogl/cogl-primitives.c +++ b/cogl/cogl-primitives.c @@ -42,11 +42,6 @@ #define _COGL_MAX_BEZ_RECURSE_DEPTH 16 -#ifdef HAVE_COGL_GL -#define glClientActiveTexture ctx->drv.pf_glClientActiveTexture -#endif - - typedef struct _TextureSlicedQuadState { CoglPipeline *pipeline; diff --git a/cogl/cogl-program.c b/cogl/cogl-program.c index 24a938d0..8f00eada 100644 --- a/cogl/cogl-program.c +++ b/cogl/cogl-program.c @@ -48,32 +48,6 @@ COGL_OBJECT_DEFINE_DEPRECATED_REF_COUNTING (program); an array and then flushed whenever the material backend requests it. */ -#ifndef HAVE_COGL_GLES2 - -#define glGetUniformLocation ctx->glGetUniformLocation -#define glUniform1f ctx->glUniform1f -#define glUniform2f ctx->glUniform2f -#define glUniform3f ctx->glUniform3f -#define glUniform4f ctx->glUniform4f -#define glUniform1fv ctx->glUniform1fv -#define glUniform2fv ctx->glUniform2fv -#define glUniform3fv ctx->glUniform3fv -#define glUniform4fv ctx->glUniform4fv -#define glUniform1i ctx->glUniform1i -#define glUniform2i ctx->glUniform2i -#define glUniform3i ctx->glUniform3i -#define glUniform4i ctx->glUniform4i -#define glUniform1iv ctx->glUniform1iv -#define glUniform2iv ctx->glUniform2iv -#define glUniform3iv ctx->glUniform3iv -#define glUniform4iv ctx->glUniform4iv -#define glUniformMatrix2fv ctx->glUniformMatrix2fv -#define glUniformMatrix3fv ctx->glUniformMatrix3fv -#define glUniformMatrix4fv ctx->glUniformMatrix4fv -#define glProgramLocalParameter4fv ctx->glProgramLocalParameter4fv - -#endif /* HAVE_COGL_GLES2 */ - static void _cogl_program_free (CoglProgram *program) { @@ -448,10 +422,10 @@ _cogl_program_flush_uniform_glsl (GLint location, switch (value->size) { - case 1: glUniform1iv (location, value->count, ptr); break; - case 2: glUniform2iv (location, value->count, ptr); break; - case 3: glUniform3iv (location, value->count, ptr); break; - case 4: glUniform4iv (location, value->count, ptr); break; + case 1: ctx->glUniform1iv (location, value->count, ptr); break; + case 2: ctx->glUniform2iv (location, value->count, ptr); break; + case 3: ctx->glUniform3iv (location, value->count, ptr); break; + case 4: ctx->glUniform4iv (location, value->count, ptr); break; } } break; @@ -467,10 +441,10 @@ _cogl_program_flush_uniform_glsl (GLint location, switch (value->size) { - case 1: glUniform1fv (location, value->count, ptr); break; - case 2: glUniform2fv (location, value->count, ptr); break; - case 3: glUniform3fv (location, value->count, ptr); break; - case 4: glUniform4fv (location, value->count, ptr); break; + case 1: ctx->glUniform1fv (location, value->count, ptr); break; + case 2: ctx->glUniform2fv (location, value->count, ptr); break; + case 3: ctx->glUniform3fv (location, value->count, ptr); break; + case 4: ctx->glUniform4fv (location, value->count, ptr); break; } } break; @@ -487,13 +461,16 @@ _cogl_program_flush_uniform_glsl (GLint location, switch (value->size) { case 2: - glUniformMatrix2fv (location, value->count, value->transpose, ptr); + ctx->glUniformMatrix2fv (location, value->count, + value->transpose, ptr); break; case 3: - glUniformMatrix3fv (location, value->count, value->transpose, ptr); + ctx->glUniformMatrix3fv (location, value->count, + value->transpose, ptr); break; case 4: - glUniformMatrix4fv (location, value->count, value->transpose, ptr); + ctx->glUniformMatrix4fv (location, value->count, + value->transpose, ptr); break; } } @@ -517,8 +494,8 @@ _cogl_program_flush_uniform_arbfp (GLint location, g_return_if_fail (value->size == 4); g_return_if_fail (value->count == 1); - GE( glProgramLocalParameter4fv (GL_FRAGMENT_PROGRAM_ARB, location, - value->v.float_value) ); + GE( ctx, glProgramLocalParameter4fv (GL_FRAGMENT_PROGRAM_ARB, location, + value->v.float_value) ); } } @@ -552,7 +529,7 @@ _cogl_program_flush_uniforms (CoglProgram *program, if (_cogl_program_get_language (program) == COGL_SHADER_LANGUAGE_GLSL) uniform->location = - glGetUniformLocation (gl_program, uniform->name); + ctx->glGetUniformLocation (gl_program, uniform->name); else uniform->location = get_local_param_index (uniform->name); diff --git a/cogl/cogl-shader.c b/cogl/cogl-shader.c index 7b474bfc..996676b8 100644 --- a/cogl/cogl-shader.c +++ b/cogl/cogl-shader.c @@ -36,22 +36,6 @@ #include <string.h> -#ifdef HAVE_COGL_GL -#define glCreateShader ctx->glCreateShader -#define glGetShaderiv ctx->glGetShaderiv -#define glGetShaderInfoLog ctx->glGetShaderInfoLog -#define glCompileShader ctx->glCompileShader -#define glShaderSource ctx->glShaderSource -#define glDeleteShader ctx->glDeleteShader -#define glProgramString ctx->glProgramString -#define glBindProgram ctx->glBindProgram -#define glDeletePrograms ctx->glDeletePrograms -#define glGenPrograms ctx->glGenPrograms -#define GET_CONTEXT _COGL_GET_CONTEXT -#else -#define GET_CONTEXT(CTXVAR,RETVAL) G_STMT_START { } G_STMT_END -#endif - static void _cogl_shader_free (CoglShader *shader); COGL_HANDLE_DEFINE (Shader, shader); @@ -70,12 +54,12 @@ _cogl_shader_free (CoglShader *shader) if (shader->language == COGL_SHADER_LANGUAGE_ARBFP) { if (shader->gl_handle) - GE (glDeletePrograms (1, &shader->gl_handle)); + GE (ctx, glDeletePrograms (1, &shader->gl_handle)); } else #endif if (shader->gl_handle) - GE (glDeleteShader (shader->gl_handle)); + GE (ctx, glDeleteShader (shader->gl_handle)); #endif /* HAVE_COGL_GLES */ @@ -87,7 +71,7 @@ cogl_create_shader (CoglShaderType type) { CoglShader *shader; - GET_CONTEXT (ctx, COGL_INVALID_HANDLE); + _COGL_GET_CONTEXT (ctx, COGL_INVALID_HANDLE); switch (type) { @@ -122,13 +106,13 @@ delete_shader (CoglShader *shader) if (shader->language == COGL_SHADER_LANGUAGE_ARBFP) { if (shader->gl_handle) - GE (glDeletePrograms (1, &shader->gl_handle)); + GE (ctx, glDeletePrograms (1, &shader->gl_handle)); } else #endif { if (shader->gl_handle) - GE (glDeleteShader (shader->gl_handle)); + GE (ctx, glDeleteShader (shader->gl_handle)); } shader->gl_handle = 0; @@ -211,7 +195,7 @@ _cogl_shader_set_source_with_boilerplate (GLuint shader_gl_handle, char *tex_coord_declarations = NULL; #endif - GET_CONTEXT (ctx, NO_RETVAL); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); #ifdef HAVE_COGL_GLES2 if (cogl_features_available (COGL_FEATURE_TEXTURE_3D)) @@ -295,8 +279,8 @@ _cogl_shader_set_source_with_boilerplate (GLuint shader_gl_handle, g_string_free (buf, TRUE); } - GE( glShaderSource (shader_gl_handle, count, - (const char **) strings, lengths) ); + GE( ctx, glShaderSource (shader_gl_handle, count, + (const char **) strings, lengths) ); #ifdef HAVE_COGL_GLES2 g_free (tex_coord_declarations); @@ -325,30 +309,30 @@ _cogl_shader_compile_real (CoglHandle handle, if (shader->gl_handle) return; - GE (glGenPrograms (1, &shader->gl_handle)); + GE (ctx, glGenPrograms (1, &shader->gl_handle)); - GE (glBindProgram (GL_FRAGMENT_PROGRAM_ARB, shader->gl_handle)); + GE (ctx, glBindProgram (GL_FRAGMENT_PROGRAM_ARB, shader->gl_handle)); if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_SHOW_SOURCE))) g_message ("user ARBfp program:\n%s", shader->source); #ifdef COGL_GL_DEBUG - while ((gl_error = glGetError ()) != GL_NO_ERROR) + while ((gl_error = ctx->glGetError ()) != GL_NO_ERROR) ; #endif - glProgramString (GL_FRAGMENT_PROGRAM_ARB, - GL_PROGRAM_FORMAT_ASCII_ARB, - strlen (shader->source), - shader->source); + ctx->glProgramString (GL_FRAGMENT_PROGRAM_ARB, + GL_PROGRAM_FORMAT_ASCII_ARB, + strlen (shader->source), + shader->source); #ifdef COGL_GL_DEBUG - gl_error = glGetError (); + gl_error = ctx->glGetError (); if (gl_error != GL_NO_ERROR) { g_warning ("%s: GL error (%d): Failed to compile ARBfp:\n%s\n%s", G_STRLOC, gl_error, shader->source, - glGetString (GL_PROGRAM_ERROR_STRING_ARB)); + ctx->glGetString (GL_PROGRAM_ERROR_STRING_ARB)); } #endif } @@ -380,7 +364,7 @@ _cogl_shader_compile_real (CoglHandle handle, break; } - shader->gl_handle = glCreateShader (gl_type); + shader->gl_handle = ctx->glCreateShader (gl_type); _cogl_shader_set_source_with_boilerplate (shader->gl_handle, gl_type, @@ -389,7 +373,7 @@ _cogl_shader_compile_real (CoglHandle handle, (const char **) &shader->source, NULL); - GE (glCompileShader (shader->gl_handle)); + GE (ctx, glCompileShader (shader->gl_handle)); #ifdef HAVE_COGL_GLES2 shader->n_tex_coord_attribs = n_tex_coord_attribs; @@ -420,7 +404,7 @@ cogl_shader_get_info_log (CoglHandle handle) CoglShader *shader; - GET_CONTEXT (ctx, NULL); + _COGL_GET_CONTEXT (ctx, NULL); if (!cogl_is_shader (handle)) return NULL; @@ -455,7 +439,7 @@ cogl_shader_get_info_log (CoglHandle handle) if (!shader->gl_handle) _cogl_shader_compile_real (handle, 4); - glGetShaderInfoLog (shader->gl_handle, 511, &len, buffer); + ctx->glGetShaderInfoLog (shader->gl_handle, 511, &len, buffer); buffer[len] = '\0'; return g_strdup (buffer); } @@ -468,7 +452,7 @@ cogl_shader_get_type (CoglHandle handle) { CoglShader *shader; - GET_CONTEXT (ctx, COGL_SHADER_TYPE_VERTEX); + _COGL_GET_CONTEXT (ctx, COGL_SHADER_TYPE_VERTEX); if (!cogl_is_shader (handle)) { @@ -492,7 +476,7 @@ cogl_shader_is_compiled (CoglHandle handle) GLint status; CoglShader *shader; - GET_CONTEXT (ctx, FALSE); + _COGL_GET_CONTEXT (ctx, FALSE); if (!cogl_is_shader (handle)) return FALSE; @@ -523,7 +507,7 @@ cogl_shader_is_compiled (CoglHandle handle) if (!shader->gl_handle) _cogl_shader_compile_real (handle, 4); - GE (glGetShaderiv (shader->gl_handle, GL_COMPILE_STATUS, &status)); + GE (ctx, glGetShaderiv (shader->gl_handle, GL_COMPILE_STATUS, &status)); if (status == GL_TRUE) return TRUE; else diff --git a/cogl/cogl-texture-2d.c b/cogl/cogl-texture-2d.c index 86ccae10..267ed9ac 100644 --- a/cogl/cogl-texture-2d.c +++ b/cogl/cogl-texture-2d.c @@ -136,6 +136,8 @@ _cogl_texture_2d_set_wrap_mode_parameters (CoglTexture *tex, { CoglTexture2D *tex_2d = COGL_TEXTURE_2D (tex); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + /* Only set the wrap mode if it's different from the current value to avoid too many GL calls. Texture 2D doesn't make use of the r coordinate so we can ignore its wrap mode */ @@ -145,8 +147,12 @@ _cogl_texture_2d_set_wrap_mode_parameters (CoglTexture *tex, _cogl_bind_gl_texture_transient (GL_TEXTURE_2D, tex_2d->gl_texture, tex_2d->is_foreign); - GE( glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap_mode_s) ); - GE( glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_mode_t) ); + GE( ctx, glTexParameteri (GL_TEXTURE_2D, + GL_TEXTURE_WRAP_S, + wrap_mode_s) ); + GE( ctx, glTexParameteri (GL_TEXTURE_2D, + GL_TEXTURE_WRAP_T, + wrap_mode_t) ); tex_2d->wrap_mode_s = wrap_mode_s; tex_2d->wrap_mode_t = wrap_mode_t; @@ -262,8 +268,8 @@ cogl_texture_2d_new_with_size (CoglContext *ctx, _cogl_bind_gl_texture_transient (GL_TEXTURE_2D, tex_2d->gl_texture, tex_2d->is_foreign); - GE( glTexImage2D (GL_TEXTURE_2D, 0, gl_intformat, - width, height, 0, gl_format, gl_type, NULL) ); + GE( ctx, glTexImage2D (GL_TEXTURE_2D, 0, gl_intformat, + width, height, 0, gl_format, gl_type, NULL) ); return _cogl_texture_2d_handle_new (tex_2d); } @@ -405,15 +411,15 @@ cogl_texture_2d_new_from_foreign (CoglContext *ctx, return COGL_INVALID_HANDLE; /* Make sure it is a valid GL texture object */ - if (!glIsTexture (gl_handle)) + if (!ctx->glIsTexture (gl_handle)) return COGL_INVALID_HANDLE; /* Make sure binding succeeds */ - while ((gl_error = glGetError ()) != GL_NO_ERROR) + while ((gl_error = ctx->glGetError ()) != GL_NO_ERROR) ; _cogl_bind_gl_texture_transient (GL_TEXTURE_2D, gl_handle, TRUE); - if (glGetError () != GL_NO_ERROR) + if (ctx->glGetError () != GL_NO_ERROR) return COGL_INVALID_HANDLE; /* Obtain texture parameters @@ -421,16 +427,16 @@ cogl_texture_2d_new_from_foreign (CoglContext *ctx, #if HAVE_COGL_GL - GE( glGetTexLevelParameteriv (GL_TEXTURE_2D, 0, - GL_TEXTURE_COMPRESSED, - &gl_compressed) ); + GE( ctx, glGetTexLevelParameteriv (GL_TEXTURE_2D, 0, + GL_TEXTURE_COMPRESSED, + &gl_compressed) ); { GLint val; - GE( glGetTexLevelParameteriv (GL_TEXTURE_2D, 0, - GL_TEXTURE_INTERNAL_FORMAT, - &val) ); + GE( ctx, glGetTexLevelParameteriv (GL_TEXTURE_2D, 0, + GL_TEXTURE_INTERNAL_FORMAT, + &val) ); gl_int_format = val; } @@ -529,10 +535,10 @@ _cogl_egl_texture_2d_new_from_image (CoglContext *ctx, tex_2d->gl_texture, FALSE); - while ((gl_error = glGetError ()) != GL_NO_ERROR) + while ((gl_error = ctx->glGetError ()) != GL_NO_ERROR) ; ctx->glEGLImageTargetTexture2D (GL_TEXTURE_2D, image); - if (glGetError () != GL_NO_ERROR) + if (ctx->glGetError () != GL_NO_ERROR) { g_set_error (error, COGL_TEXTURE_ERROR, @@ -630,6 +636,8 @@ _cogl_texture_2d_copy_from_framebuffer (CoglHandle handle, { CoglTexture2D *tex_2d; + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + g_return_if_fail (cogl_is_texture_2d (handle)); tex_2d = COGL_TEXTURE_2D (handle); @@ -644,11 +652,11 @@ _cogl_texture_2d_copy_from_framebuffer (CoglHandle handle, tex_2d->gl_texture, tex_2d->is_foreign); - glCopyTexSubImage2D (GL_TEXTURE_2D, - 0, /* level */ - dst_x, dst_y, - src_x, src_y, - width, height); + ctx->glCopyTexSubImage2D (GL_TEXTURE_2D, + 0, /* level */ + dst_x, dst_y, + src_x, src_y, + width, height); tex_2d->mipmaps_dirty = TRUE; } @@ -721,6 +729,8 @@ _cogl_texture_2d_set_filters (CoglTexture *tex, { CoglTexture2D *tex_2d = COGL_TEXTURE_2D (tex); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + if (min_filter == tex_2d->min_filter && mag_filter == tex_2d->mag_filter) return; @@ -733,8 +743,8 @@ _cogl_texture_2d_set_filters (CoglTexture *tex, _cogl_bind_gl_texture_transient (GL_TEXTURE_2D, tex_2d->gl_texture, tex_2d->is_foreign); - GE( glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter) ); - GE( glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter) ); + GE( ctx, glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter) ); + GE( ctx, glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter) ); } static void @@ -760,16 +770,16 @@ _cogl_texture_2d_pre_paint (CoglTexture *tex, CoglTexturePrePaintFlags flags) #ifndef HAVE_COGL_GLES2 else { - GE( glTexParameteri (GL_TEXTURE_2D, - GL_GENERATE_MIPMAP, - GL_TRUE) ); - GE( glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, 1, 1, - tex_2d->first_pixel.gl_format, - tex_2d->first_pixel.gl_type, - tex_2d->first_pixel.data) ); - GE( glTexParameteri (GL_TEXTURE_2D, - GL_GENERATE_MIPMAP, - GL_FALSE) ); + GE( ctx, glTexParameteri (GL_TEXTURE_2D, + GL_GENERATE_MIPMAP, + GL_TRUE) ); + GE( ctx, glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, 1, 1, + tex_2d->first_pixel.gl_format, + tex_2d->first_pixel.gl_type, + tex_2d->first_pixel.data) ); + GE( ctx, glTexParameteri (GL_TEXTURE_2D, + GL_GENERATE_MIPMAP, + GL_FALSE) ); } #endif diff --git a/cogl/cogl-texture-3d.c b/cogl/cogl-texture-3d.c index 3803c2d8..7c111724 100644 --- a/cogl/cogl-texture-3d.c +++ b/cogl/cogl-texture-3d.c @@ -49,9 +49,6 @@ #define GL_TEXTURE_WRAP_R 0x8072 #endif -#define glTexImage3D ctx->glTexImage3D -#define glTexSubImage3D ctx->glTexSubImage3D - static void _cogl_texture_3d_free (CoglTexture3D *tex_3d); COGL_TEXTURE_DEFINE (Texture3D, texture_3d); @@ -140,6 +137,8 @@ _cogl_texture_3d_set_wrap_mode_parameters (CoglTexture *tex, { CoglTexture3D *tex_3d = COGL_TEXTURE_3D (tex); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + /* Only set the wrap mode if it's different from the current value to avoid too many GL calls. */ if (tex_3d->wrap_mode_s != wrap_mode_s || @@ -149,9 +148,15 @@ _cogl_texture_3d_set_wrap_mode_parameters (CoglTexture *tex, _cogl_bind_gl_texture_transient (GL_TEXTURE_3D, tex_3d->gl_texture, FALSE); - GE( glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, wrap_mode_s) ); - GE( glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, wrap_mode_t) ); - GE( glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, wrap_mode_p) ); + GE( ctx, glTexParameteri (GL_TEXTURE_3D, + GL_TEXTURE_WRAP_S, + wrap_mode_s) ); + GE( ctx, glTexParameteri (GL_TEXTURE_3D, + GL_TEXTURE_WRAP_T, + wrap_mode_t) ); + GE( ctx, glTexParameteri (GL_TEXTURE_3D, + GL_TEXTURE_WRAP_R, + wrap_mode_p) ); tex_3d->wrap_mode_s = wrap_mode_s; tex_3d->wrap_mode_t = wrap_mode_t; @@ -295,8 +300,8 @@ cogl_texture_3d_new_with_size (unsigned int width, _cogl_bind_gl_texture_transient (GL_TEXTURE_3D, tex_3d->gl_texture, FALSE); - GE( glTexImage3D (GL_TEXTURE_3D, 0, gl_intformat, - width, height, depth, 0, gl_format, gl_type, NULL) ); + GE( ctx, glTexImage3D (GL_TEXTURE_3D, 0, gl_intformat, + width, height, depth, 0, gl_format, gl_type, NULL) ); return _cogl_texture_3d_handle_new (tex_3d); } @@ -536,6 +541,8 @@ _cogl_texture_3d_set_filters (CoglTexture *tex, { CoglTexture3D *tex_3d = COGL_TEXTURE_3D (tex); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + if (min_filter == tex_3d->min_filter && mag_filter == tex_3d->mag_filter) return; @@ -548,8 +555,8 @@ _cogl_texture_3d_set_filters (CoglTexture *tex, _cogl_bind_gl_texture_transient (GL_TEXTURE_3D, tex_3d->gl_texture, FALSE); - GE( glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, mag_filter) ); - GE( glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, min_filter) ); + GE( ctx, glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, mag_filter) ); + GE( ctx, glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, min_filter) ); } static void @@ -574,23 +581,23 @@ _cogl_texture_3d_pre_paint (CoglTexture *tex, CoglTexturePrePaintFlags flags) #ifndef HAVE_COGL_GLES2 else { - GE( glTexParameteri (GL_TEXTURE_3D, - GL_GENERATE_MIPMAP, - GL_TRUE) ); - GE( glTexSubImage3D (GL_TEXTURE_3D, - 0, /* level */ - 0, /* xoffset */ - 0, /* yoffset */ - 0, /* zoffset */ - 1, /* width */ - 1, /* height */ - 1, /* depth */ - tex_3d->first_pixel.gl_format, - tex_3d->first_pixel.gl_type, - tex_3d->first_pixel.data) ); - GE( glTexParameteri (GL_TEXTURE_3D, - GL_GENERATE_MIPMAP, - GL_FALSE) ); + GE( ctx, glTexParameteri (GL_TEXTURE_3D, + GL_GENERATE_MIPMAP, + GL_TRUE) ); + GE( ctx, glTexSubImage3D (GL_TEXTURE_3D, + 0, /* level */ + 0, /* xoffset */ + 0, /* yoffset */ + 0, /* zoffset */ + 1, /* width */ + 1, /* height */ + 1, /* depth */ + tex_3d->first_pixel.gl_format, + tex_3d->first_pixel.gl_type, + tex_3d->first_pixel.data) ); + GE( ctx, glTexParameteri (GL_TEXTURE_3D, + GL_GENERATE_MIPMAP, + GL_FALSE) ); } #endif diff --git a/cogl/cogl-texture-rectangle.c b/cogl/cogl-texture-rectangle.c index 37bc93d9..dc8bb773 100644 --- a/cogl/cogl-texture-rectangle.c +++ b/cogl/cogl-texture-rectangle.c @@ -154,6 +154,8 @@ _cogl_texture_rectangle_set_wrap_mode_parameters (CoglTexture *tex, { CoglTextureRectangle *tex_rect = COGL_TEXTURE_RECTANGLE (tex); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + /* Only set the wrap mode if it's different from the current value to avoid too many GL calls. Texture rectangle doesn't make use of the r coordinate so we can ignore its wrap mode */ @@ -163,13 +165,13 @@ _cogl_texture_rectangle_set_wrap_mode_parameters (CoglTexture *tex, g_assert (can_use_wrap_mode (wrap_mode_s)); g_assert (can_use_wrap_mode (wrap_mode_t)); - GE( _cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB, - tex_rect->gl_texture, - tex_rect->is_foreign) ); - GE( glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, - GL_TEXTURE_WRAP_S, wrap_mode_s) ); - GE( glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, - GL_TEXTURE_WRAP_T, wrap_mode_t) ); + _cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB, + tex_rect->gl_texture, + tex_rect->is_foreign); + GE( ctx, glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, + GL_TEXTURE_WRAP_S, wrap_mode_s) ); + GE( ctx, glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, + GL_TEXTURE_WRAP_T, wrap_mode_t) ); tex_rect->wrap_mode_s = wrap_mode_s; tex_rect->wrap_mode_t = wrap_mode_t; @@ -251,6 +253,8 @@ _cogl_texture_rectangle_new_with_size (unsigned int width, GLenum gl_format; GLenum gl_type; + _COGL_GET_CONTEXT (ctx, COGL_INVALID_HANDLE); + /* Since no data, we need some internal format */ if (internal_format == COGL_PIXEL_FORMAT_ANY) internal_format = COGL_PIXEL_FORMAT_RGBA_8888_PRE; @@ -267,11 +271,11 @@ _cogl_texture_rectangle_new_with_size (unsigned int width, internal_format); _cogl_texture_driver_gen (GL_TEXTURE_RECTANGLE_ARB, 1, &tex_rect->gl_texture); - GE( _cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB, - tex_rect->gl_texture, - tex_rect->is_foreign) ); - GE( glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, gl_intformat, - width, height, 0, gl_format, gl_type, NULL) ); + _cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB, + tex_rect->gl_texture, + tex_rect->is_foreign); + GE( ctx, glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, gl_intformat, + width, height, 0, gl_format, gl_type, NULL) ); return _cogl_texture_rectangle_handle_new (tex_rect); } @@ -344,35 +348,37 @@ _cogl_texture_rectangle_new_from_foreign (GLuint gl_handle, GLenum gl_int_format = 0; CoglTextureRectangle *tex_rect; + _COGL_GET_CONTEXT (ctx, COGL_INVALID_HANDLE); + if (!_cogl_texture_driver_allows_foreign_gl_target (GL_TEXTURE_RECTANGLE_ARB)) return COGL_INVALID_HANDLE; /* Make sure it is a valid GL texture object */ - if (!glIsTexture (gl_handle)) + if (!ctx->glIsTexture (gl_handle)) return COGL_INVALID_HANDLE; /* Make sure binding succeeds */ - while ((gl_error = glGetError ()) != GL_NO_ERROR) + while ((gl_error = ctx->glGetError ()) != GL_NO_ERROR) ; _cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB, gl_handle, TRUE); - if (glGetError () != GL_NO_ERROR) + if (ctx->glGetError () != GL_NO_ERROR) return COGL_INVALID_HANDLE; /* Obtain texture parameters */ #if HAVE_COGL_GL - GE( glGetTexLevelParameteriv (GL_TEXTURE_RECTANGLE_ARB, 0, - GL_TEXTURE_COMPRESSED, - &gl_compressed) ); + GE( ctx, glGetTexLevelParameteriv (GL_TEXTURE_RECTANGLE_ARB, 0, + GL_TEXTURE_COMPRESSED, + &gl_compressed) ); { GLint val; - GE( glGetTexLevelParameteriv (GL_TEXTURE_RECTANGLE_ARB, 0, - GL_TEXTURE_INTERNAL_FORMAT, - &val) ); + GE( ctx, glGetTexLevelParameteriv (GL_TEXTURE_RECTANGLE_ARB, 0, + GL_TEXTURE_INTERNAL_FORMAT, + &val) ); gl_int_format = val; } @@ -499,6 +505,8 @@ _cogl_texture_rectangle_set_filters (CoglTexture *tex, { CoglTextureRectangle *tex_rect = COGL_TEXTURE_RECTANGLE (tex); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + if (min_filter == tex_rect->min_filter && mag_filter == tex_rect->mag_filter) return; @@ -511,13 +519,13 @@ _cogl_texture_rectangle_set_filters (CoglTexture *tex, tex_rect->mag_filter = mag_filter; /* Apply new filters to the texture */ - GE( _cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB, - tex_rect->gl_texture, - tex_rect->is_foreign) ); - GE( glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, - mag_filter) ); - GE( glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, - min_filter) ); + _cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB, + tex_rect->gl_texture, + tex_rect->is_foreign); + GE( ctx, glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, + mag_filter) ); + GE( ctx, glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, + min_filter) ); } static void @@ -580,6 +588,8 @@ _cogl_texture_rectangle_get_data (CoglTexture *tex, GLenum gl_format; GLenum gl_type; + _COGL_GET_CONTEXT (ctx, FALSE); + bpp = _cogl_get_format_bpp (format); _cogl_pixel_format_to_gl (format, @@ -589,9 +599,9 @@ _cogl_texture_rectangle_get_data (CoglTexture *tex, _cogl_texture_driver_prep_gl_for_pixels_download (rowstride, bpp); - GE( _cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB, - tex_rect->gl_texture, - tex_rect->is_foreign) ); + _cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB, + tex_rect->gl_texture, + tex_rect->is_foreign); return _cogl_texture_driver_gl_get_tex_image (GL_TEXTURE_RECTANGLE_ARB, gl_format, gl_type, diff --git a/cogl/cogl-texture.c b/cogl/cogl-texture.c index f1ff63dd..f2f0a3b5 100644 --- a/cogl/cogl-texture.c +++ b/cogl/cogl-texture.c @@ -250,27 +250,31 @@ _cogl_texture_prepare_for_upload (CoglBitmap *src_bmp, void _cogl_texture_prep_gl_alignment_for_pixels_upload (int pixels_rowstride) { + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + if (!(pixels_rowstride & 0x7)) - GE( glPixelStorei (GL_UNPACK_ALIGNMENT, 8) ); + GE( ctx, glPixelStorei (GL_UNPACK_ALIGNMENT, 8) ); else if (!(pixels_rowstride & 0x3)) - GE( glPixelStorei (GL_UNPACK_ALIGNMENT, 4) ); + GE( ctx, glPixelStorei (GL_UNPACK_ALIGNMENT, 4) ); else if (!(pixels_rowstride & 0x1)) - GE( glPixelStorei (GL_UNPACK_ALIGNMENT, 2) ); + GE( ctx, glPixelStorei (GL_UNPACK_ALIGNMENT, 2) ); else - GE( glPixelStorei (GL_UNPACK_ALIGNMENT, 1) ); + GE( ctx, glPixelStorei (GL_UNPACK_ALIGNMENT, 1) ); } void _cogl_texture_prep_gl_alignment_for_pixels_download (int pixels_rowstride) { + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + if (!(pixels_rowstride & 0x7)) - GE( glPixelStorei (GL_PACK_ALIGNMENT, 8) ); + GE( ctx, glPixelStorei (GL_PACK_ALIGNMENT, 8) ); else if (!(pixels_rowstride & 0x3)) - GE( glPixelStorei (GL_PACK_ALIGNMENT, 4) ); + GE( ctx, glPixelStorei (GL_PACK_ALIGNMENT, 4) ); else if (!(pixels_rowstride & 0x1)) - GE( glPixelStorei (GL_PACK_ALIGNMENT, 2) ); + GE( ctx, glPixelStorei (GL_PACK_ALIGNMENT, 2) ); else - GE( glPixelStorei (GL_PACK_ALIGNMENT, 1) ); + GE( ctx, glPixelStorei (GL_PACK_ALIGNMENT, 1) ); } /* FIXME: wrap modes should be set on pipelines not textures */ @@ -1119,10 +1123,10 @@ _cogl_texture_draw_and_read (CoglHandle handle, still doesn't seem to have an alpha buffer. This might be just a PowerVR issue. GLint r_bits, g_bits, b_bits, a_bits; - GE( glGetIntegerv (GL_ALPHA_BITS, &a_bits) ); - GE( glGetIntegerv (GL_RED_BITS, &r_bits) ); - GE( glGetIntegerv (GL_GREEN_BITS, &g_bits) ); - GE( glGetIntegerv (GL_BLUE_BITS, &b_bits) ); + GE( ctx, glGetIntegerv (GL_ALPHA_BITS, &a_bits) ); + GE( ctx, glGetIntegerv (GL_RED_BITS, &r_bits) ); + GE( ctx, glGetIntegerv (GL_GREEN_BITS, &g_bits) ); + GE( ctx, glGetIntegerv (GL_BLUE_BITS, &b_bits) ); printf ("R bits: %d\n", r_bits); printf ("G bits: %d\n", g_bits); printf ("B bits: %d\n", b_bits); diff --git a/cogl/cogl.c b/cogl/cogl.c index 67f1ed19..ea4d7c8b 100644 --- a/cogl/cogl.c +++ b/cogl/cogl.c @@ -47,10 +47,6 @@ #include "cogl-attribute-private.h" #include "cogl-framebuffer-private.h" -#ifdef HAVE_COGL_GL -#define glClientActiveTexture ctx->drv.pf_glClientActiveTexture -#endif - #ifdef COGL_GL_DEBUG /* GL error to string conversion */ static const struct { @@ -154,14 +150,14 @@ toggle_flag (CoglContext *ctx, { if (!(ctx->enable_flags & flag)) { - GE( glEnable (gl_flag) ); + GE( ctx, glEnable (gl_flag) ); ctx->enable_flags |= flag; return TRUE; } } else if (ctx->enable_flags & flag) { - GE( glDisable (gl_flag) ); + GE( ctx, glDisable (gl_flag) ); ctx->enable_flags &= ~flag; } @@ -191,14 +187,14 @@ toggle_client_flag (CoglContext *ctx, { if (!(ctx->enable_flags & flag)) { - GE( glEnableClientState (gl_flag) ); + GE( ctx, glEnableClientState (gl_flag) ); ctx->enable_flags |= flag; return TRUE; } } else if (ctx->enable_flags & flag) { - GE( glDisableClientState (gl_flag) ); + GE( ctx, glDisableClientState (gl_flag) ); ctx->enable_flags &= ~flag; } @@ -307,9 +303,9 @@ _cogl_flush_face_winding (void) { if (winding == COGL_FRONT_WINDING_CLOCKWISE) - GE (glFrontFace (GL_CW)); + GE (ctx, glFrontFace (GL_CW)); else - GE (glFrontFace (GL_CCW)); + GE (ctx, glFrontFace (GL_CCW)); ctx->flushed_front_winding = winding; } } @@ -574,9 +570,9 @@ _cogl_read_pixels_with_rowstride (int x, _cogl_texture_driver_prep_gl_for_pixels_download (4 * width, 4); - GE( glReadPixels (x, y, width, height, - GL_RGBA, GL_UNSIGNED_BYTE, - tmp_data) ); + GE( ctx, glReadPixels (x, y, width, height, + GL_RGBA, GL_UNSIGNED_BYTE, + tmp_data) ); /* CoglBitmap doesn't currently have a way to convert without allocating its own buffer so we have to copy the data @@ -604,7 +600,7 @@ _cogl_read_pixels_with_rowstride (int x, { _cogl_texture_driver_prep_gl_for_pixels_download (rowstride, bpp); - GE( glReadPixels (x, y, width, height, gl_format, gl_type, pixels) ); + GE( ctx, glReadPixels (x, y, width, height, gl_format, gl_type, pixels) ); /* Convert to the premult format specified by the caller in-place. This will do nothing if the premult status is already diff --git a/cogl/cogl2-path.c b/cogl/cogl2-path.c index 043ac37f..521bd1f4 100644 --- a/cogl/cogl2-path.c +++ b/cogl/cogl2-path.c @@ -381,15 +381,15 @@ _cogl_add_path_to_stencil_buffer (CoglPath *path, _cogl_pipeline_flush_gl_state (ctx->stencil_pipeline, FALSE, 0); - GE( glEnable (GL_STENCIL_TEST) ); + GE( ctx, glEnable (GL_STENCIL_TEST) ); - GE( glColorMask (FALSE, FALSE, FALSE, FALSE) ); - GE( glDepthMask (FALSE) ); + GE( ctx, glColorMask (FALSE, FALSE, FALSE, FALSE) ); + GE( ctx, glDepthMask (FALSE) ); if (merge) { - GE (glStencilMask (2)); - GE (glStencilFunc (GL_LEQUAL, 0x2, 0x6)); + GE (ctx, glStencilMask (2)); + GE (ctx, glStencilFunc (GL_LEQUAL, 0x2, 0x6)); } else { @@ -407,18 +407,18 @@ _cogl_add_path_to_stencil_buffer (CoglPath *path, else { /* Just clear the bounding box */ - GE( glStencilMask (~(GLuint) 0) ); - GE( glStencilOp (GL_ZERO, GL_ZERO, GL_ZERO) ); + GE( ctx, glStencilMask (~(GLuint) 0) ); + GE( ctx, glStencilOp (GL_ZERO, GL_ZERO, GL_ZERO) ); _cogl_rectangle_immediate (data->path_nodes_min.x, data->path_nodes_min.y, data->path_nodes_max.x, data->path_nodes_max.y); } - GE (glStencilMask (1)); - GE (glStencilFunc (GL_LEQUAL, 0x1, 0x3)); + GE (ctx, glStencilMask (1)); + GE (ctx, glStencilFunc (GL_LEQUAL, 0x1, 0x3)); } - GE (glStencilOp (GL_INVERT, GL_INVERT, GL_INVERT)); + GE (ctx, glStencilOp (GL_INVERT, GL_INVERT, GL_INVERT)); if (path->data->path_nodes->len >= 3) _cogl_path_fill_nodes (path); @@ -427,9 +427,9 @@ _cogl_add_path_to_stencil_buffer (CoglPath *path, { /* Now we have the new stencil buffer in bit 1 and the old stencil buffer in bit 0 so we need to intersect them */ - GE (glStencilMask (3)); - GE (glStencilFunc (GL_NEVER, 0x2, 0x3)); - GE (glStencilOp (GL_DECR, GL_DECR, GL_DECR)); + GE (ctx, glStencilMask (3)); + GE (ctx, glStencilFunc (GL_NEVER, 0x2, 0x3)); + GE (ctx, glStencilOp (GL_DECR, GL_DECR, GL_DECR)); /* Decrement all of the bits twice so that only pixels where the value is 3 will remain */ @@ -450,12 +450,12 @@ _cogl_add_path_to_stencil_buffer (CoglPath *path, _cogl_matrix_stack_pop (projection_stack); } - GE (glStencilMask (~(GLuint) 0)); - GE (glDepthMask (TRUE)); - GE (glColorMask (TRUE, TRUE, TRUE, TRUE)); + GE (ctx, glStencilMask (~(GLuint) 0)); + GE (ctx, glDepthMask (TRUE)); + GE (ctx, glColorMask (TRUE, TRUE, TRUE, TRUE)); - GE (glStencilFunc (GL_EQUAL, 0x1, 0x1)); - GE (glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP)); + GE (ctx, glStencilFunc (GL_EQUAL, 0x1, 0x1)); + GE (ctx, glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP)); /* restore the original pipeline */ cogl_pop_source (); diff --git a/cogl/driver/gl/cogl-gl.c b/cogl/driver/gl/cogl-gl.c index 906d7dad..a701cb78 100644 --- a/cogl/driver/gl/cogl-gl.c +++ b/cogl/driver/gl/cogl-gl.c @@ -40,8 +40,10 @@ _cogl_get_gl_version (int *major_out, int *minor_out) const char *version_string, *major_end, *minor_end; int major = 0, minor = 0; + _COGL_GET_CONTEXT (ctx, FALSE); + /* Get the OpenGL version number */ - if ((version_string = (const char *) glGetString (GL_VERSION)) == NULL) + if ((version_string = (const char *) ctx->glGetString (GL_VERSION)) == NULL) return FALSE; /* Extract the major number */ @@ -75,6 +77,8 @@ _cogl_gl_check_version (GError **error) int major, minor; const char *gl_extensions; + _COGL_GET_CONTEXT (ctx, FALSE); + if (!_cogl_get_gl_version (&major, &minor)) { g_set_error (error, @@ -88,7 +92,7 @@ _cogl_gl_check_version (GError **error) if (COGL_CHECK_GL_VERSION (major, minor, 1, 3)) return TRUE; - gl_extensions = (const char*) glGetString (GL_EXTENSIONS); + gl_extensions = (const char*) ctx->glGetString (GL_EXTENSIONS); /* OpenGL 1.2 is only supported if we have the multitexturing extension */ @@ -131,16 +135,25 @@ _cogl_gl_update_features (CoglContext *context) int num_stencil_bits = 0; int gl_major = 0, gl_minor = 0; + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + + /* We have to special case getting the pointer to the glGetString + function because we need to use it to determine what functions we + can expect */ + context->glGetString = + (void *) _cogl_get_proc_address (_cogl_context_get_winsys (context), + "glGetString"); + COGL_NOTE (WINSYS, "Checking features\n" " GL_VENDOR: %s\n" " GL_RENDERER: %s\n" " GL_VERSION: %s\n" " GL_EXTENSIONS: %s", - glGetString (GL_VENDOR), - glGetString (GL_RENDERER), - glGetString (GL_VERSION), - glGetString (GL_EXTENSIONS)); + ctx->glGetString (GL_VENDOR), + ctx->glGetString (GL_RENDERER), + ctx->glGetString (GL_VERSION), + ctx->glGetString (GL_EXTENSIONS)); _cogl_get_gl_version (&gl_major, &gl_minor); @@ -148,7 +161,7 @@ _cogl_gl_update_features (CoglContext *context) | COGL_FEATURE_UNSIGNED_INT_INDICES | COGL_FEATURE_DEPTH_RANGE); - gl_extensions = (const char *)glGetString (GL_EXTENSIONS); + gl_extensions = (const char *)ctx->glGetString (GL_EXTENSIONS); _cogl_feature_check_ext_functions (context, gl_major, @@ -172,12 +185,12 @@ _cogl_gl_update_features (CoglContext *context) } #endif - GE( glGetIntegerv (GL_STENCIL_BITS, &num_stencil_bits) ); + GE( ctx, glGetIntegerv (GL_STENCIL_BITS, &num_stencil_bits) ); /* We need at least three stencil bits to combine clips */ if (num_stencil_bits > 2) flags |= COGL_FEATURE_STENCIL_BUFFER; - GE( glGetIntegerv (GL_MAX_CLIP_PLANES, &max_clip_planes) ); + GE( ctx, glGetIntegerv (GL_MAX_CLIP_PLANES, &max_clip_planes) ); if (max_clip_planes >= 4) flags |= COGL_FEATURE_FOUR_CLIP_PLANES; diff --git a/cogl/driver/gl/cogl-texture-driver-gl.c b/cogl/driver/gl/cogl-texture-driver-gl.c index d5e71262..fdb938e8 100644 --- a/cogl/driver/gl/cogl-texture-driver-gl.c +++ b/cogl/driver/gl/cogl-texture-driver-gl.c @@ -46,9 +46,6 @@ #include <stdlib.h> #include <math.h> -#define glGenerateMipmap ctx->glGenerateMipmap -#define glTexImage3D ctx->glTexImage3D - void _cogl_texture_driver_gen (GLenum gl_target, GLsizei n, @@ -56,7 +53,9 @@ _cogl_texture_driver_gen (GLenum gl_target, { unsigned int i; - GE (glGenTextures (n, textures)); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + + GE (ctx, glGenTextures (n, textures)); for (i = 0; i < n; i++) { @@ -69,9 +68,9 @@ _cogl_texture_driver_gen (GLenum gl_target, case GL_TEXTURE_2D: case GL_TEXTURE_3D: /* GL_TEXTURE_MAG_FILTER defaults to GL_LINEAR, no need to set it */ - GE( glTexParameteri (gl_target, - GL_TEXTURE_MIN_FILTER, - GL_LINEAR) ); + GE( ctx, glTexParameteri (gl_target, + GL_TEXTURE_MIN_FILTER, + GL_LINEAR) ); break; case GL_TEXTURE_RECTANGLE_ARB: @@ -94,13 +93,16 @@ prep_gl_for_pixels_upload_full (int pixels_rowstride, int pixels_src_y, int pixels_bpp) { - GE( glPixelStorei (GL_UNPACK_ROW_LENGTH, pixels_rowstride / pixels_bpp) ); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + + GE( ctx, glPixelStorei (GL_UNPACK_ROW_LENGTH, + pixels_rowstride / pixels_bpp) ); - GE( glPixelStorei (GL_UNPACK_SKIP_PIXELS, pixels_src_x) ); - GE( glPixelStorei (GL_UNPACK_SKIP_ROWS, pixels_src_y) ); + GE( ctx, glPixelStorei (GL_UNPACK_SKIP_PIXELS, pixels_src_x) ); + GE( ctx, glPixelStorei (GL_UNPACK_SKIP_ROWS, pixels_src_y) ); if (cogl_features_available (COGL_FEATURE_TEXTURE_3D)) - GE( glPixelStorei (GL_UNPACK_IMAGE_HEIGHT, image_height) ); + GE( ctx, glPixelStorei (GL_UNPACK_IMAGE_HEIGHT, image_height) ); _cogl_texture_prep_gl_alignment_for_pixels_upload (pixels_rowstride); } @@ -121,13 +123,15 @@ prep_gl_for_pixels_download_full (int pixels_rowstride, int pixels_src_y, int pixels_bpp) { - GE( glPixelStorei (GL_PACK_ROW_LENGTH, pixels_rowstride / pixels_bpp) ); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + + GE( ctx, glPixelStorei (GL_PACK_ROW_LENGTH, pixels_rowstride / pixels_bpp) ); - GE( glPixelStorei (GL_PACK_SKIP_PIXELS, pixels_src_x) ); - GE( glPixelStorei (GL_PACK_SKIP_ROWS, pixels_src_y) ); + GE( ctx, glPixelStorei (GL_PACK_SKIP_PIXELS, pixels_src_x) ); + GE( ctx, glPixelStorei (GL_PACK_SKIP_ROWS, pixels_src_y) ); if (cogl_features_available (COGL_FEATURE_TEXTURE_3D)) - GE( glPixelStorei (GL_PACK_IMAGE_HEIGHT, image_height) ); + GE( ctx, glPixelStorei (GL_PACK_IMAGE_HEIGHT, image_height) ); _cogl_texture_prep_gl_alignment_for_pixels_download (pixels_rowstride); } @@ -156,6 +160,8 @@ _cogl_texture_driver_upload_subregion_to_gl (GLenum gl_target, guint8 *data; int bpp = _cogl_get_format_bpp (_cogl_bitmap_get_format (source_bmp)); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + data = _cogl_bitmap_bind (source_bmp, COGL_BUFFER_ACCESS_READ, 0); /* Setup gl alignment to match rowstride and top-left corner */ @@ -167,12 +173,12 @@ _cogl_texture_driver_upload_subregion_to_gl (GLenum gl_target, _cogl_bind_gl_texture_transient (gl_target, gl_handle, is_foreign); - GE( glTexSubImage2D (gl_target, 0, - dst_x, dst_y, - width, height, - source_gl_format, - source_gl_type, - data) ); + GE( ctx, glTexSubImage2D (gl_target, 0, + dst_x, dst_y, + width, height, + source_gl_format, + source_gl_type, + data) ); _cogl_bitmap_unbind (source_bmp); } @@ -189,6 +195,8 @@ _cogl_texture_driver_upload_to_gl (GLenum gl_target, guint8 *data; int bpp = _cogl_get_format_bpp (_cogl_bitmap_get_format (source_bmp)); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + data = _cogl_bitmap_bind (source_bmp, COGL_BUFFER_ACCESS_READ, 0); /* Setup gl alignment to match rowstride and top-left corner */ @@ -197,14 +205,14 @@ _cogl_texture_driver_upload_to_gl (GLenum gl_target, _cogl_bind_gl_texture_transient (gl_target, gl_handle, is_foreign); - GE( glTexImage2D (gl_target, 0, - internal_gl_format, - _cogl_bitmap_get_width (source_bmp), - _cogl_bitmap_get_height (source_bmp), - 0, - source_gl_format, - source_gl_type, - data) ); + GE( ctx, glTexImage2D (gl_target, 0, + internal_gl_format, + _cogl_bitmap_get_width (source_bmp), + _cogl_bitmap_get_height (source_bmp), + 0, + source_gl_format, + source_gl_type, + data) ); _cogl_bitmap_unbind (source_bmp); } @@ -235,16 +243,16 @@ _cogl_texture_driver_upload_to_gl_3d (GLenum gl_target, _cogl_bind_gl_texture_transient (gl_target, gl_handle, is_foreign); - GE( glTexImage3D (gl_target, - 0, /* level */ - internal_gl_format, - _cogl_bitmap_get_width (source_bmp), - height, - depth, - 0, - source_gl_format, - source_gl_type, - data) ); + GE( ctx, glTexImage3D (gl_target, + 0, /* level */ + internal_gl_format, + _cogl_bitmap_get_width (source_bmp), + height, + depth, + 0, + source_gl_format, + source_gl_type, + data) ); _cogl_bitmap_unbind (source_bmp); } @@ -255,11 +263,13 @@ _cogl_texture_driver_gl_get_tex_image (GLenum gl_target, GLenum dest_gl_type, guint8 *dest) { - GE (glGetTexImage (gl_target, - 0, /* level */ - dest_gl_format, - dest_gl_type, - (GLvoid *)dest)); + _COGL_GET_CONTEXT (ctx, FALSE); + + GE (ctx, glGetTexImage (gl_target, + 0, /* level */ + dest_gl_format, + dest_gl_type, + (GLvoid *)dest)); return TRUE; } @@ -283,12 +293,12 @@ _cogl_texture_driver_size_supported_3d (GLenum gl_target, return FALSE; /* Proxy texture allows for a quick check for supported size */ - GE( glTexImage3D (proxy_target, 0, GL_RGBA, - width, height, depth, 0 /* border */, - gl_format, gl_type, NULL) ); + GE( ctx, glTexImage3D (proxy_target, 0, GL_RGBA, + width, height, depth, 0 /* border */, + gl_format, gl_type, NULL) ); - GE( glGetTexLevelParameteriv (proxy_target, 0, - GL_TEXTURE_WIDTH, &new_width) ); + GE( ctx, glGetTexLevelParameteriv (proxy_target, 0, + GL_TEXTURE_WIDTH, &new_width) ); return new_width != 0; } @@ -303,6 +313,8 @@ _cogl_texture_driver_size_supported (GLenum gl_target, GLenum proxy_target; GLint new_width = 0; + _COGL_GET_CONTEXT (ctx, FALSE); + if (gl_target == GL_TEXTURE_2D) proxy_target = GL_PROXY_TEXTURE_2D; #if HAVE_COGL_GL @@ -314,12 +326,12 @@ _cogl_texture_driver_size_supported (GLenum gl_target, return FALSE; /* Proxy texture allows for a quick check for supported size */ - GE( glTexImage2D (proxy_target, 0, GL_RGBA, - width, height, 0 /* border */, - gl_format, gl_type, NULL) ); + GE( ctx, glTexImage2D (proxy_target, 0, GL_RGBA, + width, height, 0 /* border */, + gl_format, gl_type, NULL) ); - GE( glGetTexLevelParameteriv (proxy_target, 0, - GL_TEXTURE_WIDTH, &new_width) ); + GE( ctx, glGetTexLevelParameteriv (proxy_target, 0, + GL_TEXTURE_WIDTH, &new_width) ); return new_width != 0; } @@ -329,11 +341,13 @@ _cogl_texture_driver_try_setting_gl_border_color ( GLuint gl_target, const GLfloat *transparent_color) { + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + /* Use a transparent border color so that we can leave the color buffer alone when using texture co-ordinates outside of the texture */ - GE( glTexParameterfv (gl_target, GL_TEXTURE_BORDER_COLOR, - transparent_color) ); + GE( ctx, glTexParameterfv (gl_target, GL_TEXTURE_BORDER_COLOR, + transparent_color) ); } gboolean @@ -504,7 +518,7 @@ _cogl_texture_driver_gl_generate_mipmaps (GLenum gl_target) { _COGL_GET_CONTEXT (ctx, NO_RETVAL); - GE( glGenerateMipmap (gl_target) ); + GE( ctx, glGenerateMipmap (gl_target) ); } CoglPixelFormat diff --git a/cogl/driver/gles/cogl-gles.c b/cogl/driver/gles/cogl-gles.c index bf11194a..0d97d2b6 100644 --- a/cogl/driver/gles/cogl-gles.c +++ b/cogl/driver/gles/cogl-gles.c @@ -54,18 +54,25 @@ _cogl_gl_update_features (CoglContext *context) #endif int num_stencil_bits = 0; + /* We have to special case getting the pointer to the glGetString + function because we need to use it to determine what functions we + can expect */ + context->glGetString = + (void *) _cogl_get_proc_address (_cogl_context_get_winsys (context), + "glGetString"); + COGL_NOTE (WINSYS, "Checking features\n" " GL_VENDOR: %s\n" " GL_RENDERER: %s\n" " GL_VERSION: %s\n" " GL_EXTENSIONS: %s", - glGetString (GL_VENDOR), - glGetString (GL_RENDERER), - glGetString (GL_VERSION), - glGetString (GL_EXTENSIONS)); + context->glGetString (GL_VENDOR), + context->glGetString (GL_RENDERER), + context->glGetString (GL_VERSION), + context->glGetString (GL_EXTENSIONS)); - gl_extensions = (const char*) glGetString (GL_EXTENSIONS); + gl_extensions = (const char*) context->glGetString (GL_EXTENSIONS); _cogl_feature_check_ext_functions (context, -1 /* GL major version */, @@ -78,13 +85,13 @@ _cogl_gl_update_features (CoglContext *context) #endif ); - GE( glGetIntegerv (GL_STENCIL_BITS, &num_stencil_bits) ); + GE( context, glGetIntegerv (GL_STENCIL_BITS, &num_stencil_bits) ); /* We need at least three stencil bits to combine clips */ if (num_stencil_bits > 2) flags |= COGL_FEATURE_STENCIL_BUFFER; #ifndef HAVE_COGL_GLES2 - GE( glGetIntegerv (GL_MAX_CLIP_PLANES, &max_clip_planes) ); + GE( context, glGetIntegerv (GL_MAX_CLIP_PLANES, &max_clip_planes) ); if (max_clip_planes >= 4) flags |= COGL_FEATURE_FOUR_CLIP_PLANES; #endif diff --git a/cogl/driver/gles/cogl-texture-driver-gles.c b/cogl/driver/gles/cogl-texture-driver-gles.c index a8fecbd8..9a3f61bd 100644 --- a/cogl/driver/gles/cogl-texture-driver-gles.c +++ b/cogl/driver/gles/cogl-texture-driver-gles.c @@ -46,9 +46,6 @@ #include <stdlib.h> #include <math.h> -#define glTexImage3D ctx->glTexImage3D -#define glTexSubImage3D ctx->glTexSubImage3D - #ifndef GL_TEXTURE_3D #define GL_TEXTURE_3D 0x806F #endif @@ -63,7 +60,9 @@ _cogl_texture_driver_gen (GLenum gl_target, { unsigned int i; - GE (glGenTextures (n, textures)); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + + GE (ctx, glGenTextures (n, textures)); for (i = 0; i < n; i++) { @@ -74,7 +73,9 @@ _cogl_texture_driver_gen (GLenum gl_target, case GL_TEXTURE_2D: case GL_TEXTURE_3D: /* GL_TEXTURE_MAG_FILTER defaults to GL_LINEAR, no need to set it */ - GE( glTexParameteri (gl_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR) ); + GE( ctx, glTexParameteri (gl_target, + GL_TEXTURE_MIN_FILTER, + GL_LINEAR) ); break; default: @@ -143,6 +144,8 @@ _cogl_texture_driver_upload_subregion_to_gl (GLenum gl_target, CoglBitmap *slice_bmp; int rowstride; + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + /* If we are copying a sub region of the source bitmap then we need to copy it because GLES does not support GL_UNPACK_ROW_LENGTH */ if (src_x != 0 || src_y != 0 || @@ -177,12 +180,12 @@ _cogl_texture_driver_upload_subregion_to_gl (GLenum gl_target, _cogl_bind_gl_texture_transient (gl_target, gl_handle, is_foreign); - GE( glTexSubImage2D (gl_target, 0, - dst_x, dst_y, - width, height, - source_gl_format, - source_gl_type, - data) ); + GE( ctx, glTexSubImage2D (gl_target, 0, + dst_x, dst_y, + width, height, + source_gl_format, + source_gl_type, + data) ); _cogl_bitmap_unbind (slice_bmp); @@ -205,6 +208,8 @@ _cogl_texture_driver_upload_to_gl (GLenum gl_target, CoglBitmap *bmp; guint8 *data; + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + bmp = prepare_bitmap_alignment_for_upload (source_bmp); rowstride = _cogl_bitmap_get_rowstride (bmp); @@ -215,13 +220,13 @@ _cogl_texture_driver_upload_to_gl (GLenum gl_target, data = _cogl_bitmap_bind (bmp, COGL_BUFFER_ACCESS_READ, 0); - GE( glTexImage2D (gl_target, 0, - internal_gl_format, - bmp_width, bmp_height, - 0, - source_gl_format, - source_gl_type, - data) ); + GE( ctx, glTexImage2D (gl_target, 0, + internal_gl_format, + bmp_width, bmp_height, + 0, + source_gl_format, + source_gl_type, + data) ); _cogl_bitmap_unbind (bmp); @@ -264,16 +269,16 @@ _cogl_texture_driver_upload_to_gl_3d (GLenum gl_target, /* Initialize the texture with empty data and then upload each image with a sub-region update */ - GE( glTexImage3D (gl_target, - 0, /* level */ - internal_gl_format, - bmp_width, - height, - depth, - 0, - source_gl_format, - source_gl_type, - NULL) ); + GE( ctx, glTexImage3D (gl_target, + 0, /* level */ + internal_gl_format, + bmp_width, + height, + depth, + 0, + source_gl_format, + source_gl_type, + NULL) ); bmp = _cogl_bitmap_new_from_data (g_malloc (bpp * bmp_width * height), _cogl_bitmap_get_format (source_bmp), @@ -295,17 +300,17 @@ _cogl_texture_driver_upload_to_gl_3d (GLenum gl_target, data = _cogl_bitmap_bind (bmp, COGL_BUFFER_ACCESS_READ, 0); - GE( glTexSubImage3D (gl_target, - 0, /* level */ - 0, /* xoffset */ - 0, /* yoffset */ - i, /* zoffset */ - bmp_width, /* width */ - height, /* height */ - 1, /* depth */ - source_gl_format, - source_gl_type, - data) ); + GE( ctx, glTexSubImage3D (gl_target, + 0, /* level */ + 0, /* xoffset */ + 0, /* yoffset */ + i, /* zoffset */ + bmp_width, /* width */ + height, /* height */ + 1, /* depth */ + source_gl_format, + source_gl_type, + data) ); _cogl_bitmap_unbind (bmp); } @@ -318,16 +323,16 @@ _cogl_texture_driver_upload_to_gl_3d (GLenum gl_target, _cogl_texture_driver_prep_gl_for_pixels_upload (rowstride, bpp); - GE( glTexImage3D (gl_target, - 0, /* level */ - internal_gl_format, - bmp_width, - height, - depth, - 0, - source_gl_format, - source_gl_type, - data) ); + GE( ctx, glTexImage3D (gl_target, + 0, /* level */ + internal_gl_format, + bmp_width, + height, + depth, + 0, + source_gl_format, + source_gl_type, + data) ); _cogl_bitmap_unbind (source_bmp); } @@ -355,10 +360,12 @@ _cogl_texture_driver_size_supported_3d (GLenum gl_target, { GLint max_size; + _COGL_GET_CONTEXT (ctx, FALSE); + /* GLES doesn't support a proxy texture target so let's at least check whether the size is greater than GL_MAX_3D_TEXTURE_SIZE_OES */ - GE( glGetIntegerv (GL_MAX_3D_TEXTURE_SIZE_OES, &max_size) ); + GE( ctx, glGetIntegerv (GL_MAX_3D_TEXTURE_SIZE_OES, &max_size) ); return width <= max_size && height <= max_size && depth <= max_size; } @@ -372,9 +379,11 @@ _cogl_texture_driver_size_supported (GLenum gl_target, { GLint max_size; + _COGL_GET_CONTEXT (ctx, FALSE); + /* GLES doesn't support a proxy texture target so let's at least check whether the size is greater than GL_MAX_TEXTURE_SIZE */ - GE( glGetIntegerv (GL_MAX_TEXTURE_SIZE, &max_size) ); + GE( ctx, glGetIntegerv (GL_MAX_TEXTURE_SIZE, &max_size) ); return width <= max_size && height <= max_size; } @@ -491,7 +500,9 @@ void _cogl_texture_driver_gl_generate_mipmaps (GLenum gl_target) { #ifdef HAVE_COGL_GLES2 - GE( glGenerateMipmap (gl_target) ); + _COGL_GET_CONTEXT (ctx, NO_RETVAL); + + GE( ctx, glGenerateMipmap (gl_target) ); #endif } diff --git a/cogl/winsys/cogl-winsys-glx.c b/cogl/winsys/cogl-winsys-glx.c index 1b41fde5..80c3767b 100644 --- a/cogl/winsys/cogl-winsys-glx.c +++ b/cogl/winsys/cogl-winsys-glx.c @@ -1116,7 +1116,7 @@ _cogl_winsys_onscreen_swap_region (CoglOnscreen *onscreen, * additional extension so we can report the limited region of * the window damage to X/compositors. */ - glFinish (); + context->glFinish (); if (have_counter && can_wait) { @@ -1148,7 +1148,7 @@ _cogl_winsys_onscreen_swap_region (CoglOnscreen *onscreen, int i; /* XXX: checkout how this state interacts with the code to use * glBlitFramebuffer in Neil's texture atlasing branch */ - glDrawBuffer (GL_FRONT); + context->glDrawBuffer (GL_FRONT); for (i = 0; i < n_rectangles; i++) { int *rect = &rectangles[4 * i]; @@ -1158,7 +1158,7 @@ _cogl_winsys_onscreen_swap_region (CoglOnscreen *onscreen, rect[0], rect[1], x2, y2, GL_COLOR_BUFFER_BIT, GL_NEAREST); } - glDrawBuffer (GL_BACK); + context->glDrawBuffer (GL_BACK); } /* NB: unlike glXSwapBuffers, glXCopySubBuffer and @@ -1166,7 +1166,7 @@ _cogl_winsys_onscreen_swap_region (CoglOnscreen *onscreen, * have to flush ourselves if we want the request to complete in * a finite amount of time since otherwise the driver can batch * the command indefinitely. */ - glFlush (); + context->glFlush (); /* NB: It's important we save the counter we read before acting on * the swap request since if we are mixing and matching different @@ -1237,7 +1237,7 @@ _cogl_winsys_onscreen_swap_buffers (CoglOnscreen *onscreen) * obviously does not happen when we use _GLX_SWAP and let * the driver do the right thing */ - glFinish (); + context->glFinish (); if (have_counter && can_wait) { @@ -1844,7 +1844,7 @@ _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap, COGL_NOTE (TEXTURE_PIXMAP, "Rebinding GLXPixmap for %p", tex_pixmap); - GE( _cogl_bind_gl_texture_transient (gl_target, gl_handle, FALSE) ); + _cogl_bind_gl_texture_transient (gl_target, gl_handle, FALSE); if (glx_tex_pixmap->pixmap_bound) glx_renderer->pf_glXReleaseTexImage (xlib_renderer->xdpy, diff --git a/cogl/winsys/cogl-winsys-wgl.c b/cogl/winsys/cogl-winsys-wgl.c index acee20da..fef73134 100644 --- a/cogl/winsys/cogl-winsys-wgl.c +++ b/cogl/winsys/cogl-winsys-wgl.c @@ -534,7 +534,7 @@ get_wgl_extensions_string (HDC dc) extensions isn't supported then we can at least fake it to support the swap control extension */ if (_cogl_check_extension ("WGL_EXT_swap_control", - (char *) glGetString (GL_EXTENSIONS))) + (char *) ctx->glGetString (GL_EXTENSIONS))) return "WGL_EXT_swap_control"; return NULL; |