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

generalize driver description and selection

Browse Source 
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 <neil@linux.intel.com>

(cherry picked from commit e07d0fc7441dddc3f0a2bc33a6a37d62ddc3efc0)
This commit is contained in:
Robert Bragg 2013-05-11 18:15:25 +01:00
parent bd3dce4af1
commit 34658ea057
14 changed files with 302 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cogl/cogl-context.c
View File

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

2
cogl/cogl-glsl-shader.c
View File

@ -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[] =

4
cogl/cogl-matrix-stack.c
View File

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

38
cogl/cogl-private.h
View File

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

1
cogl/cogl-renderer-private.h
View File

@ -70,6 +70,7 @@ struct _CoglRenderer
#endif
CoglDriver driver;
CoglPrivateFeatureFlags private_feature_flags;
#ifndef HAVE_DIRECTLY_LINKED_GL_LIBRARY
GModule *libgl_module;
#endif

342
cogl/cogl-renderer.c
View File

@ -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,97 +340,188 @@ 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)
{
support_gles2_constraint = TRUE;
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_name && renderer->driver_override == COGL_DRIVER_ANY)
renderer->driver_override = COGL_DRIVER_GLES2;
if (driver_override != COGL_DRIVER_ANY)
{
CoglBool found = FALSE;
int i;
for (i = 0; i < G_N_ELEMENTS (_cogl_drivers); i++)
{
if (_cogl_drivers[i].id == driver_override)
{
found = TRUE;
break;
}
}
#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 (!found)
invalid_override = driver_id_to_name (driver_override);
}
if (renderer->driver_override == COGL_DRIVER_GL3 ||
(renderer->driver_override == COGL_DRIVER_ANY &&
(driver_name == NULL || !g_ascii_strcasecmp (driver_name, "gl3"))))
if (invalid_override)
{
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");
COGL_RENDERER_ERROR,
COGL_RENDERER_ERROR_BAD_CONSTRAINT,
"Driver \"%s\" is not available",
invalid_override);
return FALSE;
}
found:
state.driver_description = NULL;
state.constraints = renderer->constraints;
if (support_gles2_constraint &&
renderer->driver != COGL_DRIVER_GLES2)
foreach_driver_description (driver_override,
satisfy_constraints,
&state);
if (!state.driver_description)
{
_cogl_set_error (error,
COGL_RENDERER_ERROR,
@ -362,12 +530,16 @@ 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;
}

2
cogl/cogl-texture-3d.c
View File

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

8
cogl/driver/gl/cogl-attribute-gl.c
View File

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

3
cogl/driver/gl/cogl-pipeline-fragend-glsl.c
View File

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

16
cogl/driver/gl/cogl-pipeline-opengl.c
View File

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

2
cogl/driver/gl/cogl-pipeline-progend-fixed.c
View File

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

2
cogl/driver/gl/gl/cogl-driver-gl.c
View File

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

2
cogl/driver/gl/gl/cogl-pipeline-progend-fixed-arbfp.c
View File

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

2
cogl/driver/gl/gles/cogl-driver-gles.c
View File

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