From 34658ea05787201dd6caaa21fb60c2859fcd765b Mon Sep 17 00:00:00 2001 From: Robert Bragg Date: Sat, 11 May 2013 18:15:25 +0100 Subject: [PATCH] generalize driver description and selection This adds a table of driver descriptions to cogl-renderer.c in order of preference and when choosing what driver to use we now iterate the table instead of repeating boilerplate checks. For handling the "default driver" that can be specified when building cogl and handling driver overrides there is a foreach_driver_description() that will make sure to iterate the default driver first or if an override has been set then nothing but the override will be considered. This patch introduces some driver flags that let us broadly categorize what kind of GL driver we are currently running on. Since there are numerous OpenGL apis with different broad feature sets and new apis may be introduced in the future by Khronos then we should tend to avoid using the driver id to do runtime feature checking. These flags provide a more stable quantity for broad feature checks. Reviewed-by: Neil Roberts (cherry picked from commit e07d0fc7441dddc3f0a2bc33a6a37d62ddc3efc0) --- cogl/cogl-context.c | 4 +- cogl/cogl-glsl-shader.c | 2 +- cogl/cogl-matrix-stack.c | 4 +- cogl/cogl-private.h | 38 +- cogl/cogl-renderer-private.h | 1 + cogl/cogl-renderer.c | 362 ++++++++++++------ cogl/cogl-texture-3d.c | 2 +- cogl/driver/gl/cogl-attribute-gl.c | 8 +- cogl/driver/gl/cogl-pipeline-fragend-glsl.c | 3 +- cogl/driver/gl/cogl-pipeline-opengl.c | 16 +- cogl/driver/gl/cogl-pipeline-progend-fixed.c | 2 +- cogl/driver/gl/gl/cogl-driver-gl.c | 2 +- .../gl/gl/cogl-pipeline-progend-fixed-arbfp.c | 2 +- cogl/driver/gl/gles/cogl-driver-gles.c | 2 +- 14 files changed, 302 insertions(+), 146 deletions(-) diff --git a/cogl/cogl-context.c b/cogl/cogl-context.c index 12f51a2d6..fb3e2569d 100644 --- a/cogl/cogl-context.c +++ b/cogl/cogl-context.c @@ -219,6 +219,8 @@ cogl_context_new (CoglDisplay *display, context->driver_vtable = display->renderer->driver_vtable; context->texture_driver = display->renderer->texture_driver; + context->private_feature_flags |= display->renderer->private_feature_flags; + winsys = _cogl_context_get_winsys (context); if (!winsys->context_init (context, error)) { @@ -477,7 +479,7 @@ cogl_context_new (CoglDisplay *display, pipeline to track whether any layers have point sprite coords enabled. We don't need to do this for GL3 or GLES2 because point sprites are handled using a builtin varying in the shader. */ - if ((context->private_feature_flags & COGL_PRIVATE_FEATURE_FIXED_FUNCTION) && + if ((context->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED) && cogl_has_feature (context, COGL_FEATURE_ID_POINT_SPRITE)) GE (context, glEnable (GL_POINT_SPRITE)); diff --git a/cogl/cogl-glsl-shader.c b/cogl/cogl-glsl-shader.c index 3b2764ac7..d7779d896 100644 --- a/cogl/cogl-glsl-shader.c +++ b/cogl/cogl-glsl-shader.c @@ -97,7 +97,7 @@ _cogl_glsl_shader_set_source_with_boilerplate (CoglContext *ctx, lengths[count++] = -1; } - if (ctx->driver == COGL_DRIVER_GLES2 && + if (ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_EMBEDDED && cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_3D)) { static const char texture_3d_extension[] = diff --git a/cogl/cogl-matrix-stack.c b/cogl/cogl-matrix-stack.c index 37cf0c6f0..877086e34 100644 --- a/cogl/cogl-matrix-stack.c +++ b/cogl/cogl-matrix-stack.c @@ -816,7 +816,7 @@ _cogl_matrix_flush_to_gl_builtin (CoglContext *ctx, CoglMatrix *matrix, CoglMatrixMode mode) { - g_assert ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_FIXED_FUNCTION)); + g_assert ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED)); #if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES) if (ctx->flushed_matrix_mode != mode) @@ -856,7 +856,7 @@ _cogl_matrix_entry_flush_to_gl_builtins (CoglContext *ctx, CoglFramebuffer *framebuffer, CoglBool disable_flip) { - g_assert ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_FIXED_FUNCTION)); + g_assert ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED)); #if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES) { diff --git a/cogl/cogl-private.h b/cogl/cogl-private.h index eb3a3dddd..6bc51eae8 100644 --- a/cogl/cogl-private.h +++ b/cogl/cogl-private.h @@ -44,25 +44,31 @@ typedef enum COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_BGRA8888 = 1L<<8, COGL_PRIVATE_FEATURE_UNPACK_SUBIMAGE = 1L<<9, COGL_PRIVATE_FEATURE_SAMPLER_OBJECTS = 1L<<10, - COGL_PRIVATE_FEATURE_FIXED_FUNCTION = 1L<<11, - COGL_PRIVATE_FEATURE_READ_PIXELS_ANY_FORMAT = 1L<<12, - COGL_PRIVATE_FEATURE_ANY_GL = 1L<<13, - COGL_PRIVATE_FEATURE_ALPHA_TEST = 1L<<14, - COGL_PRIVATE_FEATURE_FORMAT_CONVERSION = 1L<<15, - COGL_PRIVATE_FEATURE_QUADS = 1L<<16, - COGL_PRIVATE_FEATURE_BLEND_CONSTANT = 1L<<17, - COGL_PRIVATE_FEATURE_QUERY_FRAMEBUFFER_BITS = 1L<<18, - COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM = 1L<<19, - COGL_PRIVATE_FEATURE_QUERY_TEXTURE_PARAMETERS = 1L<<20, - COGL_PRIVATE_FEATURE_ALPHA_TEXTURES = 1L<<21, - COGL_PRIVATE_FEATURE_TEXTURE_SWIZZLE = 1L<<22, - COGL_PRIVATE_FEATURE_TEXTURE_MAX_LEVEL = 1L<<23, - COGL_PRIVATE_FEATURE_OES_EGL_SYNC = 1L<<24, + COGL_PRIVATE_FEATURE_READ_PIXELS_ANY_FORMAT = 1L<<11, + COGL_PRIVATE_FEATURE_ALPHA_TEST = 1L<<12, + COGL_PRIVATE_FEATURE_FORMAT_CONVERSION = 1L<<13, + COGL_PRIVATE_FEATURE_QUADS = 1L<<14, + COGL_PRIVATE_FEATURE_BLEND_CONSTANT = 1L<<15, + COGL_PRIVATE_FEATURE_QUERY_FRAMEBUFFER_BITS = 1L<<16, + COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM = 1L<<17, + COGL_PRIVATE_FEATURE_QUERY_TEXTURE_PARAMETERS = 1L<<18, + COGL_PRIVATE_FEATURE_ALPHA_TEXTURES = 1L<<19, + COGL_PRIVATE_FEATURE_TEXTURE_SWIZZLE = 1L<<20, + COGL_PRIVATE_FEATURE_TEXTURE_MAX_LEVEL = 1L<<21, + COGL_PRIVATE_FEATURE_ARBFP = 1L<<22, + COGL_PRIVATE_FEATURE_OES_EGL_SYNC = 1L<<23, /* If this is set then the winsys is responsible for queueing dirty * events. Otherwise a dirty event will be queued when the onscreen * is first allocated or when it is shown or resized */ - COGL_PRIVATE_FEATURE_DIRTY_EVENTS = 1L<<25, - COGL_PRIVATE_FEATURE_ENABLE_PROGRAM_POINT_SIZE = 1L<<26 + COGL_PRIVATE_FEATURE_DIRTY_EVENTS = 1L<<24, + COGL_PRIVATE_FEATURE_ENABLE_PROGRAM_POINT_SIZE = 1L<<25, + /* These features let us avoid conditioning code based on the exact + * driver being used and instead check for broad opengl feature + * sets that can be shared by several GL apis */ + COGL_PRIVATE_FEATURE_ANY_GL = 1L<<26, + COGL_PRIVATE_FEATURE_GL_FIXED = 1L<<27, + COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE = 1L<<28, + COGL_PRIVATE_FEATURE_GL_EMBEDDED = 1L<<29 } CoglPrivateFeatureFlags; /* Sometimes when evaluating pipelines, either during comparisons or diff --git a/cogl/cogl-renderer-private.h b/cogl/cogl-renderer-private.h index 3e2601f67..9e4b339e0 100644 --- a/cogl/cogl-renderer-private.h +++ b/cogl/cogl-renderer-private.h @@ -70,6 +70,7 @@ struct _CoglRenderer #endif CoglDriver driver; + CoglPrivateFeatureFlags private_feature_flags; #ifndef HAVE_DIRECTLY_LINKED_GL_LIBRARY GModule *libgl_module; #endif diff --git a/cogl/cogl-renderer.c b/cogl/cogl-renderer.c index 41b1eaa4f..6360dafe2 100644 --- a/cogl/cogl-renderer.c +++ b/cogl/cogl-renderer.c @@ -90,6 +90,83 @@ extern const CoglDriverVtable _cogl_driver_gles; extern const CoglDriverVtable _cogl_driver_nop; +typedef struct _CoglDriverDescription +{ + CoglDriver id; + const char *name; + CoglRendererConstraint constraints; + CoglPrivateFeatureFlags private_feature_flags; + const CoglDriverVtable *vtable; + const CoglTextureDriver *texture_driver; + const char *libgl_name; +} CoglDriverDescription; + +_COGL_STATIC_ASSERT(sizeof (CoglPrivateFeatureFlags) == + sizeof (unsigned long), + "Private feature flags don't fit in long"); + +static CoglDriverDescription _cogl_drivers[] = +{ +#ifdef HAVE_COGL_GL + { + COGL_DRIVER_GL, + "gl", + 0, + COGL_PRIVATE_FEATURE_ANY_GL | + COGL_PRIVATE_FEATURE_GL_FIXED | + COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE, + &_cogl_driver_gl, + &_cogl_texture_driver_gl, + COGL_GL_LIBNAME, + }, + { + COGL_DRIVER_GL3, + "gl3", + 0, + COGL_PRIVATE_FEATURE_ANY_GL | + COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE, + &_cogl_driver_gl, + &_cogl_texture_driver_gl, + COGL_GL_LIBNAME, + }, +#endif +#ifdef HAVE_COGL_GLES2 + { + COGL_DRIVER_GLES2, + "gles2", + COGL_RENDERER_CONSTRAINT_SUPPORTS_COGL_GLES2, + COGL_PRIVATE_FEATURE_ANY_GL | + COGL_PRIVATE_FEATURE_GL_EMBEDDED | + COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE, + &_cogl_driver_gles, + &_cogl_texture_driver_gles, + COGL_GLES2_LIBNAME, + }, +#endif +#ifdef HAVE_COGL_GLES + { + COGL_DRIVER_GLES1, + "gles1", + 0, + COGL_PRIVATE_FEATURE_ANY_GL | + COGL_PRIVATE_FEATURE_GL_EMBEDDED | + COGL_PRIVATE_FEATURE_GL_FIXED, + &_cogl_driver_gles, + &_cogl_texture_driver_gles, + COGL_GLES1_LIBNAME, + }, +#endif + { + COGL_DRIVER_NOP, + "nop", + 0, /* constraints satisfied */ + 0, /* flags */ + &_cogl_driver_nop, + NULL, /* texture driver */ + NULL /* libgl_name */ + } +}; + static CoglWinsysVtableGetter _cogl_winsys_vtable_getters[] = { #ifdef COGL_HAS_GLX_SUPPORT @@ -263,111 +340,206 @@ cogl_renderer_check_onscreen_template (CoglRenderer *renderer, return TRUE; } +typedef CoglBool (*DriverCallback) (CoglDriverDescription *description, + void *user_data); + +static void +foreach_driver_description (CoglDriver driver_override, + DriverCallback callback, + void *user_data) +{ +#ifdef COGL_DEFAULT_DRIVER + const CoglDriverDescription *default_driver = NULL; +#endif + int i; + + if (driver_override != COGL_DRIVER_ANY) + { + for (i = 0; i < G_N_ELEMENTS (_cogl_drivers); i++) + { + if (_cogl_drivers[i].id == driver_override) + { + callback (&_cogl_drivers[i], user_data); + return; + } + } + + g_warn_if_reached (); + return; + } + +#ifdef COGL_DEFAULT_DRIVER + for (i = 0; i < G_N_ELEMENTS (_cogl_drivers); i++) + { + const CoglDriverDescription *desc = &_cogl_drivers[i]; + if (g_ascii_strcasecmp (desc->name, COGL_DEFAULT_DRIVER) == 0) + { + default_driver = desc; + break; + } + } + + if (default_driver) + { + if (!callback (default_driver, user_data)) + return; + } +#endif + + for (i = 0; i < G_N_ELEMENTS (_cogl_drivers); i++) + { +#ifdef COGL_DEFAULT_DRIVER + if (&_cogl_drivers[i] == default_driver) + continue; +#endif + + if (!callback (&_cogl_drivers[i], user_data)) + return; + } +} + +static CoglDriver +driver_name_to_id (const char *name) +{ + int i; + + for (i = 0; i < G_N_ELEMENTS (_cogl_drivers); i++) + { + if (g_ascii_strcasecmp (_cogl_drivers[i].name, name) == 0) + return _cogl_drivers[i].id; + } + + return COGL_DRIVER_ANY; +} + +static const char * +driver_id_to_name (CoglDriver id) +{ + switch (id) + { + case COGL_DRIVER_GL: + return "gl"; + case COGL_DRIVER_GL3: + return "gl3"; + case COGL_DRIVER_GLES1: + return "gles1"; + case COGL_DRIVER_GLES2: + return "gles2"; + case COGL_DRIVER_NOP: + return "nop"; + case COGL_DRIVER_ANY: + g_warn_if_reached (); + return "any"; + } + + g_warn_if_reached (); + return "unknown"; +} + +typedef struct _SatisfyConstraintsState +{ + GList *constraints; + const CoglDriverDescription *driver_description; +} SatisfyConstraintsState; + +static CoglBool +satisfy_constraints (CoglDriverDescription *description, + void *user_data) +{ + SatisfyConstraintsState *state = user_data; + GList *l; + + for (l = state->constraints; l; l = l->next) + { + CoglRendererConstraint constraint = GPOINTER_TO_UINT (l->data); + + /* If the driver doesn't satisfy any constraint then continue + * to the next driver description */ + if (!(constraint & description->constraints)) + return TRUE; + } + + state->driver_description = description; + + return FALSE; +} + static CoglBool _cogl_renderer_choose_driver (CoglRenderer *renderer, CoglError **error) { const char *driver_name = g_getenv ("COGL_DRIVER"); + CoglDriver driver_override = COGL_DRIVER_ANY; + const char *invalid_override = NULL; const char *libgl_name; - CoglBool support_gles2_constraint = FALSE; - GList *l; + SatisfyConstraintsState state; + const CoglDriverDescription *desc; if (!driver_name) driver_name = _cogl_config_driver; - for (l = renderer->constraints; l; l = l->next) + if (driver_name) { - CoglRendererConstraint constraint = GPOINTER_TO_UINT (l->data); - if (constraint == COGL_RENDERER_CONSTRAINT_SUPPORTS_COGL_GLES2) + driver_override = driver_name_to_id (driver_name); + if (driver_override == COGL_DRIVER_ANY) + invalid_override = driver_name; + } + else + driver_override = renderer->driver_override; + + if (driver_override != COGL_DRIVER_ANY) + { + CoglBool found = FALSE; + int i; + + for (i = 0; i < G_N_ELEMENTS (_cogl_drivers); i++) { - support_gles2_constraint = TRUE; - - if (!driver_name && renderer->driver_override == COGL_DRIVER_ANY) - renderer->driver_override = COGL_DRIVER_GLES2; - break; + if (_cogl_drivers[i].id == driver_override) + { + found = TRUE; + break; + } } + if (!found) + invalid_override = driver_id_to_name (driver_override); } -#ifdef COGL_DEFAULT_DRIVER - if (!driver_name) - driver_name = COGL_DEFAULT_DRIVER; -#endif - -#ifdef HAVE_COGL_GL - if (renderer->driver_override == COGL_DRIVER_GL || - (renderer->driver_override == COGL_DRIVER_ANY && - (driver_name == NULL || !g_ascii_strcasecmp (driver_name, "gl")))) - { - renderer->driver = COGL_DRIVER_GL; - libgl_name = COGL_GL_LIBNAME; - goto found; - } - - if (renderer->driver_override == COGL_DRIVER_GL3 || - (renderer->driver_override == COGL_DRIVER_ANY && - (driver_name == NULL || !g_ascii_strcasecmp (driver_name, "gl3")))) - { - renderer->driver = COGL_DRIVER_GL3; - libgl_name = COGL_GL_LIBNAME; - goto found; - } -#endif - -#ifdef HAVE_COGL_GLES2 - if (renderer->driver_override == COGL_DRIVER_GLES2 || - (renderer->driver_override == COGL_DRIVER_ANY && - (driver_name == NULL || !g_ascii_strcasecmp (driver_name, "gles2")))) - { - renderer->driver = COGL_DRIVER_GLES2; - libgl_name = COGL_GLES2_LIBNAME; - goto found; - } -#endif - -#ifdef HAVE_COGL_GLES - if (renderer->driver_override == COGL_DRIVER_GLES1 || - (renderer->driver_override == COGL_DRIVER_ANY && - (driver_name == NULL || !g_ascii_strcasecmp (driver_name, "gles1")))) - { - renderer->driver = COGL_DRIVER_GLES1; - libgl_name = COGL_GLES1_LIBNAME; - goto found; - } -#endif - - if (renderer->driver_override == COGL_DRIVER_NOP || - (renderer->driver_override == COGL_DRIVER_ANY && - (driver_name == NULL || !g_ascii_strcasecmp (driver_name, "nop")))) - { - renderer->driver = COGL_DRIVER_NOP; - libgl_name = NULL; - goto found; - } - - _cogl_set_error (error, - COGL_DRIVER_ERROR, - COGL_DRIVER_ERROR_NO_SUITABLE_DRIVER_FOUND, - "No suitable driver found"); - return FALSE; - -found: - - if (support_gles2_constraint && - renderer->driver != COGL_DRIVER_GLES2) + if (invalid_override) { _cogl_set_error (error, - COGL_RENDERER_ERROR, - COGL_RENDERER_ERROR_BAD_CONSTRAINT, - "No suitable driver found"); + COGL_RENDERER_ERROR, + COGL_RENDERER_ERROR_BAD_CONSTRAINT, + "Driver \"%s\" is not available", + invalid_override); return FALSE; } + state.driver_description = NULL; + state.constraints = renderer->constraints; + + foreach_driver_description (driver_override, + satisfy_constraints, + &state); + + if (!state.driver_description) + { + _cogl_set_error (error, + COGL_RENDERER_ERROR, + COGL_RENDERER_ERROR_BAD_CONSTRAINT, + "No suitable driver found"); + return FALSE; + } + + desc = state.driver_description; + renderer->driver = desc->id; + renderer->driver_vtable = desc->vtable; + renderer->texture_driver = desc->texture_driver; + renderer->private_feature_flags = desc->private_feature_flags; + libgl_name = desc->libgl_name; + #ifndef HAVE_DIRECTLY_LINKED_GL_LIBRARY - if (renderer->driver == COGL_DRIVER_GL || - renderer->driver == COGL_DRIVER_GL3 || - renderer->driver == COGL_DRIVER_GLES1 || - renderer->driver == COGL_DRIVER_GLES2) + if (renderer->private_feature_flags & COGL_PRIVATE_FEATURE_ANY_GL) { renderer->libgl_module = g_module_open (libgl_name, G_MODULE_BIND_LAZY); @@ -384,30 +556,6 @@ found: #endif /* HAVE_DIRECTLY_LINKED_GL_LIBRARY */ - switch (renderer->driver) - { -#ifdef HAVE_COGL_GL - case COGL_DRIVER_GL: - case COGL_DRIVER_GL3: - renderer->driver_vtable = &_cogl_driver_gl; - renderer->texture_driver = &_cogl_texture_driver_gl; - break; -#endif - -#if defined (HAVE_COGL_GLES) || defined (HAVE_COGL_GLES2) - case COGL_DRIVER_GLES1: - case COGL_DRIVER_GLES2: - renderer->driver_vtable = &_cogl_driver_gles; - renderer->texture_driver = &_cogl_texture_driver_gles; - break; -#endif - - case COGL_DRIVER_NOP: - default: - renderer->driver_vtable = &_cogl_driver_nop; - renderer->texture_driver = NULL; - } - return TRUE; } diff --git a/cogl/cogl-texture-3d.c b/cogl/cogl-texture-3d.c index fd1b21e35..697b6c458 100644 --- a/cogl/cogl-texture-3d.c +++ b/cogl/cogl-texture-3d.c @@ -579,7 +579,7 @@ _cogl_texture_3d_pre_paint (CoglTexture *tex, CoglTexturePrePaintFlags flags) if (cogl_has_feature (ctx, COGL_FEATURE_ID_OFFSCREEN)) _cogl_texture_gl_generate_mipmaps (tex); #if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES) - else if (ctx->driver != COGL_DRIVER_GLES2) + else if (ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED) { _cogl_bind_gl_texture_transient (GL_TEXTURE_3D, tex_3d->gl_texture, diff --git a/cogl/driver/gl/cogl-attribute-gl.c b/cogl/driver/gl/cogl-attribute-gl.c index 08354a87c..7d1ce237b 100644 --- a/cogl/driver/gl/cogl-attribute-gl.c +++ b/cogl/driver/gl/cogl-attribute-gl.c @@ -56,7 +56,7 @@ toggle_builtin_attribute_enabled_cb (int bit_num, void *user_data) CoglContext *context = state->context; _COGL_RETURN_VAL_IF_FAIL ((context->private_feature_flags & - COGL_PRIVATE_FEATURE_FIXED_FUNCTION), + COGL_PRIVATE_FEATURE_GL_FIXED), FALSE); #if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES) @@ -93,7 +93,7 @@ toggle_texcood_attribute_enabled_cb (int bit_num, void *user_data) CoglContext *context = state->context; _COGL_RETURN_VAL_IF_FAIL ((context->private_feature_flags & - COGL_PRIVATE_FEATURE_FIXED_FUNCTION), + COGL_PRIVATE_FEATURE_GL_FIXED), FALSE); #if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES) @@ -282,7 +282,7 @@ setup_legacy_buffered_attribute (CoglContext *ctx, break; case COGL_ATTRIBUTE_NAME_ID_CUSTOM_ARRAY: #ifdef COGL_PIPELINE_PROGEND_GLSL - if (ctx->driver != COGL_DRIVER_GLES1) + if (ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE) setup_generic_buffered_attribute (ctx, pipeline, attribute, base); #endif break; @@ -299,7 +299,7 @@ setup_legacy_const_attribute (CoglContext *ctx, #ifdef COGL_PIPELINE_PROGEND_GLSL if (attribute->name_state->name_id == COGL_ATTRIBUTE_NAME_ID_CUSTOM_ARRAY) { - if (ctx->driver != COGL_DRIVER_GLES1) + if (ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE) setup_generic_const_attribute (ctx, pipeline, attribute); } else diff --git a/cogl/driver/gl/cogl-pipeline-fragend-glsl.c b/cogl/driver/gl/cogl-pipeline-fragend-glsl.c index 00e053b42..069a1fee4 100644 --- a/cogl/driver/gl/cogl-pipeline-fragend-glsl.c +++ b/cogl/driver/gl/cogl-pipeline-fragend-glsl.c @@ -1054,8 +1054,7 @@ _cogl_pipeline_fragend_glsl_end (CoglPipeline *pipeline, source_strings[1] = shader_state->source->str; if (shader_state->ref_point_coord && - (ctx->driver == COGL_DRIVER_GL || - ctx->driver == COGL_DRIVER_GL3)) + !(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_EMBEDDED)) version_string = "#version 120\n"; else version_string = NULL; diff --git a/cogl/driver/gl/cogl-pipeline-opengl.c b/cogl/driver/gl/cogl-pipeline-opengl.c index 119b44905..cc3b93c1b 100644 --- a/cogl/driver/gl/cogl-pipeline-opengl.c +++ b/cogl/driver/gl/cogl-pipeline-opengl.c @@ -434,7 +434,7 @@ flush_depth_state (CoglContext *ctx, (ctx->depth_range_near_cache != depth_state->range_near || ctx->depth_range_far_cache != depth_state->range_far)) { - if (ctx->driver == COGL_DRIVER_GLES2) + if (ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_EMBEDDED) GE (ctx, glDepthRangef (depth_state->range_near, depth_state->range_far)); else @@ -487,7 +487,7 @@ _cogl_pipeline_flush_color_blend_alpha_depth_state ( _COGL_GET_CONTEXT (ctx, NO_RETVAL); /* On GLES2 we'll flush the color later */ - if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_FIXED_FUNCTION) && + if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED) && !with_color_attrib) { if ((pipelines_difference & COGL_PIPELINE_STATE_COLOR) || @@ -725,8 +725,7 @@ get_max_activateable_texture_units (void) int i; #ifdef HAVE_COGL_GL - if (ctx->driver == COGL_DRIVER_GL || - ctx->driver == COGL_DRIVER_GL3) + if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_EMBEDDED)) { /* GL_MAX_TEXTURE_COORDS is provided for both GLSL and ARBfp. It defines the number of texture coordinates that can be @@ -749,7 +748,8 @@ get_max_activateable_texture_units (void) #endif /* HAVE_COGL_GL */ #ifdef HAVE_COGL_GLES2 - if (ctx->driver == COGL_DRIVER_GLES2) + if (ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_EMBEDDED && + ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE) { GE (ctx, glGetIntegerv (GL_MAX_VERTEX_ATTRIBS, values + n_values)); /* Two of the vertex attribs need to be used for the position @@ -761,8 +761,8 @@ get_max_activateable_texture_units (void) } #endif -#if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES) /* not GLES2 */ - if (ctx->driver != COGL_DRIVER_GLES2) +#if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES) + if (ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED) { /* GL_MAX_TEXTURE_UNITS defines the number of units that are usable from the fixed function pipeline, therefore it isn't @@ -907,7 +907,7 @@ flush_layers_common_gl_state_cb (CoglPipelineLayer *layer, void *user_data) * glsl progend. */ #if defined (HAVE_COGL_GLES) || defined (HAVE_COGL_GL) - if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_FIXED_FUNCTION) && + if ((ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED) && (layers_difference & COGL_PIPELINE_LAYER_STATE_POINT_SPRITE_COORDS)) { CoglPipelineState change = COGL_PIPELINE_LAYER_STATE_POINT_SPRITE_COORDS; diff --git a/cogl/driver/gl/cogl-pipeline-progend-fixed.c b/cogl/driver/gl/cogl-pipeline-progend-fixed.c index 558b5b803..dc2f63db8 100644 --- a/cogl/driver/gl/cogl-pipeline-progend-fixed.c +++ b/cogl/driver/gl/cogl-pipeline-progend-fixed.c @@ -48,7 +48,7 @@ _cogl_pipeline_progend_fixed_start (CoglPipeline *pipeline) if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_FIXED))) return FALSE; - if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_FIXED_FUNCTION)) + if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED)) return FALSE; /* Vertex snippets are only supported in the GLSL fragend */ diff --git a/cogl/driver/gl/gl/cogl-driver-gl.c b/cogl/driver/gl/gl/cogl-driver-gl.c index 6705159ee..5dc783bb1 100644 --- a/cogl/driver/gl/gl/cogl-driver-gl.c +++ b/cogl/driver/gl/gl/cogl-driver-gl.c @@ -591,7 +591,7 @@ _cogl_driver_update_features (CoglContext *ctx, int max_clip_planes = 0; /* Features which are not available in GL 3 */ - private_flags |= (COGL_PRIVATE_FEATURE_FIXED_FUNCTION | + private_flags |= (COGL_PRIVATE_FEATURE_GL_FIXED | COGL_PRIVATE_FEATURE_ALPHA_TEST | COGL_PRIVATE_FEATURE_QUADS | COGL_PRIVATE_FEATURE_ALPHA_TEXTURES); diff --git a/cogl/driver/gl/gl/cogl-pipeline-progend-fixed-arbfp.c b/cogl/driver/gl/gl/cogl-pipeline-progend-fixed-arbfp.c index fe46a0d0f..45a9f28a8 100644 --- a/cogl/driver/gl/gl/cogl-pipeline-progend-fixed-arbfp.c +++ b/cogl/driver/gl/gl/cogl-pipeline-progend-fixed-arbfp.c @@ -51,7 +51,7 @@ _cogl_pipeline_progend_fixed_arbfp_start (CoglPipeline *pipeline) if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_FIXED))) return FALSE; - if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_FIXED_FUNCTION)) + if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_FIXED)) return FALSE; /* Vertex snippets are only supported in the GLSL fragend */ diff --git a/cogl/driver/gl/gles/cogl-driver-gles.c b/cogl/driver/gl/gles/cogl-driver-gles.c index bdeaa3078..ad9f8d1ba 100644 --- a/cogl/driver/gl/gles/cogl-driver-gles.c +++ b/cogl/driver/gl/gles/cogl-driver-gles.c @@ -262,7 +262,7 @@ _cogl_driver_update_features (CoglContext *context, private_flags |= COGL_PRIVATE_FEATURE_BLEND_CONSTANT; } else if (context->driver == COGL_DRIVER_GLES1) - private_flags |= (COGL_PRIVATE_FEATURE_FIXED_FUNCTION | + private_flags |= (COGL_PRIVATE_FEATURE_GL_FIXED | COGL_PRIVATE_FEATURE_ALPHA_TEST | COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM);