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

cogl/driver/gl: Clean up pre-3.1 checks

Browse Source 
They were just leftovers from times when we didn't require a 3.1
context.

Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/3338>
This commit is contained in:
Robert Mader 2023-10-23 21:37:11 +02:00 committed by Robert Mader
parent 898044b9a5
commit 81c6269ca7
2 changed files with 28 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -47,26 +47,21 @@
static gboolean static gboolean
_cogl_driver_gl_real_context_init (CoglContext *context) _cogl_driver_gl_real_context_init (CoglContext *context)
{ {
GLuint vertex_array;
_cogl_driver_gl_context_init (context); _cogl_driver_gl_context_init (context);
if ((context->driver == COGL_DRIVER_GL3)) /* In a forward compatible context, GL 3 doesn't support rendering
{ * using the default vertex array object. Cogl doesn't use vertex
GLuint vertex_array; * array objects yet so for now we just create a dummy array
* object that we will use as our own default object. Eventually
/* In a forward compatible context, GL 3 doesn't support rendering * it could be good to attach the vertex array objects to
* using the default vertex array object. Cogl doesn't use vertex * CoglPrimitives */
* array objects yet so for now we just create a dummy array context->glGenVertexArrays (1, &vertex_array);
* object that we will use as our own default object. Eventually context->glBindVertexArray (vertex_array);
* it could be good to attach the vertex array objects to
* CoglPrimitives */
context->glGenVertexArrays (1, &vertex_array);
context->glBindVertexArray (vertex_array);
}
/* There's no enable for this in GLES2, it's always on */ /* There's no enable for this in GLES2, it's always on */
if (context->driver == COGL_DRIVER_GL3) GE (context, glEnable (GL_PROGRAM_POINT_SIZE) );
GE (context, glEnable (GL_PROGRAM_POINT_SIZE) );
return TRUE; return TRUE;
} }
@ -89,20 +84,11 @@ _cogl_driver_pixel_format_to_gl (CoglContext *context,
switch (format) switch (format)
{ {
case COGL_PIXEL_FORMAT_A_8: case COGL_PIXEL_FORMAT_A_8:
/* If the driver doesn't natively support alpha textures then we /* The driver doesn't natively support alpha textures so we
* will use a red component texture with a swizzle to implement * will use a red component texture with a swizzle to implement
* the texture */ * the texture */
if (_cogl_has_private_feature glintformat = GL_RED;
(context, COGL_PRIVATE_FEATURE_ALPHA_TEXTURES) == 0) glformat = GL_RED;
{
glintformat = GL_RED;
glformat = GL_RED;
}
else
{
glintformat = GL_ALPHA;
glformat = GL_ALPHA;
}
gltype = GL_UNSIGNED_BYTE; gltype = GL_UNSIGNED_BYTE;
break; break;
case COGL_PIXEL_FORMAT_G_8: case COGL_PIXEL_FORMAT_G_8:
@ -112,22 +98,8 @@ _cogl_driver_pixel_format_to_gl (CoglContext *context,
break; break;
case COGL_PIXEL_FORMAT_RG_88: case COGL_PIXEL_FORMAT_RG_88:
if (cogl_has_feature (context, COGL_FEATURE_ID_TEXTURE_RG)) glintformat = GL_RG;
{ glformat = GL_RG;
glintformat = GL_RG;
glformat = GL_RG;
}
else
{
/* If red-green textures aren't supported then we'll use RGB
* as an internal format. Note this should only end up
* mattering for downloading the data because Cogl will
* refuse to allocate a texture with RG components if RG
* textures aren't supported */
glintformat = GL_RGB;
glformat = GL_RGB;
required_format = COGL_PIXEL_FORMAT_RGB_888;
}
gltype = GL_UNSIGNED_BYTE; gltype = GL_UNSIGNED_BYTE;
break; break;
@ -389,13 +361,12 @@ check_gl_version (CoglContext *ctx,
return FALSE; return FALSE;
} }
/* We require GLSL 1.20, which is implied by OpenGL 2.1. */ if (!COGL_CHECK_GL_VERSION (major, minor, 3, 1))
if (!COGL_CHECK_GL_VERSION (major, minor, 2, 1))
{ {
g_set_error (error, g_set_error (error,
COGL_DRIVER_ERROR, COGL_DRIVER_ERROR,
COGL_DRIVER_ERROR_INVALID_VERSION, COGL_DRIVER_ERROR_INVALID_VERSION,
"OpenGL 2.1 or better is required"); "OpenGL 3.1 or better is required");
return FALSE; return FALSE;
} }
@ -475,21 +446,11 @@ _cogl_driver_update_features (CoglContext *ctx,
COGL_FLAGS_SET (private_features, COGL_FLAGS_SET (private_features,
COGL_PRIVATE_FEATURE_MESA_PACK_INVERT, TRUE); COGL_PRIVATE_FEATURE_MESA_PACK_INVERT, TRUE);
if (!ctx->glGenRenderbuffers)
{
g_set_error (error,
COGL_DRIVER_ERROR,
COGL_DRIVER_ERROR_NO_SUITABLE_DRIVER_FOUND,
"Framebuffer objects are required to use the GL driver");
return FALSE;
}
COGL_FLAGS_SET (private_features, COGL_FLAGS_SET (private_features,
COGL_PRIVATE_FEATURE_QUERY_FRAMEBUFFER_BITS, COGL_PRIVATE_FEATURE_QUERY_FRAMEBUFFER_BITS,
TRUE); TRUE);
if (ctx->glBlitFramebuffer) COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_BLIT_FRAMEBUFFER, TRUE);
COGL_FLAGS_SET (ctx->features,
COGL_FEATURE_ID_BLIT_FRAMEBUFFER, TRUE);
COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_PBOS, TRUE); COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_PBOS, TRUE);
@ -500,9 +461,8 @@ _cogl_driver_update_features (CoglContext *ctx,
COGL_FLAGS_SET (private_features, COGL_FLAGS_SET (private_features,
COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE, TRUE); COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE, TRUE);
if (_cogl_check_extension ("GL_EXT_packed_depth_stencil", gl_extensions)) COGL_FLAGS_SET (private_features,
COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL, TRUE);
COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL, TRUE);
if (ctx->glGenSamplers) if (ctx->glGenSamplers)
COGL_FLAGS_SET (private_features, COGL_FLAGS_SET (private_features,
@ -524,29 +484,19 @@ _cogl_driver_update_features (CoglContext *ctx,
COGL_FLAGS_SET (private_features, COGL_FLAGS_SET (private_features,
COGL_PRIVATE_FEATURE_TEXTURE_MAX_LEVEL, TRUE); COGL_PRIVATE_FEATURE_TEXTURE_MAX_LEVEL, TRUE);
if (COGL_CHECK_GL_VERSION (gl_major, gl_minor, 3, 1) || COGL_FLAGS_SET (private_features,
_cogl_check_extension ("GL_EXT_texture_lod_bias", gl_extensions)) COGL_PRIVATE_FEATURE_TEXTURE_LOD_BIAS, TRUE);
{
COGL_FLAGS_SET (private_features,
COGL_PRIVATE_FEATURE_TEXTURE_LOD_BIAS, TRUE);
}
if (ctx->glFenceSync) if (ctx->glFenceSync)
COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_FENCE, TRUE); COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_FENCE, TRUE);
if (COGL_CHECK_GL_VERSION (gl_major, gl_minor, 3, 0) || COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_TEXTURE_RG, TRUE);
_cogl_check_extension ("GL_ARB_texture_rg", gl_extensions))
COGL_FLAGS_SET (ctx->features,
COGL_FEATURE_ID_TEXTURE_RG,
TRUE);
COGL_FLAGS_SET (private_features, COGL_FLAGS_SET (private_features,
COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_RGBA1010102, TRUE); COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_RGBA1010102, TRUE);
if (COGL_CHECK_GL_VERSION (gl_major, gl_minor, 3, 0)) COGL_FLAGS_SET (private_features,
COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_HALF_FLOAT, TRUE);
COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_HALF_FLOAT,
TRUE);
if (ctx->glGenQueries && ctx->glQueryCounter && ctx->glGetInteger64v) if (ctx->glGenQueries && ctx->glQueryCounter && ctx->glGetInteger64v)
COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_TIMESTAMP_QUERY, TRUE); COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_TIMESTAMP_QUERY, TRUE);

18
cogl/cogl/driver/gl/gl/cogl-texture-driver-gl.c
View File

@ -76,11 +76,7 @@ _cogl_texture_driver_gen (CoglContext *ctx,
* level to 0 so OpenGL will consider the texture storage to be * level to 0 so OpenGL will consider the texture storage to be
* "complete". * "complete".
*/ */
#ifdef HAVE_COGL_GL GE( ctx, glTexParameteri (gl_target, GL_TEXTURE_MAX_LEVEL, 0));
if (_cogl_has_private_feature
(ctx, COGL_PRIVATE_FEATURE_TEXTURE_MAX_LEVEL))
GE( ctx, glTexParameteri (gl_target, GL_TEXTURE_MAX_LEVEL, 0));
#endif
/* GL_TEXTURE_MAG_FILTER defaults to GL_LINEAR, no need to set it */ /* GL_TEXTURE_MAG_FILTER defaults to GL_LINEAR, no need to set it */
GE( ctx, glTexParameteri (gl_target, GE( ctx, glTexParameteri (gl_target,
@ -97,10 +93,9 @@ _cogl_texture_driver_gen (CoglContext *ctx,
g_assert_not_reached(); g_assert_not_reached();
} }
/* If the driver doesn't support alpha textures directly then we'll /* As the driver doesn't support alpha textures directly then we'll
* fake them by setting the swizzle parameters */ * fake them by setting the swizzle parameters */
if (internal_format == COGL_PIXEL_FORMAT_A_8 && if (internal_format == COGL_PIXEL_FORMAT_A_8 &&
!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_ALPHA_TEXTURES) &&
_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_TEXTURE_SWIZZLE)) _cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_TEXTURE_SWIZZLE))
{ {
static const GLint red_swizzle[] = { GL_ZERO, GL_ZERO, GL_ZERO, GL_RED }; static const GLint red_swizzle[] = { GL_ZERO, GL_ZERO, GL_ZERO, GL_RED };
@ -377,10 +372,8 @@ _cogl_texture_driver_size_supported (CoglContext *ctx,
if (gl_target == GL_TEXTURE_2D) if (gl_target == GL_TEXTURE_2D)
proxy_target = GL_PROXY_TEXTURE_2D; proxy_target = GL_PROXY_TEXTURE_2D;
#ifdef HAVE_COGL_GL
else if (gl_target == GL_TEXTURE_RECTANGLE_ARB) else if (gl_target == GL_TEXTURE_RECTANGLE_ARB)
proxy_target = GL_PROXY_TEXTURE_RECTANGLE_ARB; proxy_target = GL_PROXY_TEXTURE_RECTANGLE_ARB;
#endif
else else
/* Unknown target, assume it's not supported */ /* Unknown target, assume it's not supported */
return FALSE; return FALSE;
@ -434,7 +427,6 @@ _cogl_texture_driver_upload_supported (CoglContext *ctx,
case COGL_PIXEL_FORMAT_RGBA_4444_PRE: case COGL_PIXEL_FORMAT_RGBA_4444_PRE:
case COGL_PIXEL_FORMAT_RGBA_5551: case COGL_PIXEL_FORMAT_RGBA_5551:
case COGL_PIXEL_FORMAT_RGBA_5551_PRE: case COGL_PIXEL_FORMAT_RGBA_5551_PRE:
return TRUE;
case COGL_PIXEL_FORMAT_BGRX_FP_16161616: case COGL_PIXEL_FORMAT_BGRX_FP_16161616:
case COGL_PIXEL_FORMAT_BGRA_FP_16161616: case COGL_PIXEL_FORMAT_BGRA_FP_16161616:
case COGL_PIXEL_FORMAT_XRGB_FP_16161616: case COGL_PIXEL_FORMAT_XRGB_FP_16161616:
@ -447,11 +439,7 @@ _cogl_texture_driver_upload_supported (CoglContext *ctx,
case COGL_PIXEL_FORMAT_RGBX_FP_16161616: case COGL_PIXEL_FORMAT_RGBX_FP_16161616:
case COGL_PIXEL_FORMAT_RGBA_FP_16161616: case COGL_PIXEL_FORMAT_RGBA_FP_16161616:
case COGL_PIXEL_FORMAT_RGBA_FP_16161616_PRE: case COGL_PIXEL_FORMAT_RGBA_FP_16161616_PRE:
if (_cogl_has_private_feature return TRUE;
(ctx, COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_HALF_FLOAT))
return TRUE;
else
return FALSE;
case COGL_PIXEL_FORMAT_G_16: case COGL_PIXEL_FORMAT_G_16:
case COGL_PIXEL_FORMAT_RG_1616: case COGL_PIXEL_FORMAT_RG_1616:
case COGL_PIXEL_FORMAT_DEPTH_16: case COGL_PIXEL_FORMAT_DEPTH_16: